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

media/base/android/java/src/org/chromium/media/AudioManagerAndroid.java

 // Copyright 2013 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.
 
 package org.chromium.media;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.media.AudioFormat;
 import android.media.AudioManager;
+import android.media.AudioRecord;
+import android.media.AudioTrack;
 import android.os.Build;
 import android.util.Log;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 @JNINamespace("media")
 class AudioManagerAndroid {
     private static final String TAG = AudioManagerAndroid.class.getSimpleName();
+
     // Most of Google lead devices use 44.1K as the default sampling rate, 44.1K
     // is also widely used on other android devices.
     private static final int DEFAULT_SAMPLING_RATE = 44100;
+    // Randomly picked up frame size which is close to return value on N4.
+    // Return this default value when
+    // getProperty(PROPERTY_OUTPUT_FRAMES_PER_BUFFER) fails.
+    private static final int DEFAULT_FRAME_PER_BUFFER = 256;
 
     private final AudioManager mAudioManager;
     private final Context mContext;
 
     private BroadcastReceiver mReceiver;
     private boolean mOriginalSpeakerStatus;
 
     @CalledByNative
     public void setMode(int mode) {
         try {
@@ skipping 40 matching lines @@
         mContext.registerReceiver(mReceiver, filter);
     }
 
     @CalledByNative
     public void unregisterHeadsetReceiver() {
         mContext.unregisterReceiver(mReceiver);
         mReceiver = null;
         mAudioManager.setSpeakerphoneOn(mOriginalSpeakerStatus);
     }
 
+    private void logDeviceInfo() {
+        Log.i(TAG, "Manufacturer:" + Build.MANUFACTURER +
+                  " Board: " + Build.BOARD + " Device: " + Build.DEVICE +

[qinmin, 2013/05/23 16:27:39]

nit: fix the indentation

[leozwang1, 2013/05/23 21:13:46]

Done.

+                  " Model: " + Build.MODEL + " PRODUCT: " + Build.PRODUCT);
+    }
+
     @CalledByNative
-    public int getNativeOutputSampleRate() {
+    private int getNativeOutputSampleRate() {
         if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
             String sampleRateString = mAudioManager.getProperty(
                     AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE);
             return (sampleRateString == null ?
                     DEFAULT_SAMPLING_RATE : Integer.parseInt(sampleRateString));
         } else {
             return DEFAULT_SAMPLING_RATE;
         }
     }
 
-    private void logDeviceInfo() {
-        Log.i(TAG, "Manufacturer:" + Build.MANUFACTURER +
-                  " Board: " + Build.BOARD + " Device: " + Build.DEVICE +
-                  " Model: " + Build.MODEL + " PRODUCT: " + Build.PRODUCT);
+    @CalledByNative
+    private static int getMinInputBufSize(int sampleRate, int channels) {

[no longer working on chromium, 2013/05/22 21:00:00]

I am wondering if you really need the |channels| to get the buffer size, I would
guess that you will get the same result regardless channels ==1 or channels == 2
here.

[leozwang1, 2013/05/22 21:03:41]

java api takes number of channel as the input parameter and indeed adjusts the
size based on the input.

[no longer working on chromium, 2013/05/22 21:21:37]

I know, but please note that you divide the return value by the channels later,
for example :
Java_AudioManagerAndroid_getMinInputBufSize(
     base::android::AttachCurrentThread(), rate, channels) /
        sizeof(int16) / channels

[leozwang1, 2013/05/22 21:27:42]

which converts size in bytes to frames. I think I have comments about it.

[no longer working on chromium, 2013/05/22 21:41:53]

Right, that is exactly what I am trying to say, we are getting the same value in
terms of frames for mono and stereo.

For example, for mono, we are getting 512 as the returned value of
getMinInputBufSize(sample_rate, 1) here, and
AudioManagerAndroid::GetMinInputFrameSize() will return 256.
For stereo, we will get 1024 from getMinInputBufSize(sample_rate, 2), but the
return value of AudioManagerAndroid::GetMinInputFrameSize() is still 256.

+        int channelConfig;
+        if (channels == 1) {
+            channelConfig = AudioFormat.CHANNEL_IN_MONO;
+        } else if (channels == 2) {
+            channelConfig = AudioFormat.CHANNEL_IN_STEREO;
+        } else {
+            return -1;
+        }
+        return AudioRecord.getMinBufferSize(sampleRate, channelConfig,
+                                            AudioFormat.ENCODING_PCM_16BIT);
     }
+
+    @CalledByNative
+    private static int getMinOutputBufSize(int sampleRate, int channels) {

[no longer working on chromium, 2013/05/22 21:00:00]

the same here, could you please verify it?

+        int channelConfig;
+        if (channels == 1) {
+            channelConfig = AudioFormat.CHANNEL_OUT_MONO;
+        } else if (channels == 2) {
+            channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
+        } else {
+            return -1;
+        }
+        return AudioTrack.getMinBufferSize(sampleRate, channelConfig,
+                                           AudioFormat.ENCODING_PCM_16BIT);
+    }
+
+    @CalledByNative
+    private boolean isAudioLowLatencySupported() {
+        return mContext.getPackageManager().hasSystemFeature(
+                PackageManager.FEATURE_AUDIO_LOW_LATENCY);
+    }
+
+    @CalledByNative
+    private int getAudioLowLatencyFrameSize() {
+        String framesPerBuffer =
+                mAudioManager.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER);
+        return (framesPerBuffer == null ?
+                DEFAULT_FRAME_PER_BUFFER : Integer.parseInt(framesPerBuffer));
+    }
+
 }