Android MediaCodec 音频

Android MediaCodec 是一个强大的多媒体编解码器，它可以用来处理音频和视频数据。对于音频编解码，MediaCodec 提供了许多编解码器，如 AAC、MP3、WMA 等。

在使用 MediaCodec 编解码音频时，需要先创建一个音频编解码器，并设置相应的参数，如输入数据格式、输出数据格式、编码器的类型等。然后将需要编解码的音频数据分割成一定大小的数据块，通过输入缓冲区传递给音频编解码器，编码后的数据通过输出缓冲区返回。

使用 MediaCodec 编解码音频需要注意以下几点：

1. 确保输入数据格式和编码器支持的数据格式一致；
2. 确保输入数据分割后的数据块大小不超过编码器限制的最大输入缓冲区大小；
3. 确保输出数据缓冲区足够大，以存储编码后的数据；
4. 注意编解码器的状态，及时处理错误和异常。

总之，使用 MediaCodec 编解码音频可以实现高效、灵活的音频处理，但需要仔细处理好各种参数和状态，才能获得良好的编解码效果。

相关问题

Android MediaCodec 录制音频功能实现

Android MediaCodec 可以用于音频编码和解码，也可以用于音频录制。以下是利用 MediaCodec 实现音频录制的步骤：

1. 创建 MediaCodec 实例

首先需要创建一个 MediaCodec 实例，用于音频编码。可以通过以下方式创建：

MediaFormat format = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, sampleRate, channelCount);
format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, bufferSize);
MediaCodec codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

其中，`sampleRate` 表示采样率，`channelCount` 表示声道数，`bitRate` 表示比特率，`bufferSize` 表示缓冲区大小，这些参数需要根据实际情况设置。

2. 准备音频数据源

在录制音频之前，需要准备音频数据源。可以使用 AudioRecord 类录制音频数据，也可以使用其他方式获取音频数据。

AudioRecord audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleRate, channelConfig, audioFormat, bufferSize);
audioRecord.startRecording();

其中，`sampleRate`、`channelConfig`、`audioFormat`、`bufferSize` 都需要根据实际情况设置。

3. 编码音频数据

获取到音频数据后，需要将音频数据编码为 AAC 格式。可以通过以下方式实现：

