多个不同分辨率的MediaCodec编码对应一个glsurfaceview应该如何编码？

如果你想在一个 GLSurfaceView 上同时显示多个 MediaCodec 编码后的图像，可以考虑使用 OpenGL ES 来实现这个功能。具体来说，你可以将每个 MediaCodec 的输出数据绑定到一个纹理上，并在 GLSurfaceView 上绘制这些纹理，从而实现多个不同分辨率的视频流的同时显示。

具体实现步骤如下：

1. 创建多个 MediaCodec，并分别对其进行初始化和启动。

2. 对每个 MediaCodec 创建一个 Surface，并将其作为编码器的输入 Surface。

3. 对每个 MediaCodec 创建一个 OutputSurface，并将其作为解码器的输出 Surface。

4. 在 GLSurfaceView 中创建多个纹理，并将每个纹理与对应的 OutputSurface 关联。

5. 在 GLSurfaceView 的渲染回调函数中，将每个纹理绑定到对应的纹理单元，并使用 OpenGL ES 的绘制命令绘制纹理。

需要注意的是，由于不同分辨率的视频流的宽高比可能不同，因此需要在绘制时进行适当的缩放和裁剪，以确保每个视频流的显示效果均匀。此外，由于多个 MediaCodec 的编码和解码操作都需要占用较大的计算资源，因此在实现时需要考虑如何优化性能，以确保视频流的流畅显示。

相关问题

android glsurfaceview +camera+mediaCodec编码，在不影响预览的情况下，如何自定义编码帧率(0-30帧)

在android glsurfaceview +camera+mediaCodec编码中，可以通过设置MediaCodec的参数来自定义编码帧率，具体步骤如下：

1. 创建MediaCodec编码器

MediaCodec mediaCodec = MediaCodec.createEncoderByType(mimeType);

2. 配置MediaCodec参数

MediaFormat mediaFormat = MediaFormat.createVideoFormat(mimeType, width, height);
mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate); // 设置帧率
mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
mediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);

其中，frameRate参数即为要设置的帧率值，可以在0-30之间自定义。

3. 启动MediaCodec编码器

mediaCodec.start();

4. 循环获取相机预览数据并进行编码

while (mIsRecording) {
    // 获取相机预览数据
    byte[] input = getCameraData();
    // 将获取到的数据传入MediaCodec进行编码
    int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);
    if (inputBufferIndex >= 0) {
        ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
        inputBuffer.clear();
        inputBuffer.put(input);
        mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, System.nanoTime() / 1000, 0);
    }
    // 获取编码后的数据
    int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US);
    if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
        // 获取到编码后的格式信息，可进行相关初始化操作
        MediaFormat newFormat = mediaCodec.getOutputFormat();
        // ...
    } else if (outputBufferIndex >= 0) {
        ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
        byte[] output = new byte[bufferInfo.size];
        outputBuffer.get(output);
        // 处理编码后的数据
        // ...
        mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
    }
}

通过以上步骤，即可在不影响预览的情况下自定义编码帧率。需要注意的是，帧率的设置只是建议值，并不一定能够达到。

AudioRecord回调给多个MediaCodec编码的示例代码

以下是一个AudioRecord回调给多个MediaCodec编码的示例代码：

public class AudioEncoder {
    private static final String TAG = "AudioEncoder";
    private static final String MIME_TYPE = "audio/mp4a-latm";
    private static final int SAMPLE_RATE = 44100;
    private static final int CHANNEL_COUNT = 1;
    private static final int BIT_RATE = 64000;

    private AudioRecord mAudioRecord;
    private MediaCodec mMediaCodec;
    private boolean mIsRecording;
    private ByteBuffer[] mInputBuffers;
    private ByteBuffer[] mOutputBuffers;
    private MediaCodec.BufferInfo mBufferInfo;
    private List<MediaMuxerWrapper> mMuxerWrappers;

    public void startRecording() {
        mIsRecording = true;
        mAudioRecord.startRecording();

        try {
            mMediaCodec = MediaCodec.createEncoderByType(MIME_TYPE);
            MediaFormat format = MediaFormat.createAudioFormat(MIME_TYPE, SAMPLE_RATE, CHANNEL_COUNT);
            format.setInteger(MediaFormat.KEY_BIT_RATE, BIT_RATE);
            format.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
            mMediaCodec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            mMediaCodec.start();

            mInputBuffers = mMediaCodec.getInputBuffers();
            mOutputBuffers = mMediaCodec.getOutputBuffers();
            mBufferInfo = new MediaCodec.BufferInfo();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (mIsRecording) {
                        int index = mMediaCodec.dequeueInputBuffer(-1);
                        if (index >= 0) {
                            ByteBuffer inputBuffer = mInputBuffers[index];
                            inputBuffer.clear();
                            int bufferSize = mAudioRecord.read(inputBuffer, inputBuffer.capacity());
                            if (bufferSize >= 0) {
                                long presentationTimeUs = System.nanoTime() / 1000;
                                mMediaCodec.queueInputBuffer(index, 0, bufferSize, presentationTimeUs, 0);
                            }
                        }

                        int outputIndex = mMediaCodec.dequeueOutputBuffer(mBufferInfo, 0);
                        while (outputIndex >= 0) {
                            ByteBuffer outputBuffer = mOutputBuffers[outputIndex];
                            outputBuffer.position(mBufferInfo.offset);
                            outputBuffer.limit(mBufferInfo.offset + mBufferInfo.size);

                            for (MediaMuxerWrapper muxerWrapper : mMuxerWrappers) {
                                muxerWrapper.writeSampleData(AudioMuxerWrapper.TRACK_INDEX, outputBuffer, mBufferInfo);
                            }

                            mMediaCodec.releaseOutputBuffer(outputIndex, false);
                            outputIndex = mMediaCodec.dequeueOutputBuffer(mBufferInfo, 0);
                        }
                    }
                }
            }).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void stopRecording() {
        mIsRecording = false;
        mAudioRecord.stop();
        mMediaCodec.stop();
        mMediaCodec.release();
    }

    public void addMuxerWrapper(MediaMuxerWrapper muxerWrapper) {
        mMuxerWrappers.add(muxerWrapper);
    }
}

这个示例代码中，我们启动一个AudioRecord对象，然后启动一个MediaCodec对象，使用MediaCodec API将音频数据编码为AAC格式。我们将编码器的输出提供给一个MediaMuxerWrapper对象，它可以将音频数据写入一个MP4文件中。我们可以在不同的线程中同时启动多个MediaMuxerWrapper对象，这样我们就可以将音频数据写入多个MP4文件中。