OpenGL渲染(YUV数据格式)

最新推荐文章于 2025-03-29 14:10:54 发布
原创 最新推荐文章于 2025-03-29 14:10:54 发布 · 4.9k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个使用OpenGL ES进行YUV数据渲染的类GLRender的实现细节。该类能够处理YUV数据，并通过顶点和片段着色器将YUV数据转换为RGB颜色进行显示。文中还详细介绍了如何配置OpenGL上下文、创建纹理、设置顶点属性等关键步骤。 

//GLRender.h
#ifndef __GLRENDER_H_
#define __GLRENDER_H_

#include "YUVData.h"
#include "SNMutex.h"

#import <QuartzCore/QuartzCore.h>
#import <OpenGLES/EAGL.h>
#import <OpenGLES/ES2/gl.h>
#import <OpenGLES/ES2/glext.h>
#import <QuartzCore/CAMediaTiming.h>
#import <QuartzCore/CATransform3D.h>
#import <Foundation/NSObject.h>

typedef  GLint EGLint;

class GLRender
{
    typedef enum 
    {
        VERTICAL = 0,
        HORIZONTAL
    }ORIENT_T;

public:
	GLRender();
	~GLRender();

public:
	int nativeGLRender(PYUVData &yuvdata);
	void nativeGLRender(char *pFrame);
	int digitalRegionZoom(int bootom_x , int bootom_y, int top_x, int top_y);
	int close();
	bool setGLSurface(const int p_nWidth, const int p_nHeight, CAEAGLLayer *layer);

private:
	void render(const void *data);
	void render(PYUVData &yuvdata);
	void configGL();
	GLuint loadShader(GLenum shaderType, const char* pSource); 
	GLuint createProgram(const char* pVertexSource, const char* pFragmentSource);
	bool setupGraphics(EGLint w, EGLint h) ;
	void setTexture(GLuint texture);
    
    void setupBuffers();
    void createBuffers();
    void releaseBuffers();

private:
	SNMutex  m_SNMutex;
	int mWidth, mGLSurfaceWidth;
	int mHeight, mGLSurfaceHeight;
	bool surface_ok;
	ORIENT_T mOrient;
	GLfloat *mSquareVertices;
    
private:
	EAGLContext *mContext;
	GLuint  mViewRenderbuffer;
	GLuint  mViewFramebuffer;
	CAEAGLLayer  *mSurface;
	GLuint  mGlProgram; 

	GLuint m_texturePlanarY;
	GLuint m_texturePlanarU;
	GLuint m_texturePlanarV;

	GLint  mPositionLoc;
	GLint  mTexCoordLoc;

	GLint  mSamplerY;
	GLint  mSamplerU;
	GLint  mSamplerV;
    
    int mCurrentLayerWidth;
    int mCurrentLayerHeight;
};

#endif



//GLRender.cpp
#include "GLRender.h"

#define   LOGI  printf("GLRender: "); printf
#define   LOGE  printf("GLRender: "); printf
#define   eglGetError glGetError

#import "ScreenParam.h"
#import <OpenGLES/EAGLDrawable.h>
#import <QuartzCore/QuartzCore.h>

typedef   GLint  EGLint;
#define   EGL_SUCCESS GL_NO_ERROR

const int VERTEX_STRIDE = 6 * sizeof(GLfloat);

const GLfloat squareVertices[] = {
    1.0f, -1.0f, 0.0f, 1.0f,    // Position 0
    1.0f, 1.0f,                 // TexCoord 0
    1.0f, 1.f, 0.0f, 1.0f,      // Position 1
    1.0f,  0.0f,                // TexCoord 1
    -1.0f, -1.0f, 0.0f, 1.0f,   // Position 2
    0.0f,  1.0f,                // TexCoord 2
    -1.0f,  1.f, 0.0f, 1.0f,    // Position 3
    0.0f,  0.0f,                // TexCoord 3
};

//Vertext shader language
static const char gVertexShader[] =
"attribute vec4 a_Position;\n"
"attribute vec2 a_texCoord;\n"
"varying vec2 v_texCoord;\n"
"void main() {\n"
"  gl_Position = a_Position;\n"
"  v_texCoord = a_texCoord;\n"
"}\n";

