「Android音视频编码那点破事」第五章，使用MediaCodec编码AAC音频数据

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

/**
 * 初始化AudioRecord对象
 */
private fun config(){
    /**
     * 计算缓存PCM数据的Buffer最小大小
     * parameter.audio.sampleRateInHz = 16000
     * parameter.audio.pcm = AudioFormat.ENCODING_PCM_16BIT
     * parameter.audio.samplePerFrame = 1024
     * parameter.video.fps = 30
     *
     */
    val minBufferSize = AudioRecord.getMinBufferSize(parameter.audio.sampleRateInHz,
        AudioFormat.CHANNEL_IN_MONO, parameter.audio.pcm)
    /**
     * 计算buffer大小
     */
    bufferSize = parameter.audio.samplePerFrame * parameter.video.fps
    if (bufferSize < minBufferSize)
        bufferSize = (minBufferSize / parameter.audio.samplePerFrame + 1) * parameter.audio.samplePerFrame * 2
    
    debug_e("bufferSize: $bufferSize")
    /**
     * 新建储存PCM数据发Buffer
     */
    buffer = ByteArray(parameter.audio.samplePerFrame)
    /**
     * 新建AudioRecord对象
     */
    record = AudioRecord(MediaRecorder.AudioSource.MIC, parameter.audio.sampleRateInHz,
        AudioFormat.CHANNEL_IN_MONO, parameter.audio.pcm, bufferSize)
    /**
     * 开始录制音频
     */
    record?.startRecording()
}
private fun read() {
    /**
     * 读取PCM数据
     */
    val bufferReadResult = record!!.read(buffer, 0, parameter.audio.samplePerFrame)
    onPCMListener?.onPCMSample(buffer!!)
}

override fun run() {
    while (mStart) {
        read()
    }
}

fun createAudioFormat(parameter: Parameter, ignoreDevice: Boolean = false): MediaFormat? {
    val mediaFormat = MediaFormat()
    /**
     * 编码格式AAC：parameter.audio.mime = "audio/mp4a-latm"
     * 声道数量：parameter.audio.channel = 1
     * 频率：parameter.audio.sampleRateInHz = 16000
     * 码率：parameter.audio.bitrate = 64000
     * Level：parameter.audio.profile = MediaCodecInfo.CodecProfileLevel.AACObjectLC
     */
    mediaFormat.setString(MediaFormat.KEY_MIME, parameter.audio.mime)
    mediaFormat.setInteger(MediaFormat.KEY_CHANNEL_COUNT, parameter.audio.channel)
    mediaFormat.setInteger(MediaFormat.KEY_SAMPLE_RATE, parameter.audio.sampleRateInHz)
    mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, parameter.audio.bitrate)
    mediaFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, parameter.audio.profile)
    return mediaFormat
}

private fun initCodec() {
    val format = CodecHelper.createAudioFormat(parameter)
    try {
        codec = MediaCodec.createEncoderByType(format?.getString(MediaFormat.KEY_MIME))
        codec?.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
        codec?.start()
        audioWrapper = AudioRecordWrapper(parameter)
        audioWrapper?.setOnPCMListener(this)
    } catch (e: Exception) {
        debug_e("Can not create codec")
    } finally {
        if (null == codec)
            debug_e("Can not create codec")
    }
}

/**
 * 把PCM数据送入编码器的输入缓存队列
 */
private fun encode(buffer: ByteArray) {
    try {
        pTimer.record()
        /**
         * 获取输入缓存队列
         */
        inputBuffers = codec!!.inputBuffers
        /**
         * 输入输出缓存队列
         */
        outputBuffers = codec!!.outputBuffers
        /**
         * 从编码器中获取一个缓冲区的下标
         */
        val inputBufferIndex = codec!!.dequeueInputBuffer(WAIT_TIME)
        if (inputBufferIndex >= 0) {
            /**
             * 通过下标获取缓冲区
             */
            val inputBuffer = inputBuffers!![inputBufferIndex]
            inputBuffer.clear()
            /**
             * 把PCM数据送入缓冲区
             */
            inputBuffer.put(buffer)
            /**
             * 把带有PCM的数据缓冲区送进编码器
             */
            codec!!.queueInputBuffer(inputBufferIndex, 0, buffer.size, 0, 0)
        }
        /**
         * 从编码器中获取编码后的数据
         */
        dequeue()
    } catch (e: Exception) {
        e.printStackTrace()
    }
}
/**
 * 从编码器中获取编码后的数据
 */
private fun dequeue(): Boolean {
    try {
        /**
         * 从输出缓冲区取出一个Buffer，返回一个状态
         * 这是一个同步操作，所以我们需要给定最大等待时间WAIT_TIME，一般设置为10000ms
         */
        val flag = codec!!.dequeueOutputBuffer(bufferInfo, WAIT_TIME)
        when (flag) {
            MediaCodec.INFO_TRY_AGAIN_LATER -> {//等待超时，需要再次等待，通常忽略
                return false
            }
            /**
             * 输出格式改变，很重要
             * 这里必须把outputFormat设置给MediaMuxer，而不能不能用inputFormat代替，它们时不一样的，不然无法正确生成mp4文件
             */
            MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
                debug_v("AUDIO INFO_OUTPUT_FORMAT_CHANGED")
                onSampleListener?.onFormatChanged(codec!!.outputFormat)
            }
            else -> {
                if (flag < 0) return@dequeue false//如果小于零，则跳过
                val data = codec!!.outputBuffers[flag]//否则代表编码成功，可以从输出缓冲区队列取出数据
                if (null != data) {
                    val endOfStream = bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM
                    if (endOfStream == 0) {//如果没有收到BUFFER_FLAG_END_OF_STREAM信号，则代表输出数据时有效的
                        bufferInfo.presentationTimeUs = pTimer.presentationTimeUs
                        //通过回调，把编码后的数据送进MediaMuxer
                        onSampleListener?.onSample(bufferInfo, data)
                    }
                    //缓冲区使用完后必须把它还给MediaCodec，以便再次使用，至此一个流程结束，再次循环
                    codec!!.releaseOutputBuffer(flag, false)
//                        if (endOfStream == MediaCodec.BUFFER_FLAG_END_OF_STREAM) {
//                            return true
//                        }
                    return true
                }
            }
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
    return false
}