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

NV12转换成RGB用着色器实现

  1. User

    NV12转换成RGB用着色器实现

  2. Assistant

    NV12是一种YUV格式,其中Y表示亮度分量,U和V表示色度分量。RGB是一种不同的颜色空间,其中红、绿、蓝三种颜色以不同的强度组合成图像。

    要将NV12格式的图像转换为RGB格式的图像,可以使用着色器进行实现。以下是一个基本的着色器代码:

    顶点着色器:

    attribute vec4 position;
    attribute vec2 texCoord;
    varying lowp vec2 v_texCoord;
    
    void main()
    {
        gl_Position = position;
        v_texCoord = texCoord;
    }
    

    片段着色器:

    uniform sampler2D yTexture;
    uniform sampler2D uvTexture;
    varying lowp vec2 v_texCoord;
    
    void main()
    {
        mediump float y = texture2D(yTexture, v_texCoord).r;
        mediump float u = texture2D(uvTexture, v_texCoord).r - 0.5;
        mediump float v = texture2D(uvTexture, v_texCoord).g - 0.5;
    
        mediump float r = y + 1.13983 * v;
        mediump float g = y - 0.39465 * u - 0.58060 * v;
        mediump float b = y + 2.03211 * u;
    
        gl_FragColor = vec4(r, g, b, 1.0);
    }
    

    在这个着色器中,顶点着色器将传入的位置和纹理坐标传递给片段着色器。片段着色器通过两个采样器从纹理中获取Y和UV分量,并将它们转换为RGB分量,然后将结果作为最终的颜色输出。

    要使用这个着色器进行NV12到RGB的转换,需要将Y分量和UV分量分别加载到两个纹理中,并将其作为uniform变量传递给着色器。时钟着色器对应的GLSL代码如下:

    YUVShader::YUVShader() :
        m_program(0), m_yTexture(0), m_uvTexture(0), 
        m_positionLocation(-1), m_texCoordLocation(-1),
        m_yTextureLocation(-1), m_uvTextureLocation(-1)
    {
        const char *vertexShaderSrc =
            "attribute vec4 position;\n"
            "attribute vec2 texCoord;\n"
            "varying lowp vec2 v_texCoord;\n"
            "void main()\n"
            "{\n"
            "    gl_Position = position;\n"
            "    v_texCoord = texCoord;\n"
            "}";
    
        const char *fragmentShaderSrc =
            "uniform sampler2D yTexture;\n"
            "uniform sampler2D uvTexture;\n"
            "varying lowp vec2 v_texCoord;\n"
            "void main()\n"
            "{\n"
            "    mediump float y = texture2D(yTexture, v_texCoord).r;\n"
            "    mediump float u = texture2D(uvTexture, v_texCoord).r - 0.5;\n"
            "    mediump float v = texture2D(uvTexture, v_texCoord).g - 0.5;\n"
            "    mediump float r = y + 1.13983 * v;\n"
            "    mediump float g = y - 0.39465 * u - 0.58060 * v;\n"
            "    mediump float b = y + 2.03211 * u;\n"
            "    gl_FragColor = vec4(r, g, b, 1.0);\n"
            "}";
    
        m_program = createProgram(vertexShaderSrc, fragmentShaderSrc);
        if (m_program == 0)
        {
            ALOGE("Could not create YUV shader program.");
        }
    
        m_positionLocation = glGetAttribLocation(m_program, "position");
        m_texCoordLocation = glGetAttribLocation(m_program, "texCoord");
        m_yTextureLocation = glGetUniformLocation(m_program, "yTexture");
        m_uvTextureLocation = glGetUniformLocation(m_program, "uvTexture");
    }
    
    void YUVShader::initTextures(int width, int height, const uint8_t *yData, const uint8_t *uvData)
    {
        GL_CHECK(glGenTextures(1, &m_yTexture));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_yTexture));
        GL_CHECK(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, yData));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    
        GL_CHECK(glGenTextures(1, &m_uvTexture));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_uvTexture));
        GL_CHECK(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, width / 2, height / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, uvData));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    }
    
    void YUVShader::draw()
    {
        GL_CHECK(glUseProgram(m_program));
        GL_CHECK(glEnableVertexAttribArray(m_positionLocation));
        GL_CHECK(glEnableVertexAttribArray(m_texCoordLocation));
    
        static const GLfloat squareVertices[] = {
            -1.0f, -1.0f,
             1.0f, -1.0f,
            -1.0f,  1.0f,
             1.0f,  1.0f,
        };
    
        GL_CHECK(glVertexAttribPointer(m_positionLocation, 2, GL_FLOAT, GL_FALSE, 0, squareVertices));
    
        static const GLfloat texCoords[] = {
            0.0f,  1.0f,
            1.0f,  1.0f,
            0.0f,  0.0f,
            1.0f,  0.0f,
        };
    
        GL_CHECK(glVertexAttribPointer(m_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, texCoords));
    
        GL_CHECK(glActiveTexture(GL_TEXTURE0));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_yTexture));
        GL_CHECK(glUniform1i(m_yTextureLocation, 0));
    
        GL_CHECK(glActiveTexture(GL_TEXTURE1));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_uvTexture));
        GL_CHECK(glUniform1i(m_uvTextureLocation, 1));
    
        GL_CHECK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
        GL_CHECK(glDisableVertexAttribArray(m_positionLocation));
        GL_CHECK(glDisableVertexAttribArray(m_texCoordLocation));
    }
    

    这里,YUVShader类封装了着色器的信息。initTextures()方法将Y和UV分量加载到两个纹理中。draw()方法将着色器程序、顶点坐标、纹理坐标、纹理对象和纹理单元绑定,并向片段着色器传递uniform变量。

    在使用这个着色器进行NV12到RGB的转换时,可以按照以下步骤进行:

    1. 创建一个YUVShader对象。

    2. 通过initTextures()方法将Y和UV分量加载到两个纹理中。

    3. 在绘制每一帧之前,通过glViewport()函数设置绘制区域。

    4. 在绘制每一帧时,通过draw()方法将图像绘制到屏幕上。

    下面是一个简单的示例代码:

    #include <GLES2/gl2.h>
    #include <GLES2/gl2ext.h>
    #include <EGL/egl.h>
    #include <EGL/eglplatform.h>
    #include <cstdio>
    #include "../common/glhelpers.h"
    #include "../common/AndroidIOSystem.h"
    #include "../common/mesh.h"
    #include "../common/stb_image.h"
    
    class YUVShader
    {
    public:
        YUVShader();
        ~YUVShader();
    
        void initTextures(int width, int height, const uint8_t *yData, const uint8_t *uvData);
        void draw();
    
    private:
        GLuint m_program;
        GLuint m_yTexture;
        GLuint m_uvTexture;
        GLint m_positionLocation;
        GLint m_texCoordLocation;
        GLint m_yTextureLocation;
        GLint m_uvTextureLocation;
    };
    
    YUVShader::YUVShader() :
        m_program(0), m_yTexture(0), m_uvTexture(0), 
        m_positionLocation(-1), m_texCoordLocation(-1),
        m_yTextureLocation(-1), m_uvTextureLocation(-1)
    {
        const char *vertexShaderSrc =
            "attribute vec4 position;\n"
            "attribute vec2 texCoord;\n"
            "varying lowp vec2 v_texCoord;\n"
            "void main()\n"
            "{\n"
            "    gl_Position = position;\n"
            "    v_texCoord = texCoord;\n"
            "}";
    
        const char *fragmentShaderSrc =
            "uniform sampler2D yTexture;\n"
            "uniform sampler2D uvTexture;\n"
            "varying lowp vec2 v_texCoord;\n"
            "void main()\n"
            "{\n"
            "    mediump float y = texture2D(yTexture, v_texCoord).r;\n"
            "    mediump float u = texture2D(uvTexture, v_texCoord).r - 0.5;\n"
            "    mediump float v = texture2D(uvTexture, v_texCoord).g - 0.5;\n"
            "    mediump float r = y + 1.13983 * v;\n"
            "    mediump float g = y - 0.39465 * u - 0.58060 * v;\n"
            "    mediump float b = y + 2.03211 * u;\n"
            "    gl_FragColor = vec4(r, g, b, 1.0);\n"
            "}";
    
        m_program = createProgram(vertexShaderSrc, fragmentShaderSrc);
        if (m_program == 0)
        {
            ALOGE("Could not create YUV shader program.");
        }
    
        m_positionLocation = glGetAttribLocation(m_program, "position");
        m_texCoordLocation = glGetAttribLocation(m_program, "texCoord");
        m_yTextureLocation = glGetUniformLocation(m_program, "yTexture");
        m_uvTextureLocation = glGetUniformLocation(m_program, "uvTexture");
    }
    
    void YUVShader::initTextures(int width, int height, const uint8_t *yData, const uint8_t *uvData)
    {
        GL_CHECK(glGenTextures(1, &m_yTexture));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_yTexture));
        GL_CHECK(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, yData));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    
        GL_CHECK(glGenTextures(1, &m_uvTexture));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_uvTexture));
        GL_CHECK(glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, width / 2, height / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, uvData));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        GL_CHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    }
    
    void YUVShader::draw()
    {
        GL_CHECK(glUseProgram(m_program));
        GL_CHECK(glEnableVertexAttribArray(m_positionLocation));
        GL_CHECK(glEnableVertexAttribArray(m_texCoordLocation));
    
        static const GLfloat squareVertices[] = {
            -1.0f, -1.0f,
             1.0f, -1.0f,
            -1.0f,  1.0f,
             1.0f,  1.0f,
        };
    
        GL_CHECK(glVertexAttribPointer(m_positionLocation, 2, GL_FLOAT, GL_FALSE, 0, squareVertices));
    
        static const GLfloat texCoords[] = {
            0.0f,  1.0f,
            1.0f,  1.0f,
            0.0f,  0.0f,
            1.0f,  0.0f,
        };
    
        GL_CHECK(glVertexAttribPointer(m_texCoordLocation, 2, GL_FLOAT, GL_FALSE, 0, texCoords));
    
        GL_CHECK(glActiveTexture(GL_TEXTURE0));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_yTexture));
        GL_CHECK(glUniform1i(m_yTextureLocation, 0));
    
        GL_CHECK(glActiveTexture(GL_TEXTURE1));
        GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_uvTexture));
        GL_CHECK(glUniform1i(m_uvTextureLocation, 1));
    
        GL_CHECK(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
        GL_CHECK(glDisableVertexAttribArray(m_positionLocation));
        GL_CHECK(glDisableVertexAttribArray(m_texCoordLocation));
    }
    
    void printGLString(const char *name, GLenum s)
    {
        const char *v = (const char *)glGetString(s);
        ALOGI("GL %s = %s\n", name, v);
    }
    
    void checkGlError(const char* op)
    {
        for (GLint error = glGetError(); error; error = glGetError())
        {
            ALOGE("after %s() glError (0x%x)\n", op, error);
        }
    }
    
    Mesh* loadMesh(const char *filename)
    {
        AiScene scene;
        AiImporter importer;
        AndroidIOSystem ioSystem;
        Mesh *mesh = NULL;
    
        if (importer.ReadFile(filename, scene, &ioSystem))
        {
            mesh = new Mesh(scene.mMeshes[0]);
        }
        else
        {
            ALOGE("Error loading mesh %s.", filename);
        }
    
        return mesh;
    }
    
    GLuint createShader(GLenum type, const char* source)
    {
        GLuint shader = glCreateShader(type);
    
        if (shader)
        {
            glShaderSource(shader, 1, &source, NULL);
            glCompileShader(shader);
    
            GLint compiled = 0;
            glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
    
            if (!compiled)
            {
                GLint infoLen = 0;
                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
    
                if (infoLen)
                {
                    char* buf = new char[infoLen];
                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
                    ALOGE("Could not compile shader %d:\n%s\n", (int)type, buf);
                    delete[] buf;
                }
    
                glDeleteShader(shader);
                shader = 0;
            }
        }
    
        return shader;
    }
    
    GLuint createProgram(const char* vertexSource, const char* fragmentSource)
    {
        GLuint vertexShader = createShader(GL_VERTEX_SHADER, vertexSource);
        if (!vertexShader)
        {
            return 0;
        }
    
        GLuint fragmentShader = createShader(GL_FRAGMENT_SHADER, fragmentSource);
        if (!fragmentShader)
        {
            return 0;
        }
    
        GLuint program = glCreateProgram();
    
        if (program)
        {
            glAttachShader(program, vertexShader);
            checkGlError("glAttachShader");
            glAttachShader(program, fragmentShader);
            checkGlError("glAttachShader");
            glLinkProgram(program);
            GLint linkStatus = GL_FALSE;
            glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
    
            if (linkStatus != GL_TRUE)
            {
                GLint bufLength = 0;
                glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
    
                if (bufLength)
                {
                    char* buf = new char[bufLength];
                    glGetProgramInfoLog(program, bufLength, NULL, buf);
                    ALOGE("Could not link program:\n%s\n", buf);
                    delete[] buf;
                }
    
                glDeleteProgram(program);
                program = 0;
            }
        }
    
        return program;
    }
    
    int main(int argc, char **argv)
    {
        EGLDisplay display;
        EGLConfig config;
        EGLContext context;
        EGLSurface surface;
    
        static const EGLint configAttribs[] =
        {
            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
            EGL_BLUE_SIZE, 8,
            EGL_GREEN_SIZE, 8,
            EGL_RED_SIZE, 8,
            EGL_DEPTH_SIZE, 0,
            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL_NONE
        };
    
        static const EGLint contextAttribs[] =
        {
            EGL_CONTEXT_CLIENT_VERSION, 2,
            EGL_NONE
        };
    
        static const EGLint surfaceAttribs[] =
        {
            EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
            EGL_NONE
        };
    
        EGLint numConfigs;
    
        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    
        if (display == EGL_NO_DISPLAY)
        {
            ALOGE("eglGetDisplay() failed: %x\n", eglGetError());
            return -1;
        }
    
        EGLBoolean ret = eglInitialize(display, NULL, NULL);
    
        if (ret == EGL_FALSE)
        {
            ALOGE("eglInitialize() failed: %x\n", eglGetError());
            return -1;
        }
    
        ret = eglChooseConfig(display, config
    

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