Using native sampling rate and optimal buffer size for audio on Android.

media/audio/android/audio_manager_android.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/android/audio_manager_android.h"
 
 #include "base/logging.h"
 #include "jni/AudioManagerAndroid_jni.h"
 #include "media/audio/android/opensles_input.h"
 #include "media/audio/android/opensles_output.h"
@@ skipping 38 matching lines @@
 
 void AudioManagerAndroid::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   device_names->push_front(
       media::AudioDeviceName(kDefaultDeviceName, kDefaultDeviceId));
 }
 
 AudioParameters AudioManagerAndroid::GetInputStreamParameters(
     const std::string& device_id) {
-  // TODO(leozwang): Android defines the minimal buffer size requirment
-  // we should use it.
   static const int kDefaultBufferSize = 1024;
-  // TODO(xians): query the native channel layout for the specific device.
+  int size = GetMinInputFrameSize(GetNativeOutputSampleRate(), 2);

[no longer working on chromium, 2013/05/20 09:59:26]

nit, size -> buffer_size

[leozwang1, 2013/05/20 17:41:05]

Done.

   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
-      GetNativeOutputSampleRate(), 16, kDefaultBufferSize);
+      GetNativeOutputSampleRate(), 16, size <= 0 ? kDefaultBufferSize : size);
 }
 
 AudioOutputStream* AudioManagerAndroid::MakeAudioOutputStream(
     const AudioParameters& params) {
   AudioOutputStream* stream =
     AudioManagerBase::MakeAudioOutputStream(params);
   if (stream && output_stream_count() == 1)
     RegisterHeadsetReceiver();
   return stream;
 }
@@ skipping 36 matching lines @@
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return new OpenSLESInputStream(this, params);
 }
 
 AudioInputStream* AudioManagerAndroid::MakeLowLatencyInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   return new OpenSLESInputStream(this, params);
 }
 
+int AudioManagerAndroid::GetAudioOptimalOutputFrameSize(int sample_rate,

[no longer working on chromium, 2013/05/20 09:59:26]

nit, s/GetAudioOptimalOutputFrameSize/GetOptimalOutputFrameSize/g

[leozwang1, 2013/05/20 17:41:05]

Done.

+                                                        int channels) {
+  const int kTargetFrameSize = 2048;

[no longer working on chromium, 2013/05/20 09:59:26]

kTargetFrameSize is the same as kDefaultBufferSize, move kDefaultBufferSize to
global and use it instead

[leozwang1, 2013/05/20 17:41:05]

Done.

+  if (IsAudioLowLatencySupported()) {
+    int frame_size = GetAudioLowLatencyFrameSize();
+    // Return the optimal size as a multiple of the low latency frame
+    // size that is close to the target frame size.
+    return ((kTargetFrameSize + frame_size / 2) / frame_size) * frame_size;

[no longer working on chromium, 2013/05/20 09:59:26]

I have to admit that I am not familiar with PROPERTY_OUTPUT_FRAMES_PER_BUFFER,
not sure why it is "optimal" to be a multiple of the number, could you please
elaborate the reasons of doing so and why kTargetFrameSize is 2048?
More explicitly, why not do it this way?
const int kNumberBuffers = 4; // or whatever, decided from testing.
reutrn kNumberBuffers * frame_size;

[leozwang1, 2013/05/20 17:41:05]

In order to achieve to "low latency", the buffer size must be a multiple of the
buffer size returned by GetAudioLowLatencyFrameSize(). I think audiofligner
implements in this way to achieve low latency. Probably it's not the best answer
to your Q, but let me know if you need more info or we can discuss offline.

[no longer working on chromium, 2013/05/21 21:52:32]

I understand that it needs to be a multiple of GetAudioLowLatencyFrameSize(),
but my question is why not doing it this way?
const int kLowLatencyNumberBuffers = 4; // or whatever.
return kLowLatencyNumberBuffers * frame_size; 

[Raymond Toy (Google), 2013/05/21 22:00:27]

The low latency frame size varies quite a bit depending on the device: 144 for
Galaxy Nexus, 256 for Nexus 7(?), and 800 or so for Nexus S.  A fixed number of
buffers would probably make some devices have too large or too small a size.  

This is a compromise so that all devices get a size of about 2048 frames.

+  } else

[no longer working on chromium, 2013/05/20 09:59:26]

nit, add { }

[leozwang1, 2013/05/20 17:41:05]

Done.

+    return std::max(kTargetFrameSize,
+                    GetMinOutputFrameSize(sample_rate, channels));
+}
+
 AudioParameters AudioManagerAndroid::GetPreferredOutputStreamParameters(
     const AudioParameters& input_params) {
-  // TODO(leozwang): Android defines the minimal buffer size requirment
-  // we should use it.
   static const int kDefaultBufferSize = 2048;
-
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int sample_rate = GetNativeOutputSampleRate();
-  int buffer_size = kDefaultBufferSize;
+  int buffer_size = GetAudioOptimalOutputFrameSize(sample_rate, 2);
   int bits_per_sample = 16;
   int input_channels = 0;
   if (input_params.IsValid()) {
     // Use the client's input parameters if they are valid.
     sample_rate = input_params.sample_rate();
     bits_per_sample = input_params.bits_per_sample();
     channel_layout = input_params.channel_layout();
     input_channels = input_params.input_channels();
-
-    buffer_size = std::min(buffer_size, input_params.frames_per_buffer());
+    buffer_size = buffer_size <= 0 ? kDefaultBufferSize : buffer_size;

[no longer working on chromium, 2013/05/20 09:59:26]

how buffer_size can be <= 0?

[leozwang1, 2013/05/20 17:41:05]

good catch, it was latency code, removed it.

   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels,
       sample_rate, bits_per_sample, buffer_size);
 }
