openGL ES 在android中通过MediaCodec RGB的buffer转换MP4原理

在 Android 中，要通过 MediaCodec 将 OpenGL ES 中的 RGB 数据转换为 MP4 格式的视频，需要以下步骤：

1. 创建一个 MediaCodec 编码器，并将其配置为编码 H.264 视频格式。

2. 使用 SurfaceTexture 将 OpenGL ES 中的图像渲染到 Surface 上。

3. 从 Surface 中获取帧数据，并将其传递给 MediaCodec 编码器进行编码。

4. 编码器将帧数据编码为 H.264 视频流，并将其存储到一个 MP4 文件中。

其中，步骤 2 和 3 是关键步骤，需要使用 Android 中提供的一些 API 来实现。具体来说，可以使用 SurfaceTexture 的 onFrameAvailable 回调函数来获取新的帧数据，然后将其传递给 MediaCodec 编码器进行编码。

需要注意的是，由于 OpenGL ES 中的帧数据是以 RGB 格式存储的，而 MediaCodec 编码器需要的是 YUV 格式的数据，因此需要在传递给编码器之前进行 RGB 到 YUV 的转换。这可以通过 OpenGL ES 中提供的一些函数来实现，例如 glReadPixels 和 glTexImage2D。

总体来说，将 OpenGL ES 中的 RGB 数据转换为 MP4 格式的视频是一个比较复杂的过程，需要涉及到多个方面的知识，包括 OpenGL ES、MediaCodec、SurfaceTexture 等。

相关问题

openGL ES 在android中通过MediaCodec RGB的buffer转换MP4例子

以下是一个基本的示例，演示如何使用OpenGL ES和MediaCodec将RGB图像数据转换为MP4视频：

1. 首先，需要创建一个OpenGL ES上下文并设置它的表面为MediaCodec的输入表面。这可以通过使用EGL库和MediaCodec的createInputSurface()方法来完成。以下是一个示例代码片段：

EGLDisplay eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
EGL14.eglInitialize(eglDisplay, version, 0, version, 1);

int[] configAttribs = {
    EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
    EGL14.EGL_SURFACE_TYPE, EGL14.EGL_PBUFFER_BIT,
    EGL14.EGL_RED_SIZE, 8,
    EGL14.EGL_GREEN_SIZE, 8,
    EGL14.EGL_BLUE_SIZE, 8,
    EGL14.EGL_ALPHA_SIZE, 8,
    EGL14.EGL_NONE
};

EGLConfig[] configs = new EGLConfig[1];
int[] numConfigs = new int[1];
EGL14.eglChooseConfig(eglDisplay, configAttribs, 0, configs, 0, 1, numConfigs, 0);

int[] surfaceAttribs = {
    EGL14.EGL_WIDTH, inputWidth,
    EGL14.EGL_HEIGHT, inputHeight,
    EGL14.EGL_NONE
};

EGLSurface surface = EGL14.eglCreatePbufferSurface(eglDisplay, configs[0], surfaceAttribs, 0);
EGLContext context = EGL14.eglCreateContext(eglDisplay, configs[0], EGL14.EGL_NO_CONTEXT, new int[] {EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE}, 0);
EGL14.eglMakeCurrent(eglDisplay, surface, surface, context);

MediaCodec codec = MediaCodec.createEncoderByType("video/avc");
MediaFormat format = MediaFormat.createVideoFormat("video/avc", inputWidth, inputHeight);
format.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
Surface inputSurface = codec.createInputSurface();

2. 接下来，需要将RGB图像数据传递到OpenGL ES渲染管道中，并使用MediaCodec的输入表面将渲染结果作为视频帧发送到编码器。以下是一个示例代码片段：

// 将RGB数据传递到纹理中
int[] textures = new int[1];
GLES20.glGenTextures(1, textures, 0);
int textureId = textures[0];
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, inputWidth, inputHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, ByteBuffer.wrap(rgbData));
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);

// 渲染帧
int vertexShader = ShaderUtils.loadShader(GLES20.GL_VERTEX_SHADER, VERTEX_SHADER);
int fragmentShader = ShaderUtils.loadShader(GLES20.GL_FRAGMENT_SHADER, FRAGMENT_SHADER);
int program = ShaderUtils.createProgram(vertexShader, fragmentShader);
int positionHandle = GLES20.glGetAttribLocation(program, "position");
int textureHandle = GLES20.glGetUniformLocation(program, "texture");
int matrixHandle = GLES20.glGetUniformLocation(program, "matrix");

GLES20.glViewport(0, 0, inputWidth, inputHeight);
GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

GLES20.glUseProgram(program);

float[] vertices = {
    -1.0f, -1.0f,
    1.0f, -1.0f,
    -1.0f, 1.0f,
    1.0f, 1.0f
};
ByteBuffer vertexBuffer = ByteBuffer.allocateDirect(vertices.length * 4);
vertexBuffer.order(ByteOrder.nativeOrder());
FloatBuffer floatBuffer = vertexBuffer.asFloatBuffer();
floatBuffer.put(vertices);
floatBuffer.position(0);

GLES20.glVertexAttribPointer(positionHandle, 2, GLES20.GL_FLOAT, false, 0, floatBuffer);
GLES20.glEnableVertexAttribArray(positionHandle);

Matrix.setIdentityM(matrix, 0);
Matrix.scaleM(matrix, 0, -1f, 1f, 1f);
Matrix.rotateM(matrix, 0, 270, 0, 0, 1);
GLES20.glUniformMatrix4fv(matrixHandle, 1, false, matrix, 0);

GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
GLES20.glUniform1i(textureHandle, 0);

GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

// 将渲染结果发送到编码器
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
int outputBufferIndex = codec.dequeueOutputBuffer(bufferInfo, TIMEOUT_US);
if (outputBufferIndex >= 0) {
    ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferIndex);
    outputBuffer.position(bufferInfo.offset);
    outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
    videoTrackIndex = muxer.addTrack(format);
    muxer.writeSampleData(videoTrackIndex, outputBuffer, bufferInfo);
    codec.releaseOutputBuffer(outputBufferIndex, false);
}

3. 最后，需要在完成所有帧的渲染后释放OpenGL ES上下文和MediaCodec资源。以下是一个示例代码片段：

EGL14.eglDestroySurface(eglDisplay, surface);
EGL14.eglDestroyContext(eglDisplay, context);
EGL14.eglTerminate(eglDisplay);

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

muxer.stop();
muxer.release();

注意：这只是一个基本示例，你需要根据你的具体情况进行修改。例如，你需要在每一帧之间等待编码器的输出缓冲区，以确保数据正确输出。

openGL ES 在android中通过MediaCodec RGB的buffer转换MP4代码例子

以下是一个基本的示例代码，展示了如何使用OpenGL ES和MediaCodec API将RGB数据转换为MP4格式：

public class EncoderThread extends Thread {
    private static final String TAG = "EncoderThread";
    private static final String MIME_TYPE = "video/avc";
    private static final int FRAME_RATE = 30;
    private static final int I_FRAME_INTERVAL = 1;
    private static final int TIMEOUT_USEC = 10000;

    private Surface mSurface;
    private EGLContext mEGLContext;

    private MediaCodec mEncoder;
    private MediaMuxer mMuxer;
    private int mTrackIndex;
    private boolean mMuxerStarted;

    public EncoderThread(Surface surface, EGLContext context) {
        mSurface = surface;
        mEGLContext = context;
    }

    @Override
    public void run() {
        try {
            prepareEncoder();
            prepareEGL();
            loop();
            releaseEncoder();
            releaseEGL();
        } catch (Exception e) {
            Log.e(TAG, "Encoder thread error: " + e);
        }
    }

    private void prepareEncoder() throws IOException {
        MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, width, height);
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        format.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, I_FRAME_INTERVAL);

        mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);
        mEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
        mSurface = mEncoder.createInputSurface();
        mEncoder.start();

        mMuxer = new MediaMuxer(outputFile, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
        mMuxerStarted = false;
        mTrackIndex = -1;
    }

    private void prepareEGL() {
        EGLDisplay display = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
        int[] version = new int[2];
        EGL14.eglInitialize(display, version, 0, version, 1);
        int[] attribList = {
                EGL14.EGL_RED_SIZE, 8,
                EGL14.EGL_GREEN_SIZE, 8,
                EGL14.EGL_BLUE_SIZE, 8,
                EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
                EGL14.EGL_NONE
        };
        EGLConfig[] configs = new EGLConfig[1];
        int[] numConfigs = new int[1];
        EGL14.eglChooseConfig(display, attribList, 0, configs, 0, configs.length, numConfigs, 0);
        EGLConfig config = configs[0];
        int[] attribList2 = {
                EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
                EGL14.EGL_NONE
        };
        EGLContext context = EGL14.eglCreateContext(display, config, mEGLContext, attribList2, 0);
        EGLSurface surface = EGL14.eglCreateWindowSurface(display, config, mSurface, attribList2, 0);
        EGL14.eglMakeCurrent(display, surface, surface, context);
    }

    private void loop() {
        while (true) {
            GLES20.glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
            EGLSurface eglSurface = EGL14.eglGetCurrentSurface(EGL14.EGL_DRAW);
            mEncoder.getInputSurface().swapBuffers();
            drainEncoder();
            if (mIsEndOfStream) {
                signalEndOfInputStream();
                break;
            }
        }
    }

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

    private void releaseEGL() {
        EGLDisplay display = EGL14.eglGetCurrentDisplay();
        EGLSurface surface = EGL14.eglGetCurrentSurface(EGL14.EGL_DRAW);
        EGLContext context = EGL14.eglGetCurrentContext();
        EGL14.eglMakeCurrent(display, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
        EGL14.eglDestroySurface(display, surface);
        EGL14.eglDestroyContext(display, context);
        EGL14.eglTerminate(display);
    }

    private void drainEncoder() {
        ByteBuffer[] encoderOutputBuffers = mEncoder.getOutputBuffers();
        while (true) {
            int encoderStatus = mEncoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_USEC);
            if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
                break;
            } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                encoderOutputBuffers = mEncoder.getOutputBuffers();
            } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                if (mMuxerStarted) {
                    throw new RuntimeException("Format changed twice");
                }
                MediaFormat newFormat = mEncoder.getOutputFormat();
                mTrackIndex = mMuxer.addTrack(newFormat);
                mMuxer.start();
                mMuxerStarted = true;
            } else if (encoderStatus < 0) {
                Log.e(TAG, "unexpected result from encoder.dequeueOutputBuffer: " + encoderStatus);
            } else {
                ByteBuffer encodedData = encoderOutputBuffers[encoderStatus];
                if (encodedData == null) {
                    throw new RuntimeException("encoderOutputBuffer " + encoderStatus + " was null");
                }
                if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                    mBufferInfo.size = 0;
                }
                if (mBufferInfo.size != 0) {
                    if (!mMuxerStarted) {
                        throw new RuntimeException("muxer hasn't started");
                    }
                    encodedData.position(mBufferInfo.offset);
                    encodedData.limit(mBufferInfo.offset + mBufferInfo.size);
                    mMuxer.writeSampleData(mTrackIndex, encodedData, mBufferInfo);
                }
                mEncoder.releaseOutputBuffer(encoderStatus, false);
                if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                    mIsEndOfStream = true;
                    break;
                }
            }
        }
    }
}

这个示例代码包括了几个关键的步骤，包括：

1. 创建一个MediaCodec编码器，并配置它的参数。
2. 创建一个OpenGL ES渲染器，并将渲染的图像数据绘制到屏幕上。
3. 将渲染的图像数据传递给MediaCodec编码器进行压缩。
4. 将编码后的视频数据写入一个MP4文件中。
5. 在循环中不断地从编码器的输出缓冲区中获取压缩数据，并将其写入MP4文件中。

需要注意的是，这个示例代码只是一个基本的框架，实际上还需要处理许多细节，例如处理OpenGL ES渲染器的生命周期、设置编码器的参数、处理编码器的输出缓冲区等。