Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

基于C语言和opengl es3.2版本加载两张NV12图片并进行alpha blend渲染

  1. User

    基于C语言和opengl es3.2版本加载两张NV12图片并进行alpha blend渲染

  2. Assistant

    抱歉,本AI无法提供完整的C语言和opengl es3.2版本代码来加载和alpha blend渲染NV12图片。以下为参考资料,供参考。

    1. 加载NV12图片

    NV12是一种YCbCr格式的图像数据,即亮度(Y)和两个色度(Cb和Cr)的数据。需要将其转换为OpenGL ES能够处理的RGBA格式。以下是一种实现方式:

    // 计算像素点的索引
    int index = (y * width) + x;
    
    // 获取亮度分量
    unsigned char y = imgData[index];
    
    // 计算Cb和Cr分量的索引
    int cbCrIndex = (y/2) * width + (x/2) * 2;
    
    // 获取色度分量
    unsigned char cb = imgData[cbCrIndex + 1];
    unsigned char cr = imgData[cbCrIndex];
    
    // 转换为OpenGL ES可用的RGBA格式
    float r = y + 1.402f * (cr - 128);
    float g = y - 0.344f * (cb - 128) - 0.714f * (cr - 128);
    float b = y + 1.772f * (cb - 128);
    float a = 1.0f;
    
    // 存储RGBA值
    imgDataRGBA[index * 4] = r;
    imgDataRGBA[index * 4 + 1] = g;
    imgDataRGBA[index * 4 + 2] = b;
    imgDataRGBA[index * 4 + 3] = a;
    
    1. Alpha Blend渲染

    在OpenGL ES中实现Alpha Blend渲染需要使用以下的函数:

    glEnable(GL_BLEND); // 开启blending
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // 设定blending模式
    

    然后,在渲染两张图片时,需要分别计算它们的颜色值和alpha值,然后进行适当的Alpha Blend混合。

    // 绑定第一张NV12图片的纹理
    glBindTexture(GL_TEXTURE_2D, texture1);
    
    // 绑定第二张NV12图片的纹理
    glBindTexture(GL_TEXTURE_2D, texture2);
    
    // 开启blending
    glEnable(GL_BLEND);
    
    // 设定blending模式
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    // 渲染第一张图片
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    
    // 渲染第二张图片
    glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
    
    // 关闭blending
    glDisable(GL_BLEND);
    

    注意,以上只是一个简单的示例。在实际应用中,需要根据具体情况选择适当的Alpha Blend混合模式。

  3. User

    基于C语言和opengl es3.2版本加载两张NV12图片并进行alpha blend渲染 demo

  4. Assistant

    这里提供一个简单的C语言和OpenGL ES 3.2版本的demo,加载两张NV12格式的图片并进行Alpha Blend混合。该demo仅供参考,需要根据实际情况进行适当的修改和完善。

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include <GLES3/gl32.h>
    #include <EGL/egl.h>
    #include <EGL/eglext.h>
    
    #ifndef GL_TEXTURE_EXTERNAL_OES
    #define GL_TEXTURE_EXTERNAL_OES 0x8D65
    #endif
    
    #define WIN_W 640
    #define WIN_H 480
    
    #define TEXTURE_WIDTH 256
    #define TEXTURE_HEIGHT 256
    
    #define NV12_SIZE (TEXTURE_WIDTH * TEXTURE_HEIGHT * 3 / 2)
    
    const char *vertexShaderSource = "#version 320 es\n"
        "layout(location = 0) in vec4 aPosition;\n"
        "layout(location = 1) in vec2 aTexCoord;\n"
        "out vec2 vTexCoord;\n"
        "void main()\n"
        "{\n"
        "    gl_Position = aPosition;\n"
        "    vTexCoord = aTexCoord;\n"
        "}\n";
    
    const char *fragmentShaderSource = "#version 320 es\n"
        "precision mediump float;\n"
        "uniform sampler2D sTexture1;\n"
        "uniform sampler2D sTexture2;\n"
        "in vec2 vTexCoord;\n"
        "out vec4 fragColor;\n"
        "void main()\n"
        "{\n"
        "    vec4 color1 = texture(sTexture1, vTexCoord);\n"
        "    vec4 color2 = texture(sTexture2, vTexCoord);\n"
        "    fragColor = mix(color1, color2, color2.a);\n"
        "}\n";
    
    GLuint program;
    GLuint texture1;
    GLuint texture2;
    GLuint vbo;
    GLuint vao;
    
    void loadNV12Texture(const char* filePath, GLuint texture)
    {
        unsigned char* nv12Data = (unsigned char*)malloc(NV12_SIZE);
    
        FILE* fp = fopen(filePath, "rb");
    
        fread(nv12Data, 1, NV12_SIZE, fp);
    
        fclose(fp);
    
        glBindTexture(GL_TEXTURE_2D, texture);
    
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    
        float* rgbaData = (float*)malloc(TEXTURE_WIDTH * TEXTURE_HEIGHT * 4 * sizeof(float));
    
        int y, x, i;
        for (y = 0; y < TEXTURE_HEIGHT; y++)
        {
            for (x = 0; x < TEXTURE_WIDTH; x++)
            {
                i = y * TEXTURE_WIDTH + x;
    
                unsigned char yValue = nv12Data[y * TEXTURE_WIDTH + x];
    
                unsigned char* cbCrData = nv12Data + TEXTURE_WIDTH * TEXTURE_HEIGHT + (y / 2) * TEXTURE_WIDTH + (x / 2) * 2;
                unsigned char cbValue = cbCrData[1];
                unsigned char crValue = cbCrData[0];
    
                float r = yValue + 1.402f * (crValue - 128);
                float g = yValue - 0.34414f * (cbValue - 128) - 0.71414f * (crValue - 128);
                float b = yValue + 1.772f * (cbValue - 128);
    
                rgbaData[i * 4] = r / 255.0f;
                rgbaData[i * 4 + 1] = g / 255.0f;
                rgbaData[i * 4 + 2] = b / 255.0f;
                rgbaData[i * 4 + 3] = 1.0f;
            }
        }
    
        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_RGBA, GL_FLOAT, rgbaData);
    
        free(rgbaData);
        free(nv12Data);
    }
    
    void init(void)
    {
        // 创建program
        program = glCreateProgram();
    
        // 创建vertex shader
        GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    
        glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    
        glCompileShader(vertexShader);
    
        GLint success;
        char infoLog[512];
        glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
            printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
            exit(-1);
        }
    
        glAttachShader(program, vertexShader);
    
        // 创建fragment shader
        GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    
        glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    
        glCompileShader(fragmentShader);
    
        glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
            printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
            exit(-1);
        }
    
        glAttachShader(program, fragmentShader);
    
        // 链接program
        glLinkProgram(program);
    
        glGetProgramiv(program, GL_LINK_STATUS, &success);
        if (!success) 
        {
            glGetProgramInfoLog(program, 512, NULL, infoLog);
            printf("ERROR::SHADER::PROGRAM::LINK_FAILED\n%s\n", infoLog);
            exit(-1);
        }
    
        // 使用program
        glUseProgram(program);
    
        // 创建VBO
        GLfloat vertices[] = {
            // position        // texCoord
            -1.0f, -1.0f, 0.0f, 0.0f,
             1.0f, -1.0f, 1.0f, 0.0f,
            -1.0f,  1.0f, 0.0f, 1.0f,
             1.0f,  1.0f, 1.0f, 1.0f,
    
            -1.0f, -1.0f, 0.0f, 0.0f,
             1.0f, -1.0f, 1.0f, 0.0f,
            -1.0f,  1.0f, 0.0f, 1.0f,
             1.0f,  1.0f, 1.0f, 1.0f,
        };
    
        glGenBuffers(1, &vbo);
        glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    
        // 创建VAO
        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
    
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (void*)0);
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
    
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
    
        // 创建纹理
        glGenTextures(1, &texture1);
        glBindTexture(GL_TEXTURE_2D, texture1);
        loadNV12Texture("texture1.nv12", texture1);
    
        glGenTextures(1, &texture2);
        glBindTexture(GL_TEXTURE_2D, texture2);
        loadNV12Texture("texture2.nv12", texture2);
    
        glUniform1i(glGetUniformLocation(program, "sTexture1"), 0);
        glUniform1i(glGetUniformLocation(program, "sTexture2"), 1);
    }
    
    void render(void)
    {
        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
    
        // 绑定VBO和VAO
        glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glBindVertexArray(vao);
    
        // 开启blending
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
        // 绑定纹理
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture1);
    
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, texture2);
    
        // 绘制
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
        glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
    
        // 关闭blending
        glDisable(GL_BLEND);
    }
    
    int main()
    {
        EGLDisplay egl_display = NULL;
        EGLConfig egl_conf = NULL;
        EGLContext egl_context = NULL;
        EGLSurface egl_surface = NULL;
    
        egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    
        EGLint major, minor;
        eglInitialize(egl_display, &major, &minor);
    
        EGLint num_configs;
        EGLint config_list[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
                                EGL_BLUE_SIZE, 8,
                                EGL_GREEN_SIZE, 8,
                                EGL_RED_SIZE, 8,
                                EGL_DEPTH_SIZE, 8,
                                EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
                                EGL_NONE };
    
        eglChooseConfig(egl_display, config_list, &egl_conf, 1, &num_configs);
    
        EGLint egl_ctx_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE };
    
        egl_context = eglCreateContext(egl_display, egl_conf, EGL_NO_CONTEXT, egl_ctx_attribs );
    
        egl_surface = eglCreateWindowSurface(egl_display, egl_conf, (EGLNativeWindowType)NULL, NULL);
    
        eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
    
        init();
    
        while (1)
        {
            render();
            eglSwapBuffers(egl_display, egl_surface);
        }
    
        eglDestroyContext(egl_display, egl_context);
        eglTeriminate(egl_display);
    
        return 0;
    }
    
  5. User

    texture2D().a

  6. Assistant

    在OpenGL ES和GLSL中的texture2D函数用于从纹理中获取一个颜色值。该函数的参数为纹理采样器和纹理坐标。其中,纹理采样器指的是一个指向纹理的指针,纹理坐标是一个vec2类型的向量,表示纹理中的位置。

    在GLSL中,通过texture2D()函数获取的颜色值是一个vec4类型的向量,其中包含四个分量:R(红色),G(绿色),B(蓝色)和A(透明度)。

    所以,texture2D().a指颜色向量的第四个分量,即透明度。通常情况下,用来进行Alpha Blend混合,将该值作为混合因子以混合两个颜色。

    例如,以下的代码片段将texture1和texture2混合,其中texture2的透明度作为混合因子:

    vec4 color1 = texture2D(texture1, texCoord);
    vec4 color2 = texture2D(texture2, texCoord);
    gl_FragColor = mix(color1, color2, color2.a);
    

    以上代码中,mix()函数用来对两个颜色按照颜色2的透明度进行混合,生成最终的颜色。

  7. User

    texture2D和texture区别

  8. Assistant

    在OpenGL ES中,texture、texture2D函数和textureCube函数用于从纹理中获取一个颜色值。其具体用法如下:

    1. texture
    vec4 texture(sampler2D sampler, vec2 coord)
    vec4 texture(samplerCube sampler, vec3 coord)
    

    texture函数用于从指定的纹理中获取颜色值。它的第一个参数是一个指向纹理的采样器,第二个参数是纹理的坐标。这个函数可以用于2D纹理和立方体纹理。

    1. texture2D
    vec4 texture2D(sampler2D sampler, vec2 coord)
    

    texture2D函数用于从指定的2D纹理中获取颜色值。它的第一个参数是一个指向纹理的采样器,第二个参数是纹理的二维坐标。

    该函数的作用和texture()函数是一样的,只是texture2D()是它的简写版本。在OpenGL ES 3.0之前,只有texture2D()函数是可用的,而在OpenGL ES 3.0之后,可以使用texture()或texture2D()函数进行纹理采样。

    1. textureCube
    vec4 textureCube(samplerCube sampler, vec3 coord)
    

    textureCube函数用于从指定的立方体纹理中获取颜色值。它的第一个参数是一个指向立方体纹理的采样器,第二个参数是纹理的三维坐标。

    因此,可以看到,texture()和texture2D()是等价的,只是在不同的版本中支持不同的函数名称。而textureCube()函数则是用于立方体纹理的。

  9. User

    基于C语言和opengl 的glblendFunc实现将一张图片半透明另一张不透明渲染成1张图片输出

  10. Assistant

    下面是一个简单的C语言和OpenGL的代码示例,实现了将一张图片和一张半透明图片混合渲染成一张图片并输出。具体的实现逻辑如下:

    1. 加载两张图片,并创建两个纹理
    2. 创建一个可渲染的framebuffer
    3. 将第一张图片渲染至framebuffer中
    4. 开启混合模式,将第二张图片以半透明的方式渲染至framebuffer中
    5. 将framebuffer中的内容读取到一个buffer中,输出为一张图片

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    #include <GLES3/gl32.h>
    #include <EGL/egl.h>
    #include <EGL/eglext.h>
    #include <SOIL/SOIL.h>
    
    #define WIN_W 800
    #define WIN_H 600
    
    #define IMG1 "image1.png"  // 不透明图片
    #define IMG2 "image2.png"  // 半透明图片
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.