devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MediaCodec实现AAC的解码与编码_mediacodec 解码aac

作者：喵喵爱编程 | 2024-07-28 17:39:38

赞

踩

mediacodec 解码aac

前言

MediaCodec是谷歌原生编解码接口，可以说只要涉及到音视频开发的学习，这个接口都是无法躲避，属于必学知识。我刚开始接触这个接口的时候，多多少少有点抵触这个接口，因为我觉得这个接口的使用流程超级复杂，但是后来看多了几个demo，发现也就那么一回事，流程都是一致的，只是在MediaCodec的配置上面，不同的格式编解码会有不同的编码配置，仅此而已。

今天我将以我自己实现的一个demo给大家展示一下这个接口的解码和编码的基本流程（MP3->PCM->AAC），同时也为我日后复习做好复习文档。

MediaCodec编解码的流程

MediaCodec 首先获取一个空的输入缓冲区，填充要编码或解码的数据，再将填充数据的输入缓冲区送到 MediaCodec 进行处理，处理完数据后会释放这个填充数据的输入缓冲区，最后获取已经编码或解码的输出缓冲区，使用完毕后释放输出缓冲区，其编解码的流程示意图如下：

各个阶段对应的 API 如下：

  1. // 获取可用的输入缓冲区的索引
  2.  public int dequeueInputBuffer (long timeoutUs)
  3.  // 获取输入缓冲区
  4.  public ByteBuffer getInputBuffer(int index)
  5.  // 将填满数据的inputBuffer提交到编码队列
  6.  public final void queueInputBuffer(int index,int offset, int size, long presentationTimeUs, int flags)
  7.  // 获取已成功编解码的输出缓冲区的索引
  8.  public final int dequeueOutputBuffer(BufferInfo info, long timeoutUs)
  9.  // 获取输出缓冲区
  10. public ByteBuffer getOutputBuffer(int index)
  11. // 释放输出缓冲区
  12. public final void releaseOutputBuffer(int index, boolean render)

我们使用MediaCodec接口，其实就是围绕这几个接口方法进行使用，大家可以先重点留意一下这几个方法，后续代码中会重点使用。

MediaCodec生命周期

MediaCodec 简单来说只有三种状态，分别是执行(Executing)、停止(Stopped)和释放(Released)。很多文章都会给出一些状态转换的图解，不可否认，超级直观好理解。但是其实我老是记不熟，所以我这次打算直接罗列一些每种状态所对应的接口方法。

  • 停止状态(Stopped)
  1. // 创建MediaCodec进入Uninitialized子状态
  2.  public static MediaCodec createByCodecName (String name)
  3.  public static MediaCodec createEncoderByType (String type)
  4.  public static MediaCodec createDecoderByType (String type)
  5.  // 配置MediaCodec进入Configured子状态，crypto和descrambler会在后文中进行说明
  6.  public void configure(MediaFormat format, Surface surface, MediaCrypto crypto, int flags)
  7.  public void configure(MediaFormat format, @Nullable Surface surface,int flags,MediaDescrambler descrambler)
  8.  // Error
  9.  // 编解码过程中遇到错误进入Error子状态
  • 执行状态(Executing)
  1. // start之后立即进入Flushed子状态
  2. public final void start()
  3. // 第一个输入缓冲区出队的时候进入Running子状态
  4. public int dequeueInputBuffer (long timeoutUs)
  5. // 输入缓冲区与流结束标记排队时，编解码器将转换为End-of-Stream子状态
  6. // 此时MediaCodec将不接受其他输入缓冲区，但会生成输出缓冲区
  7. public void queueInputBuffer (int index, int offset, int size, long presentationTimeUs, int flags)
  8. //输出缓冲区的操作也是执行状态，基本重复，这边就不进行重复叙述
  • 释放状态(Released)
  1. // 编解码完成结束后释放MediaCodec进入释放状态(Released)
  2. public void release ()

Demo实现基本流程 

了解完MediaCodec的基本流程和生命周期之后，我们便可以开始实现我们的编码解码demo，在开始之前我们需要先理清楚一下我们实现该功能的流程。

1、获取mp3文件

2、创建解码MediaCodec，进行解码操作，生成pcm文件

3、解码结束后，获取pcm文件

4、创建编码MediaCodec，进行编码操作，生成AAC文件

看上去那是非常简单，接下来我们来看看具体的实现。

代码实现 

我们先来看看最后我们需要实现的一个效果。

效果非常简单，点击按钮之后，便会开始mp3的解码生成pcm文件，解码之后，便会自动获取pcm文件进行编码生成AAC文件。

Layout.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity">
  8.  
  9.     <Button
  10.         android:id="@+id/audio_change"
  11.         android:layout_width="match_parent"
  12.         android:layout_height="wrap_content"
  13.         android:text="音频转换"/>
  14.  
  15. </LinearLayout>

