MediaCodec API，完成音频 AAC 硬编，5.0异步处理，AudioRecord 录音

AAC硬件编码文章有几篇，但是都是同步实现，这里采用异步实现，代码Kotlin。

虽然代码是kotlin写的，但是思路上面的按照java能复制出来

最后我会把代码上传到github，可以查看完整过程，为了方便查看，所以代码都写在 Activity中

录音和编码都设置在子线程

采取的是边录制边编码边写入文件

6.0注意动态权限问题，录音，读写文件

示例使用的5.0以上的API

MediaCodec官方原理图

上面是官方的一张原理图，我就先说下基本原理 MediaCodec给我们提供了一组InputBuffer和一组outputBuffer，我们通过手段获取到空的InputBuffer，装填原始音频数据，然后把装填后的buffer还给Codec让他去编码，他编码 后会把编码后文件放在outputBuffer中，我们获取outputBuffer读取数据保存到文件就好， 然后循环这个过程，完成所有文件的编码和保存。

这里注意并不是一个inputBuffer对应一个outputBuffer，一个输入buffer可以对应多个输出 buffer，比如你往inputBuffer添加1000个字节数据，他可能编码后放入了多个outputBuffer 中，一个outputBuffer可能就200或者300个字节。

下面就是实际操作过程

1.完成AudioRecord配置

   /**
     * 初始化音频采集
     */

    private fun initAudioRecorder() {
        //设置最小缓冲区大小  根据系统提供的方法计算
        minBufferSize = AudioRecord.getMinBufferSize(
            AudioConfig.SAMPLE_RATE,
            AudioConfig.CHANNEL_CONFIG, AudioConfig.AUDIO_FORMAT
        )

        //创建音频记录器对象
        audioRecorder = AudioRecord(
            MediaRecorder.AudioSource.MIC,
            AudioConfig.SAMPLE_RATE, AudioConfig.CHANNEL_CONFIG, AudioConfig.AUDIO_FORMAT,
            minBufferSize
        )
    }

上面的AudioConfig配置文件如下

    const val SAMPLE_RATE = 44100  //采样率
    /**
     * CHANNEL_IN_MONO 单声道   能够保证所有设备都支持
     * CHANNEL_IN_STEREO 立体声
     */
    const val CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO

    /**
     * 返回的音频数据格式
     */
    const val AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT

    /**
     * 输出的音频声道
     */
    const val CHANNEL_OUT_CONFIG = AudioFormat.CHANNEL_OUT_MONO

2.创建LinkedBlockingQeque准备保存录音数据

因为录音和编码都放在子线程去做，所以数据难以传递，通过同步队列保存来保证 正确读取数据，保存的数据类型是字节数组

 private var audioList: LinkedBlockingDeque<ByteArray>? = LinkedBlockingDeque()

3.开始录音并保存

  //开启线程启动录音
  thread(priority = android.os.Process.THREAD_PRIORITY_URGENT_AUDIO) {
            try {
                //判断AudioRecord是否初始化成功
                if (AudioRecord.STATE_INITIALIZED == audioRecorder.state) {
                      isRecording = true  //标记是否在录制中
                    audioRecorder.startRecording()
                    val outputArray = ByteArray(minBufferSize)
                    while (isRecording) {

                        var readCode = audioRecorder.read(outputArray, 0, minBufferSize)

                       //这个readCode还有很多小于0的数字，表示某种错误，
                       //这里为了方便就没处理
                        if (readCode > 0) {
                            val realArray = ByteArray(readCode)
                            System.arraycopy(outputArray, 0, realArray, 0, readCode)
                            //将读取的数据保存到LinkedBlockingDeque
                            audioList?.offer(realArray)
                        }
                    }
                    //录制结束，添加结束标记，方便编码时候知道录制结束了
                    //这个结束标记只是一个例子，不一定必须是这个数组，只要能
                    //区别正常数据，能被作为特殊的数据被识别就行
                    val stopArray = byteArrayOf((-777).toByte(), (-888).toByte())
                    audioList?.offer(stopArray)
                }
            } catch (e: IOException) {

            } finally {
                if (audioRecorder != null)
                    //释放资源，别忘记！！！
                    audioRecorder.release()

            }

        }

