MediaCodec API完成音频 AAC 硬编、硬解

1 MediaCodec 介绍

MediaCodec类可以用于使用一些基本的多媒体编解码器（音视频编解码组件），它是Android基本的多媒体支持基础架构的一部分通常和MediaExtractor、MediaSync、MediaMuxer、MediaCrypto、MediaDrm、Image、Surface和AudioTrack一起使用。

一个编解码器可以处理输入的数据来产生输出的数据，编解码器使用一组输入和输出缓冲器来异步处理数据。
你可以创建一个空的输入缓冲区，填充数据后发送到编解码器进行处理。
编解码器使用输入的数据进行转换，然后输出到一个空的输出缓冲区。
最后你获取到输出缓冲区的数据，消耗掉里面的数据，释放回编解码器。
如果后续还有数据需要继续处理，编解码器就会重复这些操作。输出流程如下：

image.png

1.1 编解码器支持的数据类型：

压缩数据、原始音频数据和原始视频数据

你可以通过ByteBuffers能够处理这三种数据，但是需要你提供一个Surface，用于对原始的视频数据进行展示，这样也能提高编解码的性能。
Surface使用的是本地的视频缓冲区，这个缓冲区不映射或拷贝到ByteBuffers，这样的机制让编解码器的效率更高。
通常在使用Surface的时候，无法访问原始的视频数据，但是你可以使用ImageReader访问解码后的原始视频帧。在使用ByteBuffer的模式下，您可以使用Image类和getInput/OutputImage（int）访问原始视频帧。

1.2 编解码器的生命周期：

主要的生命周期为：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()动到终端释放状态。

2 MediaCodec API 说明

MediaCodec可以处理具体的视频流，主要有这几个方法：

• getInputBuffers：获取需要编码数据的输入流队列，返回的是一个ByteBuffer数组
• queueInputBuffer：输入流入队列
• dequeueInputBuffer：从输入流队列中取数据进行编码操作
• getOutputBuffers：获取编解码之后的数据输出流队列，返回的是一个ByteBuffer数组
• dequeueOutputBuffer：从输出队列中取出编码操作之后的数据
• releaseOutputBuffer：处理完成，释放ByteBuffer数据

3 MediaCodec 流控

3.1 流控基本概念

流控就是流量控制。为什么要控制，因为条件有限！涉及到了 TCP 和视频编码：

对 TCP 来说就是控制单位时间内发送数据包的数据量，对编码来说就是控制单位时间内输出数据的数据量。

• TCP 的限制条件是网络带宽，流控就是在避免造成或者加剧网络拥塞的前提下，尽可能利用网络带宽。带宽够、网络好，我们就加快速度发送数据包，出现了延迟增大、丢包之后，就放慢发包的速度（因为继续高速发包，可能会加剧网络拥塞，反而发得更慢）。
• 视频编码的限制条件最初是解码器的能力，码率太高就会无法解码，后来随着 codec 的发展，解码能力不再是瓶颈，限制条件变成了传输带宽/文件大小，我们希望在控制数据量的前提下，画面质量尽可能高。

一般编码器都可以设置一个目标码率，但编码器的实际输出码率不会完全符合设置，因为在编码过程中实际可以控制的并不是最终输出的码率，而是编码过程中的一个量化参数（Quantization Parameter，QP），它和码率并没有固定的关系，而是取决于图像内容。

无论是要发送的 TCP 数据包，还是要编码的图像，都可能出现“尖峰”，也就是短时间内出现较大的数据量。TCP 面对尖峰，可以选择不为所动（尤其是网络已经拥塞的时候），这没有太大的问题，但如果视频编码也对尖峰不为所动，那图像质量就会大打折扣了。如果有几帧数据量特别大，但仍要把码率控制在原来的水平，那势必要损失更多的信息，因此图像失真就会更严重。

3.2 Android 硬编码流控

MediaCodec 流控相关的接口并不多，一是配置时设置目标码率和码率控制模式，二是动态调整目标码率(Android 19 版本以上)。

配置时指定目标码率和码率控制模式：

mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
mediaFormat.setInteger(MediaFormat.KEY_BITRATE_MODE,
MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_VBR);
mVideoCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

码率控制模式有三种：