//Fragment shader language
static const char gFragmentShader[] =
"varying lowp vec2 v_texCoord;\n"     
"uniform sampler2D SamplerY;\n"  
"uniform sampler2D SamplerU;\n"  
"uniform sampler2D SamplerV;\n"  
"void main(void)\n"  
"{\n"  
"mediump vec3 yuv;\n"  
"lowp vec3 rgb;\n"  
"yuv.x = texture2D(SamplerY, v_texCoord).r;\n"  
"yuv.y = texture2D(SamplerU, v_texCoord).r - 0.5;\n"  
"yuv.z = texture2D(SamplerV, v_texCoord).r - 0.5;\n"  
"rgb = mat3( 1,   1,   1,\n"  
"0,       -0.39465,  2.03211,\n"  
"1.13983,   -0.58060,  0) * yuv;\n"  
"gl_FragColor = vec4(rgb, 1);\n"  
"}\n";  

GLRender::GLRender()
:surface_ok(false)
,mContext(NULL)
,mOrient(VERTICAL)
,mViewRenderbuffer(NULL)
,mViewFramebuffer(NULL)
{
    mSquareVertices = (GLfloat *)malloc(sizeof(squareVertices));
    memcpy(mSquareVertices,squareVertices,sizeof(squareVertices));
}

GLRender::~GLRender()
{
    this->releaseBuffers();
    free(mSquareVertices);
}

int GLRender::close()
{
    LOCK_SNMUTEX(m_SNMutex);
    if (surface_ok)
    {
        if (mContext)
        {
            glClearColor(0, 0, 0, 0);
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
            [mContext  presentRenderbuffer:GL_RENDERBUFFER];
            
            [EAGLContext setCurrentContext:mContext];
            this->releaseBuffers();
            [EAGLContext setCurrentContext:nil];

            if (mContext){
                mContext = nil;
            }
        }
        mSurface = NULL;
        surface_ok = false ;
    }
    return 0;
}

GLuint GLRender::loadShader(GLenum shaderType, const char* pSource) {
    GLuint shader = glCreateShader(shaderType);
    if (shader) {
        glShaderSource(shader, 1, &pSource, 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 = (char*) malloc(infoLen);
                if (buf != NULL) {
                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
                    LOGE("Could not compile shader %d:\n%s\n", shaderType, buf);
                    free(buf);
                }   
                glDeleteShader(shader);
                shader = 0;
            }   
        }   

    }   
    return shader;
}


GLuint GLRender::createProgram(const char* pVertexSource, const char* pFragmentSource)
{
    GLuint program = glCreateProgram();
    if (program) {
        GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
        if (!vertexShader) {
            return 0;
        }else{
            glAttachShader(program, vertexShader);
        }
        
        GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
        if (!pixelShader) {
            return 0;
        }else{
            glAttachShader(program, pixelShader);
        }
        
        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 = (char*) malloc(bufLength);
                if (buf) {
                    glGetProgramInfoLog(program, bufLength, NULL, buf);
                    LOGE("Could not link program:\n%s\n", buf);
                    free(buf);
                }   
            }   
            glDeleteProgram(program);
            program = 0;
        }   
    }   
    return program;
}

void GLRender::setupBuffers()
{
    glDisable(GL_DEPTH_TEST);
    
    mPositionLoc = glGetAttribLocation(mGlProgram, "a_Position");
    glEnableVertexAttribArray(mPositionLoc);
    glVertexAttribPointer(mPositionLoc, 4, GL_FLOAT,GL_FALSE, VERTEX_STRIDE, mSquareVertices);
    
    mTexCoordLoc = glGetAttribLocation(mGlProgram, "a_texCoord");
    glEnableVertexAttribArray(mTexCoordLoc);
    glVertexAttribPointer(mTexCoordLoc, 2, GL_FLOAT, GL_FALSE, VERTEX_STRIDE, &mSquareVertices[4]);
    
    this->createBuffers();
}