ByteBuffer[] inputBuffers = codec.getInputBuffers();
ByteBuffer[] outputBuffers = codec.getOutputBuffers();
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
boolean isEOS = false;
while (!isEOS) {
    int inBufferIndex = codec.dequeueInputBuffer(-1);
    if (inBufferIndex >= 0) {
        ByteBuffer buffer = inputBuffers[inBufferIndex];
        buffer.clear();
        int sampleSize = audioRecord.read(buffer, bufferSize);
        if (sampleSize < 0) {
            isEOS = true;
            codec.queueInputBuffer(inBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
        } else {
            codec.queueInputBuffer(inBufferIndex, 0, sampleSize, 0, 0);
        }
    }

    int outBufferIndex = codec.dequeueOutputBuffer(bufferInfo, 0);
    switch (outBufferIndex) {
        case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
            MediaFormat format = codec.getOutputFormat();
            break;

        case MediaCodec.INFO_TRY_AGAIN_LATER:
            break;

        case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
            outputBuffers = codec.getOutputBuffers();
            break;

        default:
            ByteBuffer buffer = outputBuffers[outBufferIndex];
            // 处理编码后的音频数据
            codec.releaseOutputBuffer(outBufferIndex, false);
            break;
    }
}

其中，`inputBuffers` 和 `outputBuffers` 分别表示输入和输出缓冲区，`bufferInfo` 表示缓冲区信息，`isEOS` 表示是否结束录制。

4. 释放资源

在录制完成后，需要释放资源。可以通过以下方式实现：

audioRecord.stop();
audioRecord.release();
codec.stop();
codec.release();

以上就是利用 MediaCodec 实现音频录制的步骤。需要注意的是，MediaCodec 的使用比较复杂，需要仔细阅读官方文档并进行实践。

Android MediaCodec 录制音频功能完整代码

以下是一个简单的 Android MediaCodec 录制音频的完整代码示例：

import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaFormat;
import android.media.MediaMuxer;
import android.os.Build;
import android.os.Environment;
import android.util.Log;

import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;

public class AudioRecorder {

    private static final String TAG = "AudioRecorder";

    private static final String AUDIO_MIME_TYPE = "audio/mp4a-latm";
    private static final int AUDIO_SAMPLE_RATE = 44100; // 44.1kHz
    private static final int AUDIO_CHANNEL_COUNT = 1; // mono
    private static final int AUDIO_BIT_RATE = 64000;

    private static final int BUFFER_SIZE = 2 * AudioRecord.getMinBufferSize(AUDIO_SAMPLE_RATE,
            AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);

    private MediaCodec mEncoder;
    private MediaMuxer mMuxer;
    private int mTrackIndex = -1;
    private boolean mMuxerStarted = false;
    private long mStartTime = 0;

    public void startRecording() throws IOException {
        File outputFile = new File(Environment.getExternalStorageDirectory(),
                "audio_record.mp4");

        mEncoder = MediaCodec.createEncoderByType(AUDIO_MIME_TYPE);
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, AUDIO_MIME_TYPE);
        format.setInteger(MediaFormat.KEY_SAMPLE_RATE, AUDIO_SAMPLE_RATE);
        format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, AUDIO_CHANNEL_COUNT);
        format.setInteger(MediaFormat.KEY_BIT_RATE, AUDIO_BIT_RATE);
        format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, BUFFER_SIZE);
        }
        mEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        mEncoder.start();

        mMuxer = new MediaMuxer(outputFile.getAbsolutePath(), MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);

        ByteBuffer[] encoderOutputBuffers = mEncoder.getOutputBuffers();
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

        mTrackIndex = -1;
        mMuxerStarted = false;

        int sampleRate = AUDIO_SAMPLE_RATE;
        int channelCount = AUDIO_CHANNEL_COUNT;
        long presentationTimeUs = 0;

        while (true) {
            int inputBufferIndex = mEncoder.dequeueInputBuffer(-1);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = mEncoder.getInputBuffer(inputBufferIndex);
                inputBuffer.clear();
                int bytesRead = // read audio data into the inputBuffer
                if (bytesRead == -1) { // eof
                    mEncoder.queueInputBuffer(inputBufferIndex, 0, 0, presentationTimeUs,
                            MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                    break;
                } else {
                    int inputBufferCapacity = inputBuffer.capacity();
                    int size = inputBufferCapacity < bytesRead ? inputBufferCapacity : bytesRead;
                    inputBuffer.put(audioData, 0, size);
                    presentationTimeUs = (long) (1_000_000L * bytesRead / (2 * channelCount * sampleRate));
                    mEncoder.queueInputBuffer(inputBufferIndex, 0, size, presentationTimeUs, 0);
                }
            }

            int outputBufferIndex = mEncoder.dequeueOutputBuffer(bufferInfo, 0);
            if (outputBufferIndex >= 0) {
                ByteBuffer outputBuffer = encoderOutputBuffers[outputBufferIndex];
                if (!mMuxerStarted) {
                    MediaFormat newFormat = mEncoder.getOutputFormat();
                    mTrackIndex = mMuxer.addTrack(newFormat);
                    mMuxer.start();
                    mStartTime = System.nanoTime();
                    mMuxerStarted = true;
                }
                if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                    bufferInfo.size = 0;
                }
                if (bufferInfo.size != 0) {
                    outputBuffer.position(bufferInfo.offset);
                    outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
                    mMuxer.writeSampleData(mTrackIndex, outputBuffer, bufferInfo);
                }
                mEncoder.releaseOutputBuffer(outputBufferIndex, false);
            } else if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                MediaFormat newFormat = mEncoder.getOutputFormat();
                mTrackIndex = mMuxer.addTrack(newFormat);
                mMuxer.start();
                mStartTime = System.nanoTime();
                mMuxerStarted = true;
            }
        }
        release();
    }

    private void release() {
        if (mEncoder != null) {
            mEncoder.stop();
            mEncoder.release();
            mEncoder = null;
        }
        if (mMuxer != null) {
            if (mMuxerStarted) {
                mMuxer.stop();
            }
            mMuxer.release();
            mMuxer = null;
        }
    }
}

注意，这只是一个简单的示例，实际应用中还需要考虑错误处理、音频数据来源和如何停止录制等问题。