Android音視頻(四)MediaCodec編解碼AAC

Android音視頻(一) Camera2 API採集數據

Android音視頻(二)音頻AudioRecord和AudioTrack

Android音視頻(三)FFmpeg Camera2推流直播

MediaCodec類能夠訪問底層媒體編解碼框架（StageFright 或 OpenMAX），即編解碼組件，它是Android基本的多媒體支持基礎架構的一部分，一般和MediaExtractor、MediaSync、MediaMuxer、MediaCrypto、MediaDrm、Image、Surface和AudioTrack一塊兒使用。它自己並非Codec，它經過調用底層編解碼組件得到了Codec的能力。

MediaCodec的工做方式

MediaCodec處理輸入數據產生輸出數據。當異步處理數據時，使用一組輸入和輸出Buffer隊列。一般，在邏輯上，客戶端請求（或接收）數據後填入預先設定的空輸入緩衝區，輸入Buffer填滿後將其傳遞到MediaCodec並進行編解碼處理。以後MediaCodec編解碼後的數據填充到一個輸出Buffer中。最後，客戶端請求（或接收）輸出Buffer，消耗輸出Buffer中的內容，用完後釋放，給回MediaCodec從新填充輸出數據。

必須保證輸入和輸出隊列同時非空，即至少有一個輸入Buffer和輸出Buffer才能工做。

MediaCodec狀態週期圖

在MediaCodec的生命週期中存在三種狀態 ：Stopped、Executing、Released。

Stopped狀態實際上還能夠處在三種狀態：Uninitialized、Configured、Error。

Executing狀態也分爲三種子狀態：Flushed, Running、End-of-Stream。

從上圖能夠看出：

1. 當建立編解碼器的時候處於未初始化狀態。首先你須要調用configure(…)方法讓它處於Configured狀態，而後調用start()方法讓其處於Executing狀態。在Executing狀態下，你就可使用上面提到的緩衝區來處理數據。
2. Executing的狀態下也分爲三種子狀態：Flushed, Running、End-of-Stream。在start() 調用後，編解碼器處於Flushed狀態，這個狀態下它保存着全部的緩衝區。一旦第一個輸入buffer出現了，編解碼器就會自動運行到Running的狀態。當帶有end-of-stream標誌的buffer進去後，編解碼器會進入End-of-Stream狀態，這種狀態下編解碼器不在接受輸入buffer，可是仍然在產生輸出的buffer。此時你能夠調用flush()方法，將編解碼器重置於Flushed狀態。
3. 調用stop()將編解碼器返回到未初始化狀態，而後能夠從新配置。 完成使用編解碼器後，您必須經過調用release()來釋放它。
4. 在極少數狀況下，編解碼器可能會遇到錯誤並轉到錯誤狀態。 這是使用來自排隊操做的無效返回值或有時經過異常來傳達的。 調用reset()使編解碼器再次可用。 您能夠從任何狀態調用它來將編解碼器移回未初始化狀態。 不然，調用 release()動到終端釋放狀態。

MediaCodec的優缺點

優勢：功耗低，速度快

缺點：擴展性不強，不一樣芯片廠商提供的支持方案不一樣，致使程序移植性差

適用場景：適合有固定的硬件方案的項目，如智能家居類；須要長時間攝像。

MediaCodec 編解碼實現

作了一個Demo，使用AudioRecord錄音，使用MediaCodec 編碼爲AAC並保存文件，而後能夠從AAC解碼爲PCM數據，再用AudioTrack播放。

一、編碼PCM數據，保存爲AAC文件

初始化AudioRecord和編碼器

private void initAudioRecord() {
    int audioSource = MediaRecorder.AudioSource.MIC;
    int sampleRate = 44100;
    int channelConfig = AudioFormat.CHANNEL_IN_MONO;
    int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
    int minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat);
    mAudioRecorder = new AudioRecord(audioSource, sampleRate, channelConfig, audioFormat, Math.max(minBufferSize, 2048));
}
複製代碼

/** * 初始化編碼器 */
private void initAudioEncoder() {
    try {
        mAudioEncoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
        MediaFormat format = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, 44100, 1);
        format.setInteger(MediaFormat.KEY_BIT_RATE, 96000);//比特率
        format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, MAX_BUFFER_SIZE);
        mAudioEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
    } catch (IOException e) {
        e.printStackTrace();
    }

    if (mAudioEncoder == null) {
        Log.e(TAG, "create mediaEncode failed");
        return;
    }

    mAudioEncoder.start(); // 啓動MediaCodec,等待傳入數據
    encodeInputBuffers = mAudioEncoder.getInputBuffers(); //上面介紹的輸入和輸出Buffer隊列
    encodeOutputBuffers = mAudioEncoder.getOutputBuffers();
    mAudioEncodeBufferInfo = new MediaCodec.BufferInfo();
}
複製代碼