MainActivity

  1. package cn.yjs.mediacodecaccapplication;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4. import androidx.core.app.ActivityCompat;
  5.  
  6. import android.Manifest;
  7. import android.app.Activity;
  8. import android.content.pm.PackageManager;
  9. import android.os.Bundle;
  10. import android.os.Environment;
  11. import android.os.Handler;
  12. import android.util.Log;
  13. import android.view.View;
  14. import android.widget.Button;
  15. import android.widget.Toast;
  16.  
  17. import java.io.File;
  18.  
  19. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  20.  
  21.     private Button mAudioChangeBtn;
  22.     private Handler mMainHandler;
  23.  
  24.     @Override
  25.     protected void onCreate(Bundle savedInstanceState) {
  26.         super.onCreate(savedInstanceState);
  27.         setContentView(R.layout.activity_main);
  28.         verifyStoragePermissions(this);
  29.         bindView();
  30.         mMainHandler = new Handler(getMainLooper());
  31.     }
  32.  
  33.     private void bindView() {
  34.         mAudioChangeBtn = findViewById(R.id.audio_change);
  35.         mAudioChangeBtn.setOnClickListener(this);
  36.     }
  37.  
  38.     @Override
  39.     public void onClick(View view) {
  40.         switch (view.getId()) {
  41.             case R.id.audio_change:
  42.                 Log.d("yjs", "i has click the button");
  43.                 //初始aac文件
  44.                 File filesDir = getFilesDir();
  45.                 String inputAbsolutePath = filesDir.getAbsolutePath();
  46.                 final String mInputAACPath = inputAbsolutePath + "/AudioVideoLearning/test.mp3";
  47.                 Log.d("yjs", "mInputAACPath:" + mInputAACPath);
  48.                 File file = new File(mInputAACPath);
  49.                 if (file.exists()) {
  50.                     Log.d("yjs", "inputfile is exists");
  51.                 }
  52.                 //解码的pcm文件路径
  53.                 final String mPcmPath = inputAbsolutePath + "/AudioVideoLearning/test.pcm";
  54.                 Log.d("yjs", "mPcmPath:" + mPcmPath);
  55.                 //pcm文件编码成的aac文件
  56.                 final String mOutputAACPath = inputAbsolutePath + "/AudioVideoLearning/outputtest.aac";
  57.  
  58.                 AudioCodec.getPCMFromAudio(mInputAACPath, mPcmPath, new AudioCodec.AudioCodecCallback() {
  59.                     @Override
  60.                     public void decodeOver() {
  61.                         Log.d("yjs", "IS DECODE OVER");
  62.                         //解码之后，我们再将test.pcm编码成AAC格式
  63.                         AudioCodec.PCMToAudio(mPcmPath, mOutputAACPath, new AudioCodec.AudioCodecCallback() {
  64.                             @Override
  65.                             public void decodeOver() {
  66.                                 Log.d("YJS", "AudioCodec.PCMToAudio OVER");
  67.                                 mMainHandler.post(new Runnable() {
  68.                                     @Override
  69.                                     public void run() {
  70.                                         Toast.makeText(MainActivity.this, "pcm to aac success", Toast.LENGTH_LONG).show();
  71.                                     }
  72.                                 });
  73.  
  74.                             }
  75.  
  76.                             @Override
  77.                             public void decodeFail() {
  78.                                 mMainHandler.post(new Runnable() {
  79.                                     @Override
  80.                                     public void run() {
  81.                                         Toast.makeText(MainActivity.this, "pcm to aac failed", Toast.LENGTH_LONG).show();
  82.                                     }
  83.                                 });
  84.  
  85.                             }
  86.                         });
  87.                     }
  88.  
  89.                     @Override
  90.                     public void decodeFail() {
  91.                         Log.d("yjs", "IS DECODE FAIL");
  92.                     }
  93.                 });
  94.                 break;
  95.         }
  96.     }
  97.  
  98.     private static final int REQUEST_EXTERNAL_STORAGE = 1;
  99.     private static String[] PERMISSIONS_STORAGE = {
  100.             "android.permission.READ_EXTERNAL_STORAGE",
  101.             "android.permission.WRITE_EXTERNAL_STORAGE",
  102.             Manifest.permission.MANAGE_EXTERNAL_STORAGE};
  103.  
  104.     public static void verifyStoragePermissions(Activity activity) {
  105.         try {
  106.             // 检测是否有写的权限
  107.             for (String s : PERMISSIONS_STORAGE) {
  108.                 int permission = ActivityCompat.checkSelfPermission(activity,
  109.                         s);
  110.                 if (permission != PackageManager.PERMISSION_GRANTED) {
  111.                     // 没有写的权限，去申请写的权限，会弹出对话框
  112.                     ActivityCompat.requestPermissions(activity, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
  113.                 }
  114.             }
  115.  
  116.         } catch (Exception e) {
  117.             e.printStackTrace();
  118.         }
  119.     }
  120.  
  121. }

关于上面这段代码还是比较容易看懂的，我这边集中讲解一下其中的一个语句

AudioCodec.getPCMFromAudio（String audioPath, String audioDecodePath, AudioCodecCallback audioCodecCallback）