• CQ 表示完全不控制码率，尽最大可能保证图像质量；
• CBR 表示编码器会尽量把输出码率控制为设定值，即我们前面提到的“不为所动”；
• VBR 表示编码器会根据图像内容的复杂度（实际上是帧间变化量的大小）来动态调整输出码率，图像复杂则码率高，图像简单则码率低；
  动态调整目标码率：

Bundle param = new Bundle();
param.putInt(MediaCodec.PARAMETER_KEY_VIDEO_BITRATE, bitrate);
mediaCodec.setParameters(param);

3.3 Android 流控策略选择

• 质量要求高、不在乎带宽、解码器支持码率剧烈波动的情况下，可以选择 CQ 码率控制策略。
• VBR 输出码率会在一定范围内波动，对于小幅晃动，方块效应会有所改善，但对剧烈晃动仍无能为力；连续调低码率则会导致码率急剧下降，如果无法接受这个问题，那 VBR 就不是好的选择。
• CBR 的优点是稳定可控，这样对实时性的保证有帮助。所以 WebRTC 开发中一般使用的是CBR。

4 将mp3文件转码为aac音频文件

4.1 转码实现原理

转码实现原理：mp3->pcm->aac，首先将mp3解码成PCM，再将PCM编码成aac格式的音频文件。

PCM：可以将它理解为，未经过压缩的数字信号，即原始音频数据，mp3、aac等理解为pcm压缩后的文件。播放器在播放mp3、aac等文件时要先将mp3等文件解码成PCM数据，然后再将PCM送到底层去处理播放。

4.2 代码实现

4.2.1 初始化MediaExtractor

首先要初始化MediaExtractor选择要操作的音轨，然后在AudioDecodeRunnable中完成解码操作。因为解码是相对耗时的操作，所以需要开辟新的线程进行操作。

MediaExtractor：可用于分离视频文件的音轨和视频轨道，如果你只想要视频，那么用selectTrack方法选中视频轨道，然后用readSampleData读出数据，这样你就得到了一个没有声音的视频。此处我们传入的是一个音频文件（mp3），所以也就只有一个轨道，音频轨道。

MediaCodec.createDecoderByType(mime) 创建对应格式的解码器 要解码mp3 那么mime="audio/mpeg" 或者MediaFormat.MIMETYPE_AUDIO_MPEG其它同理。
mime：用来表示媒体文件的格式，各种类型定义在MediaFormat静态常量中，mp3为audio/mpeg；aac为audio/mp4a-latm；mp4为video/mp4v-es。
此处注意前缀 ：音频前缀为audio，视频前缀为video。我们可用此区别区分媒体文件内的音频轨道和视频轨道。

  /**
     * 将音频文件解码成原始的PCM数据
     * @param audioPath         MP3文件目录
     * @param audioSavePath     pcm文件保存位置
     * @param listener
     */
public static void getPCMFromAudio(String audioPath, String audioSavePath, final AudioDecodeListener listener){
        MediaExtractor extractor = new MediaExtractor();//此类可分离视频文件的音轨和视频轨道
        int audioTrack = -1;//音频MP3文件其实只有一个音轨
        boolean hasAudio = false;//判断音频文件是否有音频音轨

        try {
            extractor.setDataSource(audioPath);
            for (int i = 0;i < extractor.getTrackCount(); i++){
                MediaFormat format = extractor.getTrackFormat(i);
                String mime = format.getString(MediaFormat.KEY_MIME);
                if (mime.startsWith("audio/")){
                    audioTrack = i;
                    hasAudio = true;
                    break;
                }
            }

            if (hasAudio){
                extractor.selectTrack(audioTrack);

                //原始音频解码
                new Thread(new AudioDecodeRunnable(extractor,audioTrack,audioSavePath, new DecodeOverListener() {
                    @Override
                    public void decodeIsOver() {
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (listener != null){
                                    listener.decodeOver();
                                }
                            }
                        });
                    }

                    @Override
                    public void decodeFail() {
                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (listener != null){
                                    listener.decodeFail();
                                }
                            }
                        });
                    }
                })).start();

            } else {//如果音频文件没有音频音轨
                Log.e(TAG,"音频文件没有音频音轨");
                if (listener != null){
                    listener.decodeFail();
                }
            }
        }catch (IOException e){
            e.printStackTrace();
            Log.e(TAG,"解码失败");
            if (listener != null){
                listener.decodeFail();
            }
        }
    }

4.2.2 创建解码器

在新的线程中解码
1、直接从MP3音频文件中得到音轨的MediaFormat

extractor.getTrackFormat(audioTrack);

2、初始化解码器，并配置解码器属性

MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME));
audioCodec.configure(format,null,null,0);

3、启动解码器

audioCodec.start();//启动MediaCodec，等待传入数据

4、你可以创建一个空的输入缓冲区，填充数据后发送到解码器进行处理

ByteBuffer[] inputBuffers = audioCodec.getInputBuffers();//MediaCodec在此ByteBuffer[]中获取输入数据
int inputIndex = audioCodec.dequeueInputBuffer(TIMEOUT_USEC);
ByteBuffer inputBuffer = inputBuffers[inputIndex];//拿到inputBuffer
int sampleSize = extractor.readSampleData(inputBuffer,0);//将MediaExtractor读取数据到inputBuffer
audioCodec.queueInputBuffer(inputIndex,inputInfo.offset,sampleSize,inputInfo.presentationTimeUs,0);
audioCodec.queueInputBuffer(inputIndex,0,0,0L,MediaCodec.BUFFER_FLAG_END_OF_STREAM);

5、解码器使用输入的数据进行转换，然后输出到一个空的输出缓冲区。
最后你获取到输出缓冲区的数据，消耗掉里面的数据，释放回编解码器。
如果后续还有数据需要继续处理，编解码器就会重复这些操作。
最后写入pcm文件中。

ByteBuffer[] outputBuffers = audioCodec.getOutputBuffers();//MediaCodec将解码后的数据放到此ByteBuffer[]中 我们可以直接在这里面得到PCM数据
int outputIndex = audioCodec.dequeueOutputBuffer(decodeBufferInfo,TIMEOUT_USEC);
outputBuffers = audioCodec.getOutputBuffers();
ByteBuffer outputBuffer = outputBuffers[outputIndex];
chunkPCM = new byte[decodeBufferInfo.size];
outputBuffer.get(chunkPCM);
fos.write(chunkPCM);//数据写入文件中

具体代码：

public void run() {
        try {
            MediaFormat format = extractor.getTrackFormat(audioTrack);
            //初始化音频解码器
            MediaCodec audioCodec = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME));
            audioCodec.configure(format,null,null,0);

            audioCodec.start();//启动MediaCodec，等待传入数据

            ByteBuffer[] inputBuffers = audioCodec.getInputBuffers();//MediaCodec在此ByteBuffer[]中获取输入数据
            ByteBuffer[] outputBuffers = audioCodec.getOutputBuffers();//MediaCodec将解码后的数据放到此ByteBuffer[]中 我们可以直接在这里面得到PCM数据
            MediaCodec.BufferInfo decodeBufferInfo = new MediaCodec.BufferInfo();//用于描述解码得到的byte[]数据的相关信息
            MediaCodec.BufferInfo inputInfo = new MediaCodec.BufferInfo();
            boolean codeOver = false;
            boolean inputDone = false;//整体输入结束标记

            FileOutputStream fos = new FileOutputStream(mPcmFilePath);

            while (!codeOver){
                if (!inputDone){
                    for (int i = 0;i < inputBuffers.length; i++){
                        //遍历所有的编码器，然后将数据传入之后，再去输出端取出数据
                        int inputIndex = audioCodec.dequeueInputBuffer(TIMEOUT_USEC);
                        if (inputIndex >= 0){
                            //从分离器拿出输入，写入解码器
                            ByteBuffer inputBuffer = inputBuffers[inputIndex];//拿到inputBuffer，新的API中好像可以直接拿到
                            inputBuffer.clear();
                            int sampleSize = extractor.readSampleData(inputBuffer,0);//将MediaExtractor读取数据到inputBuffer
                            if (sampleSize < 0){//表示所有数据已经读取完毕
                                audioCodec.queueInputBuffer(inputIndex,0,0,0L,MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                            } else {
                                inputInfo.offset = 0;
                                inputInfo.size = sampleSize;
                                inputInfo.flags = MediaCodec.BUFFER_FLAG_SYNC_FRAME;
                                inputInfo.presentationTimeUs = extractor.getSampleTime();

                                Log.e(TAG,"往解码器写入数据，当前时间戳：" + inputInfo.presentationTimeUs);
                                //通知MediaCodec解码刚刚传入的数据
                                audioCodec.queueInputBuffer(inputIndex,inputInfo.offset,sampleSize,inputInfo.presentationTimeUs,0);
                                extractor.advance();
                            }
                        }
                    }
                }

                boolean decodeOutputDone = false;
                byte[] chunkPCM;
                while (!decodeOutputDone){
                    int outputIndex = audioCodec.dequeueOutputBuffer(decodeBufferInfo,TIMEOUT_USEC);
                    if (outputIndex == MediaCodec.INFO_TRY_AGAIN_LATER){
                        //没有可用的解码器
                        decodeOutputDone = true;
                    }else if (outputIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED){
                        outputBuffers = audioCodec.getOutputBuffers();
                    } else if (outputIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED){
                        MediaFormat newFormat = audioCodec.getOutputFormat();
                    } else if (outputIndex < 0) {

                    } else {
                        ByteBuffer outputBuffer;
                        if (Build.VERSION.SDK_INT >= 21){
                            outputBuffer = audioCodec.getOutputBuffer(outputIndex);
                        } else {
                            outputBuffer = outputBuffers[outputIndex];
                        }

                        chunkPCM = new byte[decodeBufferInfo.size];
                        outputBuffer.get(chunkPCM);
                        outputBuffer.clear();

                        fos.write(chunkPCM);//数据写入文件中
                        fos.flush();
                        Log.e(TAG,"释放输出流缓冲区：" + outputIndex);
                        audioCodec.releaseOutputBuffer(outputIndex,false);

                        if ((decodeBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0){//编解码结束
                            extractor.release();
                            audioCodec.stop();
                            audioCodec.release();
                            codeOver = true;
                            decodeOutputDone = true;
                        }
                    }
                }
            }

            fos.close();
            mListener.decodeIsOver();
            if (mListener != null){
                mListener.decodeIsOver();
            }
        }catch (IOException e){
            e.printStackTrace();
            if (mListener != null){
                mListener.decodeFail();
            }
        }
    }

4.2.3 初始化编码器

编码器的创建于解码器的类似，只不过解码器的MediaFormat直接在音频文件内获取就可以了，编码器的MediaFormat需要自己来创建。
1、初始化编码格式

//初始化编码格式   mimetype  采样率  声道数
MediaFormat encodeFormat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC,44100,2);
encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE,96000);
encodeFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE,500 * 1024);

2、初始化编码器

//初始化编码器
MediaCodec mediaEncode = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
mediaEncode.configure(encodeFormat,null,null,MediaCodec.CONFIGURE_FLAG_ENCODE);
mediaEncode.start();

3、读取pcm文件并写入编码器输入缓存区中

Log.e(TAG,"读取文件并写入编码器" + allAudioBytes.length);
inputIndex = mediaEncode.dequeueInputBuffer(-1);
inputBuffer = encodeInputBuffers[inputIndex];
inputBuffer.clear();
inputBuffer.limit(allAudioBytes.length);
inputBuffer.put(allAudioBytes);//将pcm数据填充给inputBuffer
mediaEncode.queueInputBuffer(inputIndex,0,allAudioBytes.length,0,0);//开始编码

4、从解码器输出缓存区中取出数据并写入文件中

//从解码器中取出数据
outBitSize = encodeBufferInfo.size;
outPacketSize = outBitSize + 7;//7为adts头部大小
outputBuffer = encodeOutputBuffers[outputIndex];//拿到输出的buffer
outputBuffer.position(encodeBufferInfo.offset);
outputBuffer.limit(encodeBufferInfo.offset + outBitSize);
chunkAudio = new byte[outPacketSize];
AudioCodec.addADTStoPacket(chunkAudio,outPacketSize);//添加ADTS
outputBuffer.get(chunkAudio,7,outBitSize);//将编码得到的AAC数据取出到byte[]中，偏移量为7
outputBuffer.position(encodeBufferInfo.offset);
Log.e(TAG,"编码成功并写入文件" + chunkAudio.length);
bos.write(chunkAudio,0,chunkAudio.length);//将文件保存在sdcard中

源码地址：https://github.com/Xiaoben336/Mp3ToAAC