開始錄音、編碼

使用線程池，兩條線程，一個線程去錄音，另外一個線程作編碼操做。錄音線程會將PCM數據存入一個隊列中，編碼線程從隊列中取出數據編碼。

// 開啓錄音線程
mExecutorService.submit(new Runnable() {
    @Override
    public void run() {
        startRecorder();
    }
});
// 開啓編碼線程
mExecutorService.submit(new Runnable() {
    @Override
    public void run() {
        encodePCM();
    }
});

 /** * 將PCM數據存入隊列 */
    private void putPCMData(byte[] pcmChunk) {
        Log.e(TAG, "putPCMData");
        try {
            queue.put(pcmChunk);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /** * 從隊列取出PCM數據 */
    private byte[] getPCMData() {
        try {
            if (queue.isEmpty()) {
                return null;
            }
            return queue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
    /** * 添加ADTS頭，若是要與視頻流合併就不用添加，單獨AAC文件就須要添加，不然沒法正常播放 */
    public static void addADTStoPacket(int sampleRateType, byte[] packet, int packetLen) {
        int profile = 2; // AAC LC
        int chanCfg = 2; // CPE

        packet[0] = (byte) 0xFF;
        packet[1] = (byte) 0xF9;
        packet[2] = (byte) (((profile - 1) << 6) + (sampleRateType << 2) + (chanCfg >> 2));
        packet[3] = (byte) (((chanCfg & 3) << 6) + (packetLen >> 11));
        packet[4] = (byte) ((packetLen & 0x7FF) >> 3);
        packet[5] = (byte) (((packetLen & 7) << 5) + 0x1F);
        packet[6] = (byte) 0xFC;
    }
複製代碼

音頻數據

/** * 獲取音頻數據 */
private void startRecorder() {
    try {
        mFilePath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/RecorderTest/" + System.currentTimeMillis() + ".aac";
        mAudioFile = new File(mFilePath);
        if (!mAudioFile.getParentFile().exists()) {
            mAudioFile.getParentFile().mkdirs();
        }
        mAudioFile.createNewFile();
        mFileOutputStream = new FileOutputStream(mAudioFile);
        mAudioBos = new BufferedOutputStream(mFileOutputStream, 200 * 1024);
        mAudioRecorder.startRecording();

        start = System.currentTimeMillis();

        while (mIsRecording) {
            int read = mAudioRecorder.read(mBuffer, 0, 2048);
            if (read > 0) {
                byte[] audio = new byte[read];
                System.arraycopy(mBuffer, 0, audio, 0, read);
                putPCMData(audio); // PCM數據放入隊列，等待編碼
            }
        }
    } catch (IOException | RuntimeException e) {
        e.printStackTrace();
    } finally {
        if (mAudioRecorder != null) {
            mAudioRecorder.release();
            mAudioRecorder = null;
        }
    }
}
複製代碼

編碼

從隊列中循環取出數據，MediaCodec 編碼，將編碼後的數據寫入文件中。

/** * 編碼PCM */
private void encodePCM() {
    int inputIndex;
    ByteBuffer inputBuffer;
    int outputIndex;
    ByteBuffer outputBuffer;
    byte[] chunkAudio;
    int outBitSize;
    int outPacketSize;
    byte[] chunkPCM;

    while (mIsRecording || !queue.isEmpty()) {
        chunkPCM = getPCMData();//獲取解碼器所在線程輸出的數據 代碼後邊會貼上
        if (chunkPCM == null) {
            continue;
        }
        inputIndex = mAudioEncoder.dequeueInputBuffer(-1);//同解碼器
        if (inputIndex >= 0) {
            inputBuffer = encodeInputBuffers[inputIndex];//同解碼器
            inputBuffer.clear();//同解碼器
            inputBuffer.limit(chunkPCM.length);
            inputBuffer.put(chunkPCM);//PCM數據填充給inputBuffer
            mAudioEncoder.queueInputBuffer(inputIndex, 0, chunkPCM.length, 0, 0);//通知編碼器 編碼
        }

        outputIndex = mAudioEncoder.dequeueOutputBuffer(mAudioEncodeBufferInfo, 10000);
        while (outputIndex >= 0) {
            outBitSize = mAudioEncodeBufferInfo.size;
            outPacketSize = outBitSize + 7;//7爲ADTS頭部的大小
            outputBuffer = encodeOutputBuffers[outputIndex];//拿到輸出Buffer
            outputBuffer.position(mAudioEncodeBufferInfo.offset);
            outputBuffer.limit(mAudioEncodeBufferInfo.offset + outBitSize);
            chunkAudio = new byte[outPacketSize];
            addADTStoPacket(44100, chunkAudio, outPacketSize);//添加ADTS
            outputBuffer.get(chunkAudio, 7, outBitSize);//將編碼獲得的AAC數據 取出到byte[]中 偏移量offset=7
            outputBuffer.position(mAudioEncodeBufferInfo.offset);
            try {
                mAudioBos.write(chunkAudio, 0, chunkAudio.length);//BufferOutputStream 將文件保存到內存卡中 *.aac
            } catch (IOException e) {
                e.printStackTrace();
            }
            mAudioEncoder.releaseOutputBuffer(outputIndex, false);
            outputIndex = mAudioEncoder.dequeueOutputBuffer(mAudioEncodeBufferInfo, 10000);
        }
    }

    stopRecorder();
}
複製代碼

二、解碼AAC AudioTrack播放

初始化AudioTrack和解碼器

/** * 初始化AudioTrack，等待播放數據 */
private void initAudioTrack() {
    int streamType = AudioManager.STREAM_MUSIC;
    int sampleRate = 44100;
    int channelConfig = AudioFormat.CHANNEL_OUT_MONO;
    int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
    int mode = AudioTrack.MODE_STREAM;

    int minBufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat);

    audioTrack = new AudioTrack(streamType, sampleRate, channelConfig, audioFormat,
            Math.max(minBufferSize, 2048), mode);
    audioTrack.play();
}
複製代碼

/** * 初始化解碼器 */
private void initAudioDecoder() {
    try {
        mMediaExtractor = new MediaExtractor();
        mMediaExtractor.setDataSource(mFilePath);

        MediaFormat format = mMediaExtractor.getTrackFormat(0);
        String mime = format.getString(MediaFormat.KEY_MIME);
        if (mime.startsWith("audio")) {//獲取音頻軌道
            mMediaExtractor.selectTrack(0);//選擇此音頻軌道
            format.setString(MediaFormat.KEY_MIME, "audio/mp4a-latm");
            format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 1);
            format.setInteger(MediaFormat.KEY_SAMPLE_RATE, 0);
            format.setInteger(MediaFormat.KEY_BIT_RATE, 96000);
            format.setInteger(MediaFormat.KEY_IS_ADTS, 1);
            format.setInteger(MediaFormat.KEY_AAC_PROFILE, 0);

            mAudioDecoder = MediaCodec.createDecoderByType(mime);//建立Decode解碼器
            mAudioDecoder.configure(format, null, null, 0);
        } else {
            return;
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    if (mAudioDecoder == null) {
        Log.e(TAG, "mAudioDecoder is null");
        return;
    }
    mAudioDecoder.start();//啓動MediaCodec ，等待傳入數據
}
複製代碼

解碼並播放

private void decodeAndPlay() {
    boolean isFinish = false;
    MediaCodec.BufferInfo decodeBufferInfo = new MediaCodec.BufferInfo();
    while (!isFinish && mIsPalying) {
        int inputIdex = mAudioDecoder.dequeueInputBuffer(10000);//獲取可用的inputBuffer -1表明一直等待，0表示不等待 10000表示10秒超時
        if (inputIdex < 0) {
            isFinish = true;
        }
        ByteBuffer inputBuffer = mAudioDecoder.getInputBuffer(inputIdex);
        inputBuffer.clear();//清空以前傳入inputBuffer內的數據
        int samplesize = mMediaExtractor.readSampleData(inputBuffer, 0);
        if (samplesize > 0) {
            mAudioDecoder.queueInputBuffer(inputIdex, 0, samplesize, 0, 0); //通知解碼器 解碼
            mMediaExtractor.advance(); //MediaExtractor移動到下一取樣處
        } else {
            isFinish = true;
        }
        int outputIndex = mAudioDecoder.dequeueOutputBuffer(decodeBufferInfo, 10000);//獲取解碼獲得的byte[]數據

        ByteBuffer outputBuffer;
        byte[] chunkPCM;
        //每次解碼完成的數據不必定能一次吐出 因此用while循環，保證解碼器吐出全部數據
        while (outputIndex >= 0) {
            outputBuffer = mAudioDecoder.getOutputBuffer(outputIndex);
            chunkPCM = new byte[decodeBufferInfo.size];
            outputBuffer.get(chunkPCM);
            outputBuffer.clear();//數據取出後必定記得清空此Buffer MediaCodec是循環使用這些Buffer的，不清空下次會獲得一樣的數
            // 播放解碼後的PCM數據
            audioTrack.write(chunkPCM, 0, decodeBufferInfo.size);
            mAudioDecoder.releaseOutputBuffer(outputIndex, false);
            outputIndex = mAudioDecoder.dequeueOutputBuffer(decodeBufferInfo, 10000);//再次獲取數據
        }
    }
    stopPlay();
}
複製代碼

Demo完成，手機測試效果不錯。MediaCodec的使用要比我預想的複雜，網上查了很久才完成這個Demo，但願能幫到須要的人。

若有問題歡迎留言，Github源碼 - MediaCodecActivity