AudioCodec可以理解成一个工具类，getPCMFromAudio传入mp3文件路径，pcm文件输出路径，以及解码的状态回调函数。这个方法内部是重新开一个线程进行解码处理，该方法体后续也会详细的展示出来。

 AudioCodec.getPCMFromAudio(mInputAACPath, mPcmPath, new AudioCodec.AudioCodecCallback() {
                    @Override
                    public void decodeOver() {
                        Log.d("yjs", "IS DECODE OVER");
                        //解码之后，我们再将test.pcm编码成AAC格式
                        AudioCodec.PCMToAudio(mPcmPath, mOutputAACPath, new AudioCodec.AudioCodecCallback() {

可以看到在pcm文件生成之后，我们便开始了进行pcm文件的编码操作。

自此MainActivity就没有什么好说的了，我们接下来可以着重来看看AudioCodec这个工具类。

AudioCodec

首先我们来看看这个类的一个方法结构

可以看到这个工具类创建了三个回调接口，这么设计主要是为了在解码抑或是编码结束之后对于状态的回调，让开发者可以根据状态执行接下来的各种操作。

我们着重看看getPCMFromAudio方法以及PCMToAudio这两个核心方法，顾名思义，前者是将MP3格式文件转换成PCM文件的方法，后者是将PCM文件编码成为AAC文件的方法。我们先来看看getPCMFromAudio方法，做了什么事情！

getPCMFromAudio

  1. public static void getPCMFromAudio(String audioPath, String audioDecodePath, AudioCodecCallback audioCodecCallback) {
  2.         Log.d(TAG, "getPCMFromAudio");
  3.         MediaExtractor extractor = new MediaExtractor();
  4.         int audioTrack = -1;// 音频MP3文件其实只有一个音轨
  5.         boolean hasAudio = false;// 判断音频文件是否有音频音轨
  6.  
  7.         try {
  8.             extractor.setDataSource(audioPath);
  9.             for (int i = 0; i < extractor.getTrackCount(); i++) {
  10.                 MediaFormat trackFormat = extractor.getTrackFormat(i);
  11.                 String trackFormatString = trackFormat.getString(MediaFormat.KEY_MIME);
  12.                 Log.d("yjs", "track format:" + trackFormatString);
  13.                 if (trackFormatString.startsWith("audio")) {
  14.                     audioTrack = i;
  15.                     hasAudio = true;
  16.                     break;
  17.                 }
  18.             }
  19.             if (hasAudio) {
  20.                 Log.d("yjs", "begin to get pcm");
  21.                 extractor.selectTrack(audioTrack);
  22.                 //开始解码
  23.                 new Thread(new AudioDecodeRunnable(extractor, audioDecodePath, audioTrack, new DecodeOverListener() {
  24.                     @Override
  25.                     public void decodeOver() {
  26.                         Log.d(TAG, "IS DECODE OVER");
  27.                         audioCodecCallback.decodeOver();
  28.                     }
  29.  
  30.                     @Override
  31.                     public void decodeFail() {
  32.                         Log.d(TAG, "IS DECODE FAIL");
  33.                         audioCodecCallback.decodeFail();
  34.                     }
  35.                 })).start();
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         }
  40.     }

需要注意的是，在这里我们使用了MediaExtractor类，这个类可以让我们将流媒体文件的轨道分开。MediaExtractor从api16开始添加，可用于分离视频文件的音轨和视频轨道，如果你只想要视频，那么用selectTrack方法选中视频轨道，然后用readSampleData读出数据，这样你就得到了一个没有声音的视频，想得到音频也可以用同样的方法。

不太了解这个类的同学可以先去看看这个类，还挺有用的。

Android音频学习之MediaExtractor，提取音频视频轨道数据（从视频中分离音频视频数据）_mediaextractor extractor = new mediaextractor();-CSDN博客

  1. new Thread(new AudioDecodeRunnable(extractor, audioDecodePath, audioTrack, new DecodeOverListener() {
  2.                     @Override
  3.                     public void decodeOver() {
  4.                         Log.d(TAG, "IS DECODE OVER");
  5.                         audioCodecCallback.decodeOver();
  6.                     }
  7.  
  8.                     @Override
  9.                     public void decodeFail() {
  10.                         Log.d(TAG, "IS DECODE FAIL");
  11.                         audioCodecCallback.decodeFail();
  12.                     }
  13.                 })).start();

 在该方法中，核心逻辑是创建一个子线程去进行解码操作，需要注意的是，这是很有必要的，因为解码是一个比较耗时的操作，如果放在主线程可能会导致应用报不响应错误。

AudioDecodeRunnable
  1. package cn.yjs.mediacodecaccapplication;
  2.  
  3. import android.media.MediaCodec;
  4. import android.media.MediaExtractor;
  5. import android.media.MediaFormat;
  6. import android.util.Log;
  7.  
  8. import java.io.BufferedOutputStream;
  9. import java.io.File;
  10. import java.io.FileOutputStream;
  11. import java.io.IOException;
  12. import java.nio.ByteBuffer;
  13. import java.util.PrimitiveIterator;
  14.  
  15. public class AudioDecodeRunnable implements Runnable{
  16.     private static final String TAG ="YJS,AudioDecodeRunnable";
  17.     private MediaExtractor mediaExtractor;
  18.     private String mSavePath;
  19.     private int mTrackIndex;
  20.     private AudioCodec.DecodeOverListener listener;
  21.     final static int TIMEOUT_USEC = 1000;
  22.     MediaCodec audioCodec=null;
  23.  
  24.     public AudioDecodeRunnable(MediaExtractor mediaExtractor,String mSavePath,int mTrackIndex,AudioCodec.DecodeOverListener listener){
  25.         this.mediaExtractor=mediaExtractor;
  26.         this.mTrackIndex=mTrackIndex;
  27.         this.mSavePath=mSavePath;
  28.         this.listener=listener;
  29.  
  30.     }
  31.  
  32.     @Override
  33.     public void run() {
  34.         MediaFormat trackFormat = mediaExtractor.getTrackFormat(mTrackIndex);
  35.         // 初始化音频解码器,并配置解码器属性
  36.         audioCodec = null;
  37.         try {
  38.             // 初始化音频解码器,并配置解码器属性
  39.             audioCodec = MediaCodec.createDecoderByType(trackFormat.getString(MediaFormat.KEY_MIME));
  40.             audioCodec.configure(trackFormat, null, null, 0);
  41.             Log.d(TAG,"audioCodec.start();");
  42.             //启动MeidaCodec,等待传入数据
  43.             audioCodec.start();
  44.  
  45.             ByteBuffer[] inputBuffers = audioCodec.getInputBuffers();// 获取需要编码数据的输入流队列，返回的是一个ByteBuffer数组
  46.             ByteBuffer[] outputBuffers = audioCodec.getOutputBuffers();// 获取编解码之后的数据输出流队列，返回的是一个ByteBuffer数组
  47.             MediaCodec.BufferInfo decodeBufferInfo = new MediaCodec.BufferInfo();// 用于描述解码得到的byte[]数据的相关信息
  48.             MediaCodec.BufferInfo inputInfo = new MediaCodec.BufferInfo();// 用于描述输入数据的byte[]数据的相关信息
  49.  
  50.             boolean codeOver = false;
  51.             boolean inputDone = false;// 整体输入结束标记
  52.             File pcmSaveFile = new File(mSavePath);
  53.             FileOutputStream outputStream = new FileOutputStream(pcmSaveFile);
  54.             BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);
  55.             //输入
  56.             while (!codeOver){
  57.                 if (!inputDone){
  58.                     for (int i=0;i<inputBuffers.length;i++){
  59.                         Log.d(TAG,"audioCodec.dequeueInputBuffer(TIMEOUT_USEC) BEGIN");
  60.                         int mInputIndex = audioCodec.dequeueInputBuffer(TIMEOUT_USEC);
  61.                         Log.d(TAG,"audioCodec.dequeueInputBuffer(TIMEOUT_USEC) FINISH");
  62.                         if (mInputIndex>=0) {
  63.                             ByteBuffer mInputBuffer = inputBuffers[mInputIndex];
  64.                             mInputBuffer.clear();
  65.                             int mSampleSize = mediaExtractor.readSampleData(mInputBuffer, 0);
  66.                             if (mSampleSize < 0) {
  67.                                 Log.d(TAG, "结束输入");
  68.                                 audioCodec.queueInputBuffer(mInputIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
  69.                                 inputDone=true;
  70.                             } else {
  71.                                 Log.d(TAG, "mSampleSize:"+mSampleSize);
  72.                                 inputInfo.offset = 0;
  73.                                 inputInfo.flags = MediaCodec.BUFFER_FLAG_KEY_FRAME;
  74.                                 inputInfo.size = mSampleSize;
  75.                                 inputInfo.presentationTimeUs = mediaExtractor.getSampleTime();
  76.                                 Log.d(TAG, "往解码器写入数据，当前时间戳：" + inputInfo.presentationTimeUs);
  77.                                 //inputInfo.offset,inputInfo.size一起描述了要写入缓冲区的具体数据内容
  78.                                 audioCodec.queueInputBuffer(mInputIndex, inputInfo.offset, inputInfo.size, inputInfo.presentationTimeUs, inputInfo.flags);
  79.                                 mediaExtractor.advance();
  80.  
  81.                             }
  82.                         }
  83.                     }
  84.                 }
  85.  
  86. //输出
  87.                 boolean decodeOutputDone = false;// 整体解码结束标记
  88.                 while (!decodeOutputDone){
  89.                     Log.d(TAG,"audioCodec.dequeueOutputBuffer(decodeBufferInfo, TIMEOUT_USEC) BEGIN");
  90.                     int dequeueOutputIndex = audioCodec.dequeueOutputBuffer(decodeBufferInfo, TIMEOUT_USEC);
  91.                     Log.d(TAG,"dequeueOutputIndex:"+dequeueOutputIndex);
  92.                     Log.d(TAG,"audioCodec.dequeueOutputBuffer(decodeBufferInfo, TIMEOUT_USEC) FINISH");
  93.                     if (dequeueOutputIndex==MediaCodec.INFO_TRY_AGAIN_LATER){
  94.                         Log.d(TAG,"dequeueOutputIndex==MediaCodec.INFO_TRY_AGAIN_LATER");
  95.                         decodeOutputDone=true;
  96.                     }else if (dequeueOutputIndex==MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED){
  97.                         Log.d(TAG,"dequeueOutputIndex==MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED");
  98.                         outputBuffers=audioCodec.getOutputBuffers();
  99.                     }else if (dequeueOutputIndex==MediaCodec.INFO_OUTPUT_FORMAT_CHANGED){
  100.                         Log.d(TAG,"dequeueOutputIndex==MediaCodec.INFO_OUTPUT_FORMAT_CHANGED");
  101.                         MediaFormat outputFormat = audioCodec.getOutputFormat();
  102.                     }else if (dequeueOutputIndex<0){
  103.                         Log.d(TAG,"dequeueOutputIndex<0");
  104.                     }else {
  105.                         ByteBuffer outputBuffer = outputBuffers[dequeueOutputIndex];
  106.                         byte[] chunkpcm = new byte[decodeBufferInfo.size];
  107.                         outputBuffer.get(chunkpcm);
  108.                         outputBuffer.clear();
  109.                         Log.d(TAG,"outputStream.write,time:"+decodeBufferInfo.presentationTimeUs);
  110.                         bufferedOutputStream.write(chunkpcm);
  111.                         Log.d(TAG,"outputStream.write,FINISH");
  112.                         bufferedOutputStream.flush();
  113.                         //有surface可以设置成true，让这些outputbuffer直接到surface
  114.                         Log.d(TAG,"releaseOutputBuffer");
  115.                         audioCodec.releaseOutputBuffer(dequeueOutputIndex,false);
  116.                         if ((decodeBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {// 编解码结束
  117.                             Log.d(TAG,"编解码结束");
  118.                             mediaExtractor.release();
  119.                             audioCodec.stop();
  120.                             audioCodec.release();
  121.                             codeOver = true;
  122.                             decodeOutputDone = true;
  123.                         }
  124.                     }
  125.                 }
  126.  
  127.             }
  128.             outputStream.close();
  129.             listener.decodeOver();
  130.  
  131.         } catch (IOException e) {
  132.             e.printStackTrace();
  133.             audioCodec.stop();
  134.             audioCodec.release();
  135.             audioCodec=null;
  136.             listener.decodeFail();
  137.         }
  138.  
  139.     }
  140. }

代码量也不算特别多，大家可以仔细看看，应该没有什么阅读门槛，我把核心的逻辑标注一下，进行简单的解释。

创建配置启动 MediaCodec

  1. //创建MediaCodec
  2. audioCodec = MediaCodec.createDecoderByType(trackFormat.getString(MediaFormat.KEY_MIME));
  3. //配置MediaCodec
  4. audioCodec.configure(trackFormat, null, null, 0);
  5. //启动MediaCodec
  6. audioCodec.start();

将数据写入输入缓冲区，这里采用的是直接通过遍历将所有输入缓存区写入数据。

  1. int mInputIndex = audioCodec.dequeueInputBuffer(TIMEOUT_USEC);
  2.                         //只有获取的index大于0的时候，才表示有可用的输入缓冲区位置
  3.                         if (mInputIndex>=0) {
  4.                             ByteBuffer mInputBuffer = inputBuffers[mInputIndex];
  5.                             mInputBuffer.clear();
  6.                             //通过MediaExtractor读取mp3文件数据，注意这里是不能直接读取mp3的输入流放入到输入缓冲区中进行处理，mp3中有其他的格式，直接丢入会转换失败；
  7.                             int mSampleSize = mediaExtractor.readSampleData(mInputBuffer, 0);
  8.                             if (mSampleSize < 0) {
  9.                                 Log.d(TAG, "结束输入");
  10.                                 //当读取结束之后，记得给mediacodec加多一个flage表示该流结束
  11.                                 audioCodec.queueInputBuffer(mInputIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
  12.                                 inputDone=true;
  13.                             } else {
  14.                                 Log.d(TAG, "mSampleSize:"+mSampleSize);
  15.                                 inputInfo.offset = 0;
  16.                                 inputInfo.flags = MediaCodec.BUFFER_FLAG_KEY_FRAME;
  17.                                 inputInfo.size = mSampleSize;
  18.                                 inputInfo.presentationTimeUs = mediaExtractor.getSampleTime();
  19.                                 Log.d(TAG, "往解码器写入数据，当前时间戳：" + inputInfo.presentationTimeUs);
  20.                                 //inputInfo.offset,inputInfo.size一起描述了要写入缓冲区的具体数据内容
  21.                                 audioCodec.queueInputBuffer(mInputIndex, inputInfo.offset, inputInfo.size, inputInfo.presentationTimeUs, inputInfo.flags);
  22.                                 //使用 advance() 方法来移动到下一个样本的位置，以便后续进行数据的解析或处理。
  23.                                 mediaExtractor.advance();
  24.  
  25.                             }

这里指的注意的是，将最后读到的buffer写入到输入缓冲区的时候要特别设置一个结束的flag，这样也方便后续我们获取输出缓冲区数据作为停止获取的标识。

数据写入输入缓冲区之后，MediaCodec便会开始解码数据，解码结束之后，会将解码之后的数据传递到输出缓冲区中，这时候我们将其从输出缓冲区中取出来，通过IO流写入到文件中，便得到了我们需要的PCM文件。

接下来我会抽取出获取输出缓冲区数据的核心代码逻辑进行一个简单的注释讲解。

  1. //获取输出缓冲区索引
  2. int dequeueOutputIndex = audioCodec.dequeueOutputBuffer(decodeBufferInfo, TIMEOUT_USEC);
  3. //通过索引获得解码之后的数据
  4. ByteBuffer outputBuffer = outputBuffers[dequeueOutputIndex];
  5.                         byte[] chunkpcm = new byte[decodeBufferInfo.size];
  6.                         outputBuffer.get(chunkpcm);
  7.                         outputBuffer.clear();
  8.                         Log.d(TAG,"outputStream.write,time:"+decodeBufferInfo.presentationTimeUs);
  9.                         bufferedOutputStream.write(chunkpcm);
  10.                         Log.d(TAG,"outputStream.write,FINISH");
  11.                         bufferedOutputStream.flush();
  12.                         //有surface可以设置成true，让这些outputbuffer直接到surface
  13.                         Log.d(TAG,"releaseOutputBuffer");
  14.                         audioCodec.releaseOutputBuffer(dequeueOutputIndex,false);
  15.                         if ((decodeBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {// 编解码结束，这个flag是在输入的时候设置的结束标识
  16.                             Log.d(TAG,"编解码结束");
  17.                             mediaExtractor.release();
  18.                             audioCodec.stop();
  19.                             audioCodec.release();
  20.                             codeOver = true;
  21.                             decodeOutputDone = true;
  22.                         }

大家在使用IO流的时候可以主动的去使用缓冲流，这样可以加快IO流的速度，使用也是比较简单的。

但是需要注意的是缓冲I/O流适用于大多数情况，可以提高读取和写入数据的效率。然而，有一些特定情况下，使用缓冲I/O流可能不太适合：

  1. 对实时性要求较高的场景：缓冲I/O流会将数据存储在内存缓冲区中，当缓冲区满了或达到一定条件时才进行实际的I/O操作。这个过程会引入一定的延迟。如果你的应用对实时性要求很高，例如需要立即响应输入或输出的变化，那么可能不适合使用缓冲I/O流。

  2. 处理大型二进制文件的场景：缓冲I/O流适用于处理文本数据和小型文件。但是，如果你需要处理非常大的二进制文件，例如几个GB或更大的文件，将整个文件加载到内存缓冲区可能会导致内存不足或性能问题。在这种情况下，你可能需要考虑使用流式处理，逐块读取或写入数据。

  3. 需要精确控制I/O操作的场景：缓冲I/O流对于大多数常见的I/O操作来说是足够的，但是如果你需要对每个字节进行细粒度的控制，例如实现某些协议或算法，那么可能需要直接使用底层的非缓冲I/O流，以便更好地掌控每个字节的读写过程。

自此将MP3格式解码成PCM的流程大概就完成了，其实核心还是对MediaCodec的使用，输入缓冲区的放入数据，输出缓冲区的拿出数据。

PCM文件我们获取之后，我们就可以将这个PCM文件进行编码成AAC文件。其实代码流程跟解码PCM文件差不多。我将这个过程封装成了一个方法——PCMToAudio，接下来我们来集中解释一下这个方法的逻辑。

PCMToAudio

  1. public static void PCMToAudio(String mPcmInputPath, String mOutputAACPath, AudioCodecCallback audioCodecCallback) {
  2.         Log.d(TAG, "PCMToAudio");
  3.         new Thread(new AudioEncodeRunnable(mPcmInputPath, mOutputAACPath, new EnCodeOverListener() {
  4.             @Override
  5.             public void devodeOver() {
  6.                 Log.d(TAG, "PCMToAudio,decodeOver");
  7.                 audioCodecCallback.decodeOver();
  8.             }
  9.  
  10.             @Override
  11.             public void decodeFail() {
  12.                 Log.d(TAG,"PCMToAudio,decodeFail");
  13.                 audioCodecCallback.decodeFail();
  14.             }
  15.         })).start();
  16.     }

可以看到这个方法也是通过创建一个子线程进行PCM文件的编码，防止直接在主线程中进行编码操作，导致应用ANR。 

AudioEncodeRunnable
  1. package cn.yjs.mediacodecaccapplication;
  2.  
  3. import android.hardware.TriggerEventListener;
  4. import android.media.MediaCodec;
  5. import android.media.MediaCodecInfo;
  6. import android.media.MediaFormat;
  7. import android.util.Log;
  8.  
  9. import java.io.BufferedInputStream;
  10. import java.io.BufferedOutputStream;
  11. import java.io.File;
  12. import java.io.FileInputStream;
  13. import java.io.FileOutputStream;
  14. import java.io.IOException;
  15. import java.nio.ByteBuffer;
  16. import java.util.Arrays;
  17.  
  18. public class AudioEncodeRunnable implements Runnable {
  19.  
  20.     public final String TAG = "yjs,AudioEncodeRunnable";
  21.     private String mInputPcmPath;
  22.     private String mOutputAACPath;
  23.     private AudioCodec.EnCodeOverListener enCodeOverListener;
  24.     private MediaCodec mediaEncode;
  25.     private FileInputStream fileInputStream;
  26.     private BufferedInputStream bufferedInputStream;
  27.     private FileOutputStream fileOutputStream;
  28.     private BufferedOutputStream bufferedOutputStream;
  29.  
  30.  
  31.     public AudioEncodeRunnable(String mInputPcmPath, String mOutputAACPath, AudioCodec.EnCodeOverListener enCodeOverListener) {
  32.         this.mInputPcmPath = mInputPcmPath;
  33.         this.mOutputAACPath = mOutputAACPath;
  34.         this.enCodeOverListener = enCodeOverListener;
  35.     }
  36.  
  37.     @Override
  38.     public void run() {
  39.         Log.d(TAG, "begin to encode pcm");
  40.         try {
  41.             if (!new File(mInputPcmPath).exists()) {// pcm文件目录不存在
  42.                 if (enCodeOverListener != null) {
  43.                     enCodeOverListener.decodeFail();
  44.                 }
  45.                 return;
  46.             }
  47.             // 初始化编码格式   mimetype  采样率  声道数
  48.             //创建了一个音频格式为 AAC 的 MediaFormat 对象，采样率为 44100 Hz，声道数为 2（立体声）。
  49.             MediaFormat encodeFormat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, 44100, 2);
  50.             //每秒传输的比特数为 96000，用于控制编码后音频的质量和文件大小。
  51.             encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, 96000);
  52.             //其中 AACObjectLC 表示使用低复杂度配置（Low Complexity），这是 AAC 编码的一种配置模式，适用于较低的计算资源和功耗。
  53.             encodeFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
  54.             //设置编码器输入缓冲区的最大大小为 500 KB
  55.             encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 500 * 1024);
  56.  
  57.             // 初始化编码器
  58.             mediaEncode = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
  59.             mediaEncode.configure(encodeFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  60.             mediaEncode.start();
  61.  
  62.             fileInputStream = new FileInputStream(new File(mInputPcmPath));
  63.             bufferedInputStream = new BufferedInputStream(fileInputStream);
  64.             fileOutputStream = new FileOutputStream(new File(mOutputAACPath));
  65.             bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
  66.  
  67.             //通过mediacodec获取输入输出的容器
  68.             ByteBuffer[] inputBuffers = mediaEncode.getInputBuffers();
  69.             ByteBuffer[] outputBuffers = mediaEncode.getOutputBuffers();
  70.             MediaCodec.BufferInfo encodeBufferInfo = new MediaCodec.BufferInfo();
  71.             byte[] buffer = new byte[8 * 1024];
  72.             byte[] allAudioBytes=null;
  73.  
  74.             boolean isReadDone = false;
  75.             while (true) {
  76.                 if (!isReadDone) {
  77.                     Log.d(TAG, "get mediaEncode.dequeueInputBuffer(-1) begin");
  78.                     int dequeueInputBufferIndex = mediaEncode.dequeueInputBuffer(0);
  79.                     Log.d(TAG, "mediaEncode.dequeueInputBuffer(-1) end");
  80.                     if (dequeueInputBufferIndex >= 0) {
  81.                         int read = bufferedInputStream.read(buffer);
  82.                         if (read != -1) {
  83.                             Log.d(TAG, "读取到pcm文件");
  84.                             allAudioBytes = Arrays.copyOf(buffer, read);
  85.                             ByteBuffer inputBuffer = inputBuffers[dequeueInputBufferIndex];
  86.                             inputBuffer.clear();
  87.                             inputBuffer.put(allAudioBytes);
  88.                             mediaEncode.queueInputBuffer(dequeueInputBufferIndex, 0, allAudioBytes.length, 0, 0);
  89.                         } else {
  90.                             Log.d(TAG, "读取结束");
  91.                             mediaEncode.queueInputBuffer(dequeueInputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
  92.                             isReadDone = true;
  93.                         }
  94.                     } else {
  95.                         Log.d(TAG, "没有可用的input 小推车");
  96.                     }
  97.                 }
  98.                 Log.d(TAG, "encode begin to dequeueoutputbuffer");
  99.                 //dequeueBuffer
  100.                 int dequeueOutputBufferIndex = mediaEncode.dequeueOutputBuffer(encodeBufferInfo, 0);
  101.                 Log.d(TAG, "dequeueOutputBufferIndex:" + dequeueOutputBufferIndex);
  102.                 switch (dequeueOutputBufferIndex) {
  103.                     case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
  104.                         Log.i(TAG, "输出的format已更改" + mediaEncode.getOutputFormat());
  105.                         break;
  106.                     case MediaCodec.INFO_TRY_AGAIN_LATER:
  107.                         Log.i(TAG, "超时，没获取到");
  108.                         break;
  109.                     case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
  110.                         Log.i(TAG, "输出缓冲区已更改");
  111.                         break;
  112.                     default:
  113.                         // 从解码器中取出数据
  114.                         int outBitSize = encodeBufferInfo.size;
  115.                         int outPacketSize = outBitSize + 7;// 7为adts头部大小
  116.                         ByteBuffer outputBuffer = outputBuffers[dequeueOutputBufferIndex];// 拿到输出的buffer
  117.                         //
  118.                         outputBuffer.position(encodeBufferInfo.offset);
  119.                         outputBuffer.limit(encodeBufferInfo.offset + outBitSize);
  120.  
  121.                         byte[] chunkAudio = new byte[outPacketSize];
  122.                         addADTStoPacket(chunkAudio, outPacketSize);
  123.                         outputBuffer.get(chunkAudio, 7, outBitSize);
  124.                         outputBuffer.position(encodeBufferInfo.offset);
  125.                         bufferedOutputStream.write(chunkAudio);
  126.                         bufferedOutputStream.flush();
  127.                         mediaEncode.releaseOutputBuffer(dequeueOutputBufferIndex, false);
  128.                         Log.d(TAG, "mediaEncode.releaseOutputBuffer(dequeueOutputBufferIndex, false)");
  129.                         break;
  130.                 }
  131.                 if ((encodeBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
  132.                     Log.i(TAG, "表示当前编解码已经完事了");
  133.                     break;
  134.                 }
  135.             }
  136.             if (enCodeOverListener != null) {
  137.                 enCodeOverListener.devodeOver();
  138.             }
  139.         } catch (IOException e) {
  140.             throw new RuntimeException(e);
  141.         }finally {
  142.             mediaEncode.stop();
  143.             mediaEncode.release();
  144.             try {
  145.                 bufferedOutputStream.close();
  146.                 fileOutputStream.close();
  147.                 bufferedInputStream.close();
  148.                 fileOutputStream.close();
  149.             } catch (IOException e) {
  150.                 throw new RuntimeException(e);
  151.             }
  152.         }
  153.  
  154.     }
  155.  
  156.     /**
  157.      * 添加ADTS头
  158.      *
  159.      * @param packet
  160.      * @param packetLen
  161.      */
  162.     private void addADTStoPacket(byte[] packet, int packetLen) {
  163.         int profile = 2; // AAC LC
  164.         int freqIdx = 4; // 44.1KHz
  165.         int chanCfg = 2; // CPE
  166.  
  167.         // fill in ADTS data
  168.         packet[0] = (byte) 0xFF;
  169.         packet[1] = (byte) 0xF9;
  170.         packet[2] = (byte) (((profile - 1) << 6) + (freqIdx << 2) + (chanCfg >> 2));
  171.         packet[3] = (byte) (((chanCfg & 3) << 6) + (packetLen >> 11));
  172.         packet[4] = (byte) ((packetLen & 0x7FF) >> 3);
  173.         packet[5] = (byte) (((packetLen & 7) << 5) + 0x1F);
  174.         packet[6] = (byte) 0xFC;
  175.     }
  176. }

还是一样的讲解方式，上面是完整的代码逻辑，可以自己仔细看看，我这边挑一些比较核心的语句进行讲解。

配置并启动编码器

  1. // 初始化编码格式   mimetype  采样率  声道数
  2.             //创建了一个音频格式为 AAC 的 MediaFormat 对象，采样率为 44100 Hz，声道数为 2（立体声）。
  3.             MediaFormat encodeFormat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, 44100, 2);
  4.             //每秒传输的比特数为 96000，用于控制编码后音频的质量和文件大小。
  5.             encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, 96000);
  6.             //其中 AACObjectLC 表示使用低复杂度配置（Low Complexity），这是 AAC 编码的一种配置模式，适用于较低的计算资源和功耗。
  7.             encodeFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
  8.             //设置编码器输入缓冲区的最大大小为 500 KB
  9.             encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 500 * 1024);
  10.  
  11. mediaEncode = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
  12.             mediaEncode.configure(encodeFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  13.             mediaEncode.start();

紧接着便是想办法将PCM文件读取传入输入缓冲区

  1. Log.d(TAG, "get mediaEncode.dequeueInputBuffer(-1) begin");
  2.                     int dequeueInputBufferIndex = mediaEncode.dequeueInputBuffer(0);
  3.                     Log.d(TAG, "mediaEncode.dequeueInputBuffer(-1) end");
  4.                     if (dequeueInputBufferIndex >= 0) {
  5.                         int read = bufferedInputStream.read(buffer);
  6.                         if (read != -1) {
  7.                             Log.d(TAG, "读取到pcm文件");
  8.                             allAudioBytes = Arrays.copyOf(buffer, read);
  9.                             ByteBuffer inputBuffer = inputBuffers[dequeueInputBufferIndex];
  10.                             inputBuffer.clear();
  11.                             inputBuffer.put(allAudioBytes);
  12.                             mediaEncode.queueInputBuffer(dequeueInputBufferIndex, 0, allAudioBytes.length, 0, 0);
  13.                         } else {
  14.                             Log.d(TAG, "读取结束");
  15.                             mediaEncode.queueInputBuffer(dequeueInputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
  16.                             isReadDone = true;
  17.                         }
  18.                     } else {
  19.                         Log.d(TAG, "没有可用的input 小推车");
  20.                     }

 跟之前的解码流程差不多，读取数据传入到输入缓冲区中，然后注意在结束的时候，传入输入缓冲区一个结束flag。

紧接着我们再去获取输出缓冲区的数据

  1. int dequeueOutputBufferIndex = mediaEncode.dequeueOutputBuffer(encodeBufferInfo, 0);
  2.                 Log.d(TAG, "dequeueOutputBufferIndex:" + dequeueOutputBufferIndex);
  3.                 switch (dequeueOutputBufferIndex) {
  4.                     case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
  5.                         Log.i(TAG, "输出的format已更改" + mediaEncode.getOutputFormat());
  6.                         break;
  7.                     case MediaCodec.INFO_TRY_AGAIN_LATER:
  8.                         Log.i(TAG, "超时，没获取到");
  9.                         break;
  10.                     case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
  11.                         Log.i(TAG, "输出缓冲区已更改");
  12.                         break;
  13.                     default:
  14.                         // 从解码器中取出数据
  15.                         int outBitSize = encodeBufferInfo.size;
  16.                         int outPacketSize = outBitSize + 7;// 7为adts头部大小
  17.                         ByteBuffer outputBuffer = outputBuffers[dequeueOutputBufferIndex];// 拿到输出的buffer
  18.                         //
  19.                         outputBuffer.position(encodeBufferInfo.offset);
  20.                         outputBuffer.limit(encodeBufferInfo.offset + outBitSize);
  21.  
  22.                         byte[] chunkAudio = new byte[outPacketSize];
  23.                         addADTStoPacket(chunkAudio, outPacketSize);
  24.                         outputBuffer.get(chunkAudio, 7, outBitSize);
  25.                         outputBuffer.position(encodeBufferInfo.offset);
  26.                         bufferedOutputStream.write(chunkAudio);
  27.                         bufferedOutputStream.flush();
  28.                         mediaEncode.releaseOutputBuffer(dequeueOutputBufferIndex, false);
  29.                         Log.d(TAG, "mediaEncode.releaseOutputBuffer(dequeueOutputBufferIndex, false)");
  30.                         break;
  31.                 }
  32.                 if ((encodeBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
  33.                     Log.i(TAG, "表示当前编解码已经完事了");
  34.                     break;
  35.                 }
  36.             }

这里有两个地方需要注意的，首先就是我们这边是不断去获取输出缓冲区数据，知道我们读取到结束flag停止获取输出缓冲区数据，因为这时候已经获取完了。

其次就是对于我们获取出来数据，如果直接写入到文件中其实是没有编码完成的，我们还需要再每次读取的数据前面加上ADTS才是完整的。ATDS需要七位的存储空间，所以我们需要预留七个位子在字节数组中。同时可以看到我们这里使用了bytebuffer的position，get，limit等方法，这些都是NIO典型的方法使用，我们需要另外学习一下才能更好的消化上面的代码。我这边给大家附上学习的链接，我这边就不进行详细讲解了。

玩转 ByteBuffer - 知乎 (zhihu.com)

同时获取完输出缓冲区数据之后也一定要记得执行 mediaEncode.releaseOutputBuffer方法，否则会导致非常多问题，不断可能输出缓冲区一直获取不到可用索引，也可能导致输入缓冲区也一直获取不到可用索引，所以释放这一步至关重要。

自此PCM编码为AAC的流程就差不多导通了，将填充好的数据通过IO流写入文件便可以得到AAC文件，该文件是可以直接在播放器中进行播放。大家可以通过是否可以在播放器中播放判断自己是否编码成功。

总结

其实MediaCodec的使用步骤还是非常简单的，主要是第一次使用会觉得有点生疏，所以觉得有点难以接受。其实也就是那些东西，大家认真写个demo基本就能摸透他的使用。我最后将一般使用的逻辑顺序罗列出来，大家好好消化一下即可。

1.通过IO流获取文件

2.配置启动MediaCodec

3.获取输入缓冲区可用索引

4.根据索引写入数据

5.获取输出缓冲区可用索引

6.根据索引获取数据

7.通过IO流写入到文件中

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/895181
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号