上面采用添加结束数据的方式标识录取音频结束，编码的时候可以根据这个来判断 是否已到达编码流的结尾

4.配置和启动编码(子线程中开启任务)

编码和解码必填数据

上图为编码和解码必要的数据，如果解码的MediaFormat是MediaExtractor取出，一般 就直接配置好了，就不需要自己填写了

   fun mediaCodecEncodeToAAC() {

        val currentTime = Date().time * 1000
        try {
            val isSupprot = isSupprotAAC()
            //创建音频MediaFormat，也可以new的方式创建，不过那样需要
            //自己再setXXX设置数据
            val encodeFormat =
                MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, 
                AudioConfig.SAMPLE_RATE, 1)
            /**
             * 下面配置几个比较关键的参数
             */
            //配置比特率
            encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, 96000)
            //配置AAC描述，AAC有很多规格LC是其中一个
            encodeFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, 
            MediaCodecInfo.CodecProfileLevel.AACObjectLC)
            //配置最大输入大小，这里配置的是前面起算的大小的2倍
            encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, minBufferSize * 2)

            //初始化编码器
            mediaEncode = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC)
            //设置异步回调，后面会贴出callback实现
            mediaEncode.setCallback(callback）
            //调用configure，进入configured状态
            mediaEncode.configure(encodeFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
            //调用start，进入starting状态
            mediaEncode.start()
        } catch (e: IOException) {

        } finally {
        }
    }

下面是callback的实现代码

object : MediaCodec.Callback() {
        override fun onOutputFormatChanged(codec: MediaCodec, format: MediaFormat) {
        }

        override fun onError(codec: MediaCodec, e: MediaCodec.CodecException) {
            Log.i("error", e.message)
        }
        //系统获取到有可用的输出buffer时候自动回调
        override fun onOutputBufferAvailable(
            codec: MediaCodec,
            index: Int,
            info: MediaCodec.BufferInfo
        ) {

           //通过bufferinfo获取Buffer的数据，这些数据就是编码后的数据
            val outBitsSize = info.size

            //为AAC文件添加头部，头部占7字节
            //AAC有 ADIF和ADTS两种  ADIF只有一个头部剩下都是音频文件
            //ADTS是每一段编码都有一个头部
            //outpacketSize是最后头部加上返回数据后的总大小
            val outPacketSize = outBitsSize + 7 // 7 is ADTS size

            //根据index获取buffer
            val outputBuffer = codec.getOutputBuffer(index)

            // 防止buffer有offset导致自己从0开始获取，
            // 取出数据(但是我实验的offset都为0，可能有些不为0的情况)
            outputBuffer.position(info.offset)

            //设置buffer的操作上限位置，不清楚的可以查下ByteBuffer(NIO知识),
            //了解limit ，position，clear(),filp()都是啥作用
            outputBuffer.limit(info.offset + outBitsSize)

            //创建byte数组保存组合数据
            val outData = ByteArray(outPacketSize)

            //为数据添加头部，后面会贴出，就是在头部写入7个数据
            addADTStoPacket(AudioConfig.SAMPLE_RATE, outData, outPacketSize)

            //将buffer的数据存入数组中
            outputBuffer.get(outData, 7, outBitsSize)

            outputBuffer.position(info.offset)


            //bufferedOutputStream是我创建的包装流，
            //包装的FileOutputStream

            //将数据写到文件
             bufferedOutputStream.write(outData)
            bufferedOutputStream.flush()
            outputBuffer.clear()
            //释放输出buffer！！！！！  一定要释放
            codec.releaseOutputBuffer(index, false)
        }