void GLRender::createBuffers()
{
    [EAGLContext setCurrentContext:mContext];
    
    //Create render buffer
    glGenRenderbuffers(1, &mViewRenderbuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, mViewRenderbuffer);
    
    //Create frame buffer
    glGenFramebuffers(1, &mViewFramebuffer);
    glBindFramebuffer(GL_FRAMEBUFFER, mViewFramebuffer);
    
    //Create viewport
    [mContext renderbufferStorage:GL_RENDERBUFFER fromDrawable:mSurface];
    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &mGLSurfaceWidth);
    glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &mGLSurfaceHeight);
    glViewport(0.0, 0.0, mGLSurfaceWidth, mGLSurfaceHeight);
    glClearColor(0.0, 0.0, 0.0, 1.0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mViewRenderbuffer);
    if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE){
        NSLog(@"Failure with framebuffer generation");
    }
}

void GLRender::releaseBuffers()
{
    if (mViewFramebuffer){
        glDeleteFramebuffers(1, &mViewFramebuffer);
        mViewFramebuffer = 0;
    }
    
    if (mViewFramebuffer){
        glDeleteRenderbuffers(1, &mViewRenderbuffer);
        mViewRenderbuffer = 0;
    }
}

bool GLRender::setupGraphics(EGLint w, EGLint h)
{
    mGlProgram = createProgram(gVertexShader, gFragmentShader);
    if (!mGlProgram) {
        LOGE("Could not create program.");
        return false;
    }

    // Get sampler location
    mSamplerY = glGetUniformLocation(mGlProgram, "SamplerY");
    mSamplerU = glGetUniformLocation(mGlProgram, "SamplerU");
    mSamplerV = glGetUniformLocation(mGlProgram, "SamplerV");

    glUseProgram(mGlProgram);  
    glGenTextures(1, &m_texturePlanarY);
    glGenTextures(1, &m_texturePlanarU);
    glGenTextures(1, &m_texturePlanarV);

    glActiveTexture(GL_TEXTURE0);
    setTexture(m_texturePlanarY);
    glUniform1i(mSamplerY, 0);

    glActiveTexture(GL_TEXTURE1);
    setTexture(m_texturePlanarU);
    glUniform1i(mSamplerU, 1);

    glActiveTexture(GL_TEXTURE2);
    setTexture(m_texturePlanarV);
    glUniform1i(mSamplerV, 2);

    surface_ok = true;
    return true;
}

void GLRender::nativeGLRender(char *pFrame)
{
    LOCK_SNMUTEX(m_SNMutex);
    this->configGL();
    
    if (surface_ok)
    {
        glViewport(0, 0, mGLSurfaceWidth, mGLSurfaceHeight);

        mPositionLoc  = glGetAttribLocation(mGlProgram, "a_Position");
        mTexCoordLoc     = glGetAttribLocation(mGlProgram, "a_texCoord");

        glEnableVertexAttribArray(mPositionLoc);
        glVertexAttribPointer(mPositionLoc, 4, GL_FLOAT,GL_FALSE, VERTEX_STRIDE, mSquareVertices);
            
        // Load the texture coordinate
        glEnableVertexAttribArray(mTexCoordLoc);
        glVertexAttribPointer(mTexCoordLoc, 2, GL_FLOAT, GL_FALSE, VERTEX_STRIDE, &mSquareVertices[4]);

        glDisable(GL_BLEND);
        glActiveTexture(GL_TEXTURE0);
        setTexture(m_texturePlanarY);
        glUniform1i(mSamplerY, 0);
        
        glActiveTexture(GL_TEXTURE1);
        setTexture(m_texturePlanarU);
        glUniform1i(mSamplerU, 1);
        
        glActiveTexture(GL_TEXTURE2);
        setTexture(m_texturePlanarV);
        glUniform1i(mSamplerV, 2);
        
        render(pFrame);
    }
}
int GLRender::nativeGLRender(PYUVData &yuvdata)
{
    LOCK_SNMUTEX(m_SNMutex);
    if(mCurrentLayerHeight != mSurface.bounds.size.height && mCurrentLayerWidth != mSurface.bounds.size.width){
        mCurrentLayerWidth = mSurface.bounds.size.width;
        mCurrentLayerHeight = mSurface.bounds.size.height;

        if((mCurrentLayerWidth > [ScreenParam screenWidth] - 5 && mCurrentLayerWidth < [ScreenParam screenWidth] + 5)){
               surface_ok = false ;
        }
    }
    this->configGL();

    if (surface_ok){
        
        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &mGLSurfaceWidth);
        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &mGLSurfaceHeight);
        glBindRenderbuffer(GL_RENDERBUFFER, mViewRenderbuffer);
        
        mPositionLoc = glGetAttribLocation(mGlProgram, "a_Position");
        mTexCoordLoc = glGetAttribLocation(mGlProgram, "a_texCoord");
        
        glVertexAttribPointer(mPositionLoc, 4, GL_FLOAT,GL_FALSE, VERTEX_STRIDE, mSquareVertices);
        glEnableVertexAttribArray(mPositionLoc);
        
        glVertexAttribPointer(mTexCoordLoc, 2, GL_FLOAT, GL_FALSE, VERTEX_STRIDE, &mSquareVertices[4]);
        glEnableVertexAttribArray(mTexCoordLoc);
        
        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &mGLSurfaceWidth);
        glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &mGLSurfaceHeight);
        
        glViewport(0, 0, mGLSurfaceWidth, mGLSurfaceHeight);
        render(yuvdata);
    }else{
        LOGE("NativeGLRender error.");
        return -1;
    }
    
    return 0;
}