@@ skipping 14 matching lines @@
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 void AudioManagerAndroid::UnregisterHeadsetReceiver() {
   Java_AudioManagerAndroid_unregisterHeadsetReceiver(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 int AudioManagerAndroid::GetNativeOutputSampleRate() {

[no longer working on chromium, 2013/05/20 09:59:26]

Does GetNativeOutputSampleRate() get the native sample rate based on the device
currently being used? Or it is some number used by the audioflinger?
In case it is the sample rate used by the audioflinger, cache the value and only
query the hardware at the first times.

[leozwang1, 2013/05/20 17:41:05]

Then we could also cache all return value from GetBufferSize apis. Because these
apis are not experience, maybe we can keep them can call them as needed?

   return Java_AudioManagerAndroid_getNativeOutputSampleRate(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
+int AudioManagerAndroid::GetMinInputFrameSize(int rate, int channels) {

[no longer working on chromium, 2013/05/20 09:59:26]

could you please add comments here, to explain why the buffer size needs to
divide /2 / channels?

[leozwang1, 2013/05/20 17:41:05]

Done.

+  return Java_AudioManagerAndroid_getMinInputBufSize(
+      base::android::AttachCurrentThread(), rate, channels) / 2 / channels;

[no longer working on chromium, 2013/05/20 09:59:26]

nit, use sizeof(int16) instead of 2

[leozwang1, 2013/05/20 17:41:05]

Done.

+}
+
+int AudioManagerAndroid::GetMinOutputFrameSize(int rate, int channels) {
+  // Get buffer size in frames, assuming 16-bit pcm samples.
+  return Java_AudioManagerAndroid_getMinOutputBufSize(
+      base::android::AttachCurrentThread(), rate, channels) / 2 / channels;
+}
+
+bool AudioManagerAndroid::IsAudioLowLatencySupported() {

[no longer working on chromium, 2013/05/20 09:59:26]

I don't think you need a separate IsAudioLowLatencySupported(), merge it to
GetAudioLowLatencyFrameSize

[leozwang1, 2013/05/20 17:41:05]

Currently it's called once, but it's just wrapper of java api, we might need to
call it in different use cases, for example, if IsLowLentencyDevice we do some
specially. I prefer to keep it a separated api for now.

+  return Java_AudioManagerAndroid_isAudioLowLatencySupported(
+      base::android::AttachCurrentThread(),
+      j_audio_manager_.obj());
+}
+
+int AudioManagerAndroid::GetAudioLowLatencyFrameSize() {
+  return Java_AudioManagerAndroid_getAudioLowLatencyFrameSize(
+      base::android::AttachCurrentThread(),
+      j_audio_manager_.obj());
+}
+
 }  // namespace media