        /**
         *当系统有可用的输入buffer就会自动回调
         */
        override fun onInputBufferAvailable(codec: MediaCodec, index: Int) {

            //根据index获取buffer
            val inputBuffer = codec.getInputBuffer(index)

            //从LinkBlockingDeque中获取还未编码的原音频数据
            val pop = audioList?.poll()

            //判断是否到达音频数据的结尾，这个条件根据自己设定的结束标志而定，
            //这里我是这样判断
            if (pop != null && pop.size >= 2 && (pop[0] == (-777).toByte() && pop[1] == (-888).toByte())) {
                //结束标志
                isEndTip = true
            }

            //如果数据不为空，而且不是结束标志，写入buffer，让MediaCodec去编码
            //currentTime是之前创建的变量Date().getTime(),下面用当前时间减去他，
            //是为了最终传入的数据小点

            if (pop != null && !isEndTip) {

                //填入数据
                inputBuffer?.clear()
                inputBuffer?.limit(pop.size)
                inputBuffer?.put(pop, 0, pop.size)
                //将buffer还给MediaCodec，这个一定要还
                //第四个参数为时间戳，也就是，必须是递增的，系统根据这个计算
                //音频总时长和时间间隔
                codec.queueInputBuffer(
                    index,
                    0,
                    pop.size,
                    Date().time * 1000 - currentTime,
                    0
                )
            }

            // 由于2个线程谁先执行不确定，所以可能编码线程先启动，获取到队列的数据为null
            // 而且也不是结尾数据，这个时候也要调用queueInputBuffer，将buffer换回去，写入
            // 数据大小就写0

            // 如果为null就不调用queueInputBuffer  回调几次后就会导致无可用InputBuffer，
            // 从而导致MediaCodec任务结束 只能写个配置文件
            if (pop == null && !isEndTip) {

                codec.queueInputBuffer(
                        index,
                        0,
                        0,
                        Date().time * 1000 - currentTime,
                        0
                )
            }

            //发现结束标志，写入结束标志，
            //flag为MediaCodec.BUFFER_FLAG_END_OF_STREAM
            //通知编码结束
            if (isEndTip) {
                codec.queueInputBuffer(
                    index,
                    0,
                    0,
                    Date().time * 1000 - currentTime,
                    MediaCodec.BUFFER_FLAG_END_OF_STREAM
                )
            }
        }

            })

注意事项

1. onInputBufferAvaliable回调，发现获取到的ByteArray为null，也就是录音还没录入数据切记也要将获取到的inputBuffer还回去，调用queueInputBuffer，不然一会就发现inputBuffer都没还导致无可用buffer，这个方法就不会在回调，就再也无法写入数据了！！！！！！！！！！！！！！！血的教训，之前忘了还导致每次文件大小都是9B（2字节系统默认写入，7字节添加的头部）
2. 感知到录音结束，没有数据了，要写入流结束标志，让onInputBufferAvaliable停止回调，不再接收编码数据，标志为 MediaCodec.BUFFER_FLAG_END_OF_STREAM

5.编写头文件

头文件我直接在网上找的

   /**
     * 添加ADTS头，如果要与视频流合并就不用添加，单独AAC文件就需要添加，否则无法正常播放
     * @param sampleRateType 就是之前配置的采样率
     * @param packet  之前创建的字节数组，保存头和编码后音频数据
     * @param packetLen 字节数组总长度
     */
    fun addADTStoPacket(sampleRateType: Int, packet: ByteArray, packetLen: Int) {
        val profile = 2 // AAC LC
        val chanCfg = 1 // 声道数  这个就是你之前配置的声道数量

        packet[0] = 0xFF.toByte()
        packet[1] = 0xF9.toByte()
        packet[2] = ((profile - 1 shl 6) + (sampleRateType shl 2) + (chanCfg shr 2)).toByte()
        packet[3] = ((chanCfg and 3 shl 6) + (packetLen shr 11)).toByte()
        packet[4] = (packetLen and 0x7FF shr 3).toByte()
        packet[5] = ((packetLen and 7 shl 5) + 0x1F).toByte()
        packet[6] = 0xFC.toByte()
    }

6.创建输出文件

这一步可能不是必须的，因为我们在写入文件时候，系统发现没有文件，就会先创建 ，但是如果路径设置问题，有可能写入时候老是写不进去，我就遇到，数据不为0，但是 最终写入后文件大小为0，所以保险起见我都是先创建文件，如果你们遇到一样的情况，可以 试下这一步

//filesDir 就是context.getFilesDir
  file = File(filesDir, "record.aac")
  if (!file.exists()) {
          //不存在就创建
        file.createNewFile()
  }

  if (file.isDirectory) {
  }
   else {
            outputStream = FileOutputStream(file, true)
            bufferedOutputStream = BufferedOutputStream(outputStream, 4096)
   }

完整代码地址：https://github.com/wu781521512/MediaStudyProject

-- END --

本文由哈喽比特于2年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/Hm8edLpvmD_KB5zO_UnVRw