void GLRender::setTexture(GLuint texture)
{
    glBindTexture ( GL_TEXTURE_2D, texture);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
}  

void GLRender::render(PYUVData &yuvdata)
{
    const uint8_t *src_y = (uint8_t *)yuvdata->data[0];
    const uint8_t *src_u = (uint8_t *)yuvdata->data[1];
    const uint8_t *src_v = (uint8_t *)yuvdata->data[2];

    glBindRenderbuffer(GL_RENDERBUFFER, mViewRenderbuffer);
    [mContext  presentRenderbuffer:GL_RENDERBUFFER];
    
    glBindTexture ( GL_TEXTURE_2D, m_texturePlanarY);
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, mWidth,   mHeight,   0, GL_LUMINANCE, GL_UNSIGNED_BYTE, src_y);
    
    glBindTexture( GL_TEXTURE_2D, m_texturePlanarU );
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, mWidth/2, mHeight/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, src_u);
    
    glBindTexture ( GL_TEXTURE_2D,m_texturePlanarV );
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, mWidth/2, mHeight/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, src_v);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

void GLRender::render( const void *data)
{
    const uint8_t *src_y = (const uint8_t *)data;
    const uint8_t *src_u = (const uint8_t *)data + mWidth * mHeight;
    const uint8_t *src_v = src_u + (mWidth / 2 * mHeight / 2);

    glBindTexture ( GL_TEXTURE_2D, m_texturePlanarY);
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, mWidth,   mHeight,   0, GL_LUMINANCE, GL_UNSIGNED_BYTE, src_y);
    
    glBindTexture( GL_TEXTURE_2D, m_texturePlanarU );
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, mWidth/2, mHeight/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, src_u);
    
    glBindTexture ( GL_TEXTURE_2D,m_texturePlanarV );
    glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, mWidth/2, mHeight/2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, src_v);
} 

void GLRender::configGL()
{
    if ((mSurface != NULL) && (!surface_ok)){
        if (mContext){
            mContext = nil;
        }
        
        memcpy(mSquareVertices,squareVertices,sizeof(squareVertices));
        if(!mContext){
            mContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
            
            if (!mContext || ![EAGLContext setCurrentContext:mContext]) {
                return;
            }
        }
        
        this->releaseBuffers();
        this->setupBuffers();
        setupGraphics(mGLSurfaceWidth,mGLSurfaceHeight);
    }
}

int GLRender::digitalRegionZoom(int bootom_x , int bootom_y,  int top_x,  int top_y)
{
    #define GET_SCALE(x)	(x/100.00)
    #define CHECK_VALID(x)  (x<0||x>100)
   
    int stride = 6;
    if (CHECK_VALID(bootom_x) || CHECK_VALID(bootom_y) || CHECK_VALID(top_x) || CHECK_VALID(top_y)){
        return -1;
    }

    GLfloat zoom_textures[4][2]={
        static_cast<GLfloat>GET_SCALE(bootom_x),static_cast<GLfloat>(GET_SCALE(bootom_y)),
        static_cast<GLfloat>GET_SCALE( top_x  ),static_cast<GLfloat>GET_SCALE(bootom_y),
        static_cast<GLfloat>GET_SCALE( bootom_x  ), static_cast<GLfloat>GET_SCALE(top_y),
        static_cast<GLfloat>GET_SCALE(top_x), static_cast<GLfloat>GET_SCALE(top_y)
    };

    LOCK_SNMUTEX(m_SNMutex);
    for(int i = 0; i < 4; i++){
    	mSquareVertices[i*stride+4]=  zoom_textures[i][0];
    	mSquareVertices[i*stride+4+1] = zoom_textures[i][1];
    }
    return 0;
}

bool GLRender::setGLSurface(const int p_nWidth, const int p_nHeight, CAEAGLLayer  *layer)
{
    mWidth = p_nWidth;
    mHeight = p_nHeight;
    mSurface = layer;
    
    mCurrentLayerWidth = layer.bounds.size.width;
    mCurrentLayerHeight = layer.bounds.size.height;
    return true;
}


OpenGL/OpenGL ES入门：渲染YUV数据实践
qq_34754747的博客
08-07 5248
1.yuv的字节数 现有宽为w高为h的一个视频，现在定义了一个data[] bytes变量并存储了这个视频的一帧数据。 bytes数组中，先连续存储每个像素的灰度信息，y通道占w*h个字节； 然后顺序存储颜色数据，u和v分别占一个字节，每个颜色数据共占2个字节，所以uv通道占(w/2)(h/2)2=w*h/2个字。 2.纹理 2.1 纹理的组成 y通道的数据生成一个opengl纹理； uv通道的数据生成一个opengl纹理； 两个纹理作为渲染时的输入，在渲染过程中由GPU组装还原出来视频画面。
OpenGL 渲染 YUYV(YUV422)
PX1525813502的博客
05-28 5982
OpenGL渲染YUYV(YUV422)
Android opengl渲染yuv420例子
06-25
Android下使用OpenGL渲染yuv420p图像并显示。例子中提供了两种类型，一种使用GLSurfaceView在onDrawframe中调用native方法绘制，另外一种使用EGL，直接在native层完成渲染和显示功能。
android 采用opengl显示yuv数据
09-23
Android 平台上采用纯JAVA 在opengl上显示YUV数据；bin目录下包含了编译好的APK;工程可以导入Eclipse直接编译调试；包含测试用的的yuv图片，在raw文件中；代码完整，无缺失；感谢代码的原始提供者，本人使用前人的代码调试完成该测试APP。 (使用shader转换YUV数据，GPU完成计算)
Android OpenGL ES 学习(十一) –渲染YUV视频以及视频抖音特效
夏至的稻穗的博客
12-26 5470
通过简单的配置，实现抖音特效
Opengl ES之YUV数据渲染
u012944685的专栏
11-23 4151
YUV的格式比较多，我们今天就以YUV420SP为例，而YUV420SP又分为`NV12`和`NV21`两种，因此今天我们的主题就是如何使用Opengl ES对`NV12`和`NV21`数据进行渲染显示。
精选资源
SampleYUVRenderer：通过QtOpenGL渲染YUV帧的非常基本的草图
02-04
《使用QtOpenGL渲染YUV帧：SampleYUVRenderer解析》 在计算机图形学领域，OpenGL是一种广泛使用的跨语言、跨平台的编程接口，用于渲染2D、3D矢量图形。在现代视频处理中，YUV色彩空间是常见的图像编码方式，尤其是...
Android opengl yuv 渲染代码
11-25
支持YUV 的I420/NV21/NV12的数据渲染，关键字：opengl es 、surfaceview、android、camera
Android OpenGL处理YUV数据（I420、NV12、NV21）
03-27
处理YUV数据时，首要步骤是将YUV数据转换为OpenGL可直接渲染的RGB格式。这可以通过创建一个顶点着色器和片段着色器来实现。顶点着色器处理几何形状，而片段着色器负责将每个像素的YUV值转换为RGB。 对于I420，由于U...
OpenGL渲染YUV实战：GPU加速转换与MipMap模糊效果实现
最新发布
qq_44723937的博客
03-29 1044
本文介绍了使用Qt和OpenGL渲染YUV420P数据的方法，包括YUV到RGB的转换以及通过OpenGL实现画质模糊的技术。文章详细讲解了YUV420P的结构、OpenGL纹理处理、MipMap技术及其在模糊效果中的应用，并探讨了在OpenGL ES 2.0环境下的兼容性问题及解决方案。最后，提出了进一步优化性能的方向，如FFmpeg硬解码和零拷贝渲染技术。
QT使用OpenGL显示YUV420和YUV444数据实例，内附用例，可直接运行
12-13
使用QT中的OpenGL播放YUV420和YUV444数据，包内自带测试用例和YUV测试数据，可以直接运行。
openGL显示yuv代码
02-12
把之前项目里的一些代码扒出来，可以让手机直接显示前置摄像头yuv数据，已经清理的很干净了，moto XS亲测好用~
使用OpenGL ES对YUV图片进行显示
06-13
使用OpenGL ES对YUV图片进行显示，流程为先提取YUV数据中的Y,U,V分量，在通过纹理贴图的方式，这样就可以达到显示图片的效果
QML+opengl显示yuv420
11-12
QML+opengl显示yuv420,借鉴的一个大牛的，基本没有改 QML+opengl显示yuv420,借鉴的一个大牛的，基本没有改 QML+opengl显示yuv420,借鉴的一个大牛的，基本没有改
iOS OpenGL渲染YUV数据
jeffasd的专栏
09-15 5977
链接：http://www.jianshu.com/p/39cde80d60e2 本文主要介绍使用OpenGL ES来渲染I420(YUV420P) , NV12(YUV420SP)的方法，关于YUV的知识，可以看这里《YUV颜色编码解析》，同样会用到一些简单的OpenGL shader知识，可以看看OpenGL的着色器语言。为了书写方便，以下所谈的OpenGL特指OpenGL
OpenGL学习笔记--渲染yuv纹理
HW的博客
07-05 9070
一般ffmpeg解码后的数据类型都是I420，即YUV420P，OpenGL没有提供直接渲染yuv的接口，我们可以通过可编程渲染管线，利用多重纹理将Y、U、V纹理分别传入，在片元着色器GL_FRAGMENT_SHADER中将yuv进行矩阵转化成RGB，然后进行渲染。GLSL简单介绍OpenGL渲染管线的知识可以参考博客http://www.cnblogs.com/yyxt/p/4056417.htm
使用opengl 播放yuv 数据
tuan8888888的博客
08-22 2499
背景 在很多的场景中，解码出来的数据yuv ,而渲染需要的数据rgb数据，所以需要完成yuv 转rgb的转换，会使用cpu转换，导致cpu的使用率升高。今天尝试使用opengl的方式将yuv 转换过程在gpu中处理，减少cpu的使用率。 opengl 的概念介绍 opengl2.0 后支持了 shader ，转换过程我们就可以利用shader 进行转换。 什么是Shader 着色器（Shader）是用来实现图像渲染的，用来替代固定渲染管线的可编辑程序。Shader其实就是一段执行在GPU上的程序，此程序使用
HarmonyOS通过OpenGL渲染显示yuv数据
Ada的专栏
12-01 1898
HarmonyOS通过UI层设置XComponent绑定NAPI实现openGL渲染，通过纹理渲染y,u,v数据，实现GPU渲染 三、OpenGL渲染模块 1、定义Shader 2、初始化EglContextInit 3、渲染实现 4、测试代码实现
OpenGL基础图形编程 - OpenGL数据类型和函数名
popkiler的专栏
08-22 965
OpenGL的数据类型定义可以与其它语言一致，但建议在ANSI C下最好使用以下定义的数据类型，例如GLint、GLfloat等。具体类型见表5-1。前缀    数据类型                       相应C语言类型               OpenGL类型 =============================================================
qt opengl渲染yuv
02-13
为了实现在Qt应用程序中使用OpenGL渲染YUV图像的功能，可以利用专门为此目的设计的代码库。此代码库不仅简化了开发过程，还提高了效率[^1]。 #### 准备工作环境 确保安装有支持OpenGL的Qt版本以及必要的编译工具链...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值