opengl es 离屏使用的具体例子

OpenGL ES（Elastic OpenGL ES）是一种轻量级版本的OpenGL，适用于移动设备和嵌入式系统。离屏渲染是指将图形绘制到一个Offscreen Buffer（内存缓冲区），而不是直接显示到屏幕上，然后在合适的时候再将缓冲内容复制回屏幕。

一个具体的例子可能是游戏开发中的帧缓冲（Framebuffer Object, FBO）。在游戏中，你可以创建一个FBO，并将背景图、粒子效果等复杂的渲染工作放在这个缓冲上。步骤如下：

1. **创建FBO**：首先，你需要创建一个FBO并绑定，设置其宽度和高度与屏幕一致。

2. **绘制到FBO**：在游戏循环的每一帧，绘制场景元素时，将GL drawing target切换到FBO，而不是默认的屏幕，这样所有的渲染都会进入这个内存缓冲。

3. **存储数据**：绘制完成后，FBO的内容保存在内存中。

4. **复制结果**：当需要更新屏幕时，再将FBO的内容解绑并复制到屏幕缓冲，完成画面刷新。

5. **清理资源**：最后别忘了释放FBO和其他相关资源。

这种技术有助于优化性能，尤其是在处理复杂图形和动画时，因为它允许你在后台进行大量渲染，只在需要的时候将最终结果呈现在用户眼前。

相关问题

OPENGL es MediaCodec例子

这里提供一个使用OpenGL ES和MediaCodec的简单例子，用于解码视频并将其渲染到屏幕上：

public class VideoRenderer implements SurfaceTexture.OnFrameAvailableListener {

    private static final String TAG = "VideoRenderer";

    private SurfaceTexture mSurfaceTexture;
    private Surface mSurface;
    private int mTextureId;

    private MediaCodec mMediaCodec;
    private MediaFormat mMediaFormat;
    private ByteBuffer[] mInputBuffers;
    private ByteBuffer[] mOutputBuffers;

    private int mWidth;
    private int mHeight;

    private boolean mIsRunning = false;

    private EGLDisplay mEGLDisplay;
    private EGLSurface mEGLSurface;
    private EGLContext mEGLContext;

    public VideoRenderer(SurfaceTexture surfaceTexture, int width, int height) {
        mSurfaceTexture = surfaceTexture;
        mWidth = width;
        mHeight = height;
    }

    public void start(String filePath) throws IOException {
        mMediaFormat = MediaFormat.createVideoFormat("video/avc", mWidth, mHeight);
        mMediaCodec = MediaCodec.createDecoderByType("video/avc");
        mMediaCodec.configure(mMediaFormat, mSurface, null, 0);
        mInputBuffers = mMediaCodec.getInputBuffers();
        mOutputBuffers = mMediaCodec.getOutputBuffers();

        File file = new File(filePath);
        FileInputStream inputStream = new FileInputStream(file);
        FileChannel fileChannel = inputStream.getChannel();

        mMediaCodec.start();

        while (mIsRunning) {
            int inputBufferIndex = mMediaCodec.dequeueInputBuffer(1000);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = mInputBuffers[inputBufferIndex];
                int sampleSize = fileChannel.read(inputBuffer);
                if (sampleSize < 0) {
                    mMediaCodec.queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                } else {
                    mMediaCodec.queueInputBuffer(inputBufferIndex, 0, sampleSize, 0, 0);
                }
            }

            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
            int outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 1000);
            while (outputBufferIndex >= 0) {
                mMediaCodec.releaseOutputBuffer(outputBufferIndex, true);
                outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
            }
        }
    }

    public void stop() {
        mIsRunning = false;

        // Release MediaCodec
        if (mMediaCodec != null) {
            mMediaCodec.stop();
            mMediaCodec.release();
            mMediaCodec = null;
        }

        // Destroy EGL context and surface
        if (mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
            EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
            if (mEGLSurface != null) {
                EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
            }
            if (mEGLContext != null) {
                EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
            }
            EGL14.eglTerminate(mEGLDisplay);
        }

        // Release SurfaceTexture and Surface
        if (mSurfaceTexture != null) {
            mSurfaceTexture.release();
            mSurfaceTexture = null;
        }
        if (mSurface != null) {
            mSurface.release();
            mSurface = null;
        }
    }

    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
        // Update SurfaceTexture
        surfaceTexture.updateTexImage();

        // Render frame with OpenGL ES
        float[] transformMatrix = new float[16];
        surfaceTexture.getTransformMatrix(transformMatrix);
        GLES20.glClearColor(0, 0, 0, 1);
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
        GLES20.glUseProgram(mProgram);
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTextureId);
        GLES20.glUniformMatrix4fv(mTransformMatrixHandle, 1, false, transformMatrix, 0);
        GLES20.glVertexAttribPointer(mPositionHandle, 2, GLES20.GL_FLOAT, false, 0, mVertexBuffer);
        GLES20.glVertexAttribPointer(mTextureHandle, 2, GLES20.GL_FLOAT, false, 0, mTextureBuffer);
        GLES20.glEnableVertexAttribArray(mPositionHandle);
        GLES20.glEnableVertexAttribArray(mTextureHandle);
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
        GLES20.glDisableVertexAttribArray(mPositionHandle);
        GLES20.glDisableVertexAttribArray(mTextureHandle);

        // Swap buffers
        EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
    }
}

在这个示例中，我们首先创建一个`SurfaceTexture`和一个`Surface`来将视频渲染到屏幕上。然后，我们创建一个`MediaCodec`来解码视频，并将其配置为使用指定的`Surface`进行输出。我们使用`FileInputStream`和`FileChannel`来从文件中读取视频数据，并将其输入到`MediaCodec`中进行解码。最后，我们使用OpenGL ES将解码后的视频帧渲染到屏幕上。

需要注意的是，在`onFrameAvailable`回调中，我们需要使用OpenGL ES将视频帧渲染到屏幕上，并且需要在渲染完成后调用`EGL14.eglSwapBuffers`来交换前后缓冲区。此外，我们还需要在程序退出时释放所有资源，包括`MediaCodec`，EGL上下文和SurfaceTexture。

使用OpenGL3.0为AVFrame离屏渲染添加水印的完整代码

由于AVFrame和OpenGL在很多方面都是非常复杂的主题，因此为AVFrame添加水印的完整代码可能因情况而异，具体取决于您的环境和需求。不过，我可以提供一个基本的框架，以便您开始尝试在OpenGL 3.0中为AVFrame添加水印。以下是一个简单的例子，它使用OpenGL 3.0为AVFrame离屏渲染添加一个简单的红色矩形：

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define WIDTH 640
#define HEIGHT 480

GLuint loadShader(const char* source, GLenum shaderType);
GLuint createProgram(const char* vertexShaderSource, const char* fragmentShaderSource);

int main() {
  GLFWwindow* window;

  if (!glfwInit()) {
    std::cerr << "Failed to initialize GLFW" << std::endl;
    return -1;
  }

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  window = glfwCreateWindow(WIDTH, HEIGHT, "AVFrame Watermarking", NULL, NULL);
  if (!window) {
    std::cerr << "Failed to create GLFW window" << std::endl;
    glfwTerminate();
    return -1;
  }

  glfwMakeContextCurrent(window);

  if (glewInit() != GLEW_OK) {
    std::cerr << "Failed to initialize GLEW" << std::endl;
    return -1;
  }

  const GLfloat vertices[] = {
    -1.0f, -1.0f,
    1.0f, -1.0f,
    1.0f, 1.0f,
    -1.0f, 1.0f,
  };

  const GLushort indices[] = { 0, 1, 2, 0, 2, 3 };

  GLuint vao, vbo, ebo;
  glGenVertexArrays(1, &vao);
  glBindVertexArray(vao);

  glGenBuffers(1, &vbo);
  glBindBuffer(GL_ARRAY_BUFFER, vbo);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  glGenBuffers(1, &ebo);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);

  const char* vertexShaderSource = R"glsl(
    #version 300 es

    in vec2 position;

    void main() {
      gl_Position = vec4(position, 0.0, 1.0);
    }
  )glsl";

  const char* fragmentShaderSource = R"glsl(
    #version 300 es

    precision mediump float;

    out vec4 fragColor;

    void main() {
      fragColor = vec4(1.0, 0.0, 0.0, 1.0);
    }
  )glsl";

  GLuint program = createProgram(vertexShaderSource, fragment