【如何在不同Android设备中得到有效的AudioRecord实例】

bill最近在倒腾Android上录制声音的API——AudioRecord。但始终得到初始化失败的异常（最终原因是各大android设备所支持的音频采样率、声道数等不尽相同，虽然google官方说44100Hz是所有设备均支持的，但实际上......），甚是恼火。在stackoverflow上找到了灵感，并最终在Michael-Pardo的博客里发现了一个简洁且设计较好的工具类——AudioMeter。
Pardo对类的描述是AudioMeter包裹了AudioRecord，但bill在阅读后发现AudioMeter实际上隐藏了AudioRecord的接口（如read），当然Pardo的软件可能并不需要read接口，但作为AudioRecord的倒腾者，bill是需要的，因此对AudioMeter做了轻量级修改，开放了AudioRecord的部分常用接口，使用起来也比较方便，现分享出来，希望更多的朋友受益于此，大家可以根据自己的需要完善、扩充这个工具类：
                            import java.nio.ByteBuffer; 
                 
                import android.media.AudioFormat; 
                import android.media.AudioRecord; 
                import android.media.MediaRecorder.AudioSource; 
                import android.os.Process; 
                 
                /** 
                 * Basically what this class does is construct a valid AudioRecord Object, wrap AudioRecord methods, and provide 
                 * conversion to decibels. It also caches the AudioRecord configuration and prevents multiple instances of the recorder. 
                 *  
                 * @author Michael-Pardo/billhoo 
                 * @version 0.1 2013-2-18 
                 */ 
                // TODO(billhoo) the AudioMeter.createAudioRecord() method always returned the first matched configuration currently, 
                // if the first combination [8000Hz + PCM16 + IN_MONO] is valid, method returns, but there is no way if I wanna use 
                // 16000Hz instead, so this method should be changed to a clever one in the future. 
                public class AudioMeter extends Thread { 
                 
                    // /////////////////////////////////////////////////////////////// 
                    // PRIVATE CONSTANTS 
                 
                    private static final float MAX_REPORTABLE_AMP = 32767f; 
                    private static final float MAX_REPORTABLE_DB  = 90.3087f; 
                 
                    // /////////////////////////////////////////////////////////////// 
                    // PRIVATE MEMBERS 
                 
                    private AudioRecord        mAudioRecord; 
                    private int                mSampleRate; 
                    private short              mAudioFormat; 
                    private short              mChannelConfig; 
                 
                    private short[]            mBuffer; 
                    private int                mBufferSize        = AudioRecord.ERROR_BAD_VALUE; 
                 
                    private int                mLocks             = 0; 
                 
                    // /////////////////////////////////////////////////////////////// 
                    // CONSTRUCTOR 
                 
                    private AudioMeter() { 
                        Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO); // set the AudioMeter thread in URGENT_AUDIO 
                                                                                         // priority. 
                        createAudioRecord(); 
                    } 
                 
                    // /////////////////////////////////////////////////////////////// 
                    // PUBLIC METHODS 
                 
                    public static AudioMeter getInstance() { 
                        return InstanceHolder.INSTANCE; 
                    } 
                 
                    public float getAmplitude() { 
                        return (float) (MAX_REPORTABLE_DB + (20 * Math.log10(getRawAmplitude() 
                                / MAX_REPORTABLE_AMP))); 
                    } 
                 
                    public synchronized void startRecording() { 
                        if (mAudioRecord == null 
                                || mAudioRecord.getState() != AudioRecord.STATE_INITIALIZED) { 
                            throw new IllegalStateException( 
                                    "startRecording() called on an uninitialized AudioRecord."); 
                        } 
                 
                        if (mLocks == 0) { 
                            mAudioRecord.startRecording(); 
                        } 
                 
                        mLocks++; 
                    } 
                 
                    public synchronized void stopRecording() { 
                        mLocks--; 
                 
                        if (mLocks == 0) { 
                            if (mAudioRecord != null) { 
                                mAudioRecord.stop(); 
                                mAudioRecord.release(); 
                                mAudioRecord = null; 
                            } 
                        } 
                    } 
                 
                    /** 
                     * Reads audio data from the audio hardware for recording into a direct buffer. If this buffer is not a direct 
                     * buffer, this method will always return 0. 
                     *  
                     * @param audioBuffer 
                     *            the direct buffer to which the recorded audio data is written. 
                     * @param sizeInBytes 
                     *            the number of requested bytes. 
                     * @return the number of bytes that were read or or {@link #ERROR_INVALID_OPERATION} if the object wasn't properly 
                     *         initialized, or {@link #ERROR_BAD_VALUE} if the parameters don't resolve to valid data and indexes. The 
                     *         number of bytes will not exceed sizeInBytes. 
                     */ 
                    public int read(ByteBuffer audioBuffer, int sizeInBytes) { 
                        return mAudioRecord.read(audioBuffer, sizeInBytes); 
                    } 
                 
                    /** 
                     * Reads audio data from the audio hardware for recording into a buffer. 
                     *  
                     * @param audioData 
                     *            the array to which the recorded audio data is written. 
                     * @param offsetInShorts 
                     *            index in audioData from which the data is written expressed in shorts. 
                     * @param sizeInShorts 
                     *            the number of requested shorts. 
                     * @return the number of shorts that were read or or {@link #ERROR_INVALID_OPERATION} if the object wasn't properly 
                     *         initialized, or {@link #ERROR_BAD_VALUE} if the parameters don't resolve to valid data and indexes. The 
                     *         number of shorts will not exceed sizeInShorts. 
                     */ 
                    public int read(short[] audioData, int offsetInShorts, int sizeInShorts) { 
                        return mAudioRecord.read(audioData, offsetInShorts, sizeInShorts); 
                    } 
                 
                    /** 
                     * Reads audio data from the audio hardware for recording into a buffer. 
                     *  
                     * @param audioData 
                     *            the array to which the recorded audio data is written. 
                     * @param offsetInBytes 
                     *            index in audioData from which the data is written expressed in bytes. 
                     * @param sizeInBytes 
                     *            the number of requested bytes. 
                     * @return the number of bytes that were read or or {@link #ERROR_INVALID_OPERATION} if the object wasn't properly 
                     *         initialized, or {@link #ERROR_BAD_VALUE} if the parameters don't resolve to valid data and indexes. The 
                     *         number of bytes will not exceed sizeInBytes. 
                     */ 
                    public int read(byte[] audioData, int offsetInBytes, int sizeInBytes) { 
                        return mAudioRecord.read(audioData, offsetInBytes, sizeInBytes); 
                    } 
                 
                    /** 
                     * Returns the configured audio data sample rate in Hz 
                     */ 
                    public int getSampleRate() { 
                        return mSampleRate; 
                    } 
                 
                    /** 
                     * Returns the configured audio data format. See {@link AudioFormat#ENCODING_PCM_16BIT} and 
                     * {@link AudioFormat#ENCODING_PCM_8BIT}. 
                     */ 
                    public int getAudioFormat() { 
                        return mAudioFormat; 
                    } 
                 
                    /** 
                     * Returns the configured channel configuration. See {@link AudioFormat#CHANNEL_IN_MONO} and 
                     * {@link AudioFormat#CHANNEL_IN_STEREO}. 
                     */ 
                    public int getChannelConfiguration() { 
                        return mChannelConfig; 
                    } 
                 
                    /** 
                     * Returns the state of the AudioRecord instance. This is useful after the AudioRecord instance has been created to 
                     * check if it was initialized properly. This ensures that the appropriate hardware resources have been acquired. 
                     *  
                     * @see AudioRecord#STATE_INITIALIZED 
                     * @see AudioRecord#STATE_UNINITIALIZED 
                     */ 
                    public int getAudioRecordState() { 
                        return mAudioRecord.getState(); 
                    } 
                 
                    // /////////////////////////////////////////////////////////////// 
                    // PRIVATE METHODS 
                 
                    private void createAudioRecord() { 
                        if (mSampleRate > 0 && mAudioFormat > 0 && mChannelConfig > 0) { 
                            mAudioRecord = new AudioRecord(AudioSource.MIC, mSampleRate, 
                                    mChannelConfig, mAudioFormat, mBufferSize); 
                            return; 
                        } 
                 
                        // TODO(billhoo) should try user's specific combinations first, if it's invalid, then do for loop to get a 
                        // available combination instead. 
                 
                        // Find best/compatible AudioRecord 
                        // If all combinations are invalid, throw IllegalStateException 
                        for (int sampleRate : new int[] { 8000, 11025, 16000, 22050, 32000, 
                                44100, 47250, 48000 }) { 
                            for (short audioFormat : new short[] { 
                                    AudioFormat.ENCODING_PCM_16BIT, 
                                    AudioFormat.ENCODING_PCM_8BIT }) { 
                                for (short channelConfig : new short[] { 
                                        AudioFormat.CHANNEL_IN_MONO, 
                                        AudioFormat.CHANNEL_IN_STEREO, 
                                        AudioFormat.CHANNEL_CONFIGURATION_MONO, 
                                        AudioFormat.CHANNEL_CONFIGURATION_STEREO }) { 
                 
                                    // Try to initialize 
                                    try { 
                                        mBufferSize = AudioRecord.getMinBufferSize(sampleRate, 
                                                channelConfig, audioFormat); 
                 
                                        if (mBufferSize < 0) { 
                                            continue; 
                                        } 
                 
                                        mBuffer = new short[mBufferSize]; 
                                        mAudioRecord = new AudioRecord(AudioSource.MIC, 
                                                sampleRate, channelConfig, audioFormat, 
                                                mBufferSize); 
                 
                                        if (mAudioRecord.getState() == AudioRecord.STATE_INITIALIZED) { 
                                            mSampleRate = sampleRate; 
                                            mAudioFormat = audioFormat; 
                                            mChannelConfig = channelConfig; 
                                            return; 
                                        } 
                 
                                        mAudioRecord.release(); 
                                        mAudioRecord = null; 
                                    } catch (Exception e) { 
                                        // Do nothing 
                                    } 
                                } 
                            } 
                        } 
                 
                        // ADDED(billhoo) all combinations are failed on this device. 
                        throw new IllegalStateException( 
                                "getInstance() failed : no suitable audio configurations on this device."); 
                    } 
                 
                    private int getRawAmplitude() { 
                        if (mAudioRecord == null) { 
                            createAudioRecord(); 
                        } 
                 
                        final int bufferReadSize = mAudioRecord.read(mBuffer, 0, mBufferSize); 
                 
                        if (bufferReadSize < 0) { 
                            return 0; 
                        } 
                 
                        int sum = 0; 
                        for (int i = 0; i < bufferReadSize; i++) { 
                            sum += Math.abs(mBuffer[i]); 
                        } 
                 
                        if (bufferReadSize > 0) { 
                            return sum / bufferReadSize; 
                        } 
                 
                        return 0; 
                    } 
                 
                    // /////////////////////////////////////////////////////////////// 
                    // PRIVATE CLASSES 
                 
                    // Singleton 
                    private static class InstanceHolder { 
                        private static final AudioMeter INSTANCE = new AudioMeter(); 
                    } 
                }
更多相关文章

随机推荐
