opengles2.0 显示yuv数据

最新推荐文章于 2023-06-06 19:15:37 发布
最新推荐文章于 2023-06-06 19:15:37 发布
阅读量991 收藏
点赞数
分类专栏： 学习 OPENGL ES2.0
本文介绍了一个使用OpenGL ES 2.0进行YUV纹理渲染的例子，包括了如何加载YUV数据到纹理、创建并使用着色器程序、设置顶点和纹理坐标等关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转自：http://blog.youkuaiyun.com/zsc09_leaf/article/details/16884435


cpp]   view plain copy
  1. // OpenGL ES 2.0 code  
[cpp]  view plain copy
  1. #include "Shader.vert"  
  2. #include "Shader.frag"  
  3.   
  4. #include <jni.h>  
  5. #include <android/log.h>  
  6.   
  7. #include <GLES2/gl2.h>  
  8. #include <GLES2/gl2ext.h>  
  9.   
  10. #include <stdio.h>  
  11. #include <stdlib.h>  
  12. #include <math.h>  
  13.   
  14. enum {  
  15.     ATTRIB_VERTEX,  
  16.     ATTRIB_TEXTURE,  
  17. };  
  18.   
  19. static GLuint g_texYId;  
  20. static GLuint g_texUId;  
  21. static GLuint g_texVId;  
  22. static GLuint simpleProgram;  
  23.   
  24. static char *              g_buffer = NULL;  
  25. static int                 g_width = 0;  
  26. static int                 g_height = 0;  
  27.   
  28.   
  29. static void checkGlError(const char* op)   
  30. {  
  31.     GLint error;  
  32.     for (error = glGetError(); error; error = glGetError())   
  33.     {  
  34.         log("error::after %s() glError (0x%x)\n", op, error);  
  35.     }  
  36. }  
  37.   
  38. static GLuint bindTexture(GLuint texture, const char *buffer, GLuint w , GLuint h)  
  39. {  
  40. //  GLuint texture;  
  41. //  glGenTextures ( 1, &texture );  
  42.     checkGlError("glGenTextures");  
  43.     glBindTexture ( GL_TEXTURE_2D, texture );  
  44.     checkGlError("glBindTexture");  
  45.     glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, buffer);  
  46.     checkGlError("glTexImage2D");  
  47.     glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );  
  48.     checkGlError("glTexParameteri");  
  49.     glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );  
  50.     checkGlError("glTexParameteri");  
  51.     glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );  
  52.     checkGlError("glTexParameteri");  
  53.     glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );  
  54.     checkGlError("glTexParameteri");  
  55.     //glBindTexture(GL_TEXTURE_2D, 0);  
  56.   
  57.     return texture;  
  58. }  
  59.   
  60. static void renderFrame()  
  61. {  
  62. #if 0  
  63.     // Galaxy Nexus 4.2.2  
  64.     static GLfloat squareVertices[] = {  
  65.         -1.0f, -1.0f,  
  66.         1.0f, -1.0f,  
  67.         -1.0f,  1.0f,  
  68.         1.0f,  1.0f,  
  69.     };  
  70.   
  71.     static GLfloat coordVertices[] = {  
  72.         0.0f, 1.0f,  
  73.         1.0f, 1.0f,  
  74.         0.0f,  0.0f,  
  75.         1.0f,  0.0f,  
  76.     };  
  77. #else  
  78.  // HUAWEIG510-0010 4.1.1  
  79.     static GLfloat squareVertices[] = {  
  80.         0.0f, 0.0f,  
  81.         1.0f, 0.0f,  
  82.         0.0f,  1.0f,  
  83.         1.0f,  1.0f,  
  84.     };  
  85.   
  86.     static GLfloat coordVertices[] = {  
  87.             -1.0f, 1.0f,  
  88.             1.0f, 1.0f,  
  89.             -1.0f,  -1.0f,  
  90.             1.0f,  -1.0f,  
  91.     };  
  92. #endif  
  93.   
  94.     glClearColor(0.5f, 0.5f, 0.5f, 1);  
  95.     checkGlError("glClearColor");  
  96.     glClear(GL_COLOR_BUFFER_BIT);  
  97.     checkGlError("glClear");  
  98.     //PRINTF("setsampler %d %d %d", g_texYId, g_texUId, g_texVId);  
  99.     GLint tex_y = glGetUniformLocation(simpleProgram, "SamplerY");  
  100.     checkGlError("glGetUniformLocation");  
  101.     GLint tex_u = glGetUniformLocation(simpleProgram, "SamplerU");  
  102.     checkGlError("glGetUniformLocation");  
  103.     GLint tex_v = glGetUniformLocation(simpleProgram, "SamplerV");  
  104.     checkGlError("glGetUniformLocation");  
  105.   
  106.   
  107.     glBindAttribLocation(simpleProgram, ATTRIB_VERTEX, "vPosition");  
  108.     checkGlError("glBindAttribLocation");  
  109.     glBindAttribLocation(simpleProgram, ATTRIB_TEXTURE, "a_texCoord");  
  110.     checkGlError("glBindAttribLocation");  
  111.   
  112.     glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, squareVertices);  
  113.     checkGlError("glVertexAttribPointer");  
  114.     glEnableVertexAttribArray(ATTRIB_VERTEX);  
  115.     checkGlError("glEnableVertexAttribArray");  
  116.   
  117.     glVertexAttribPointer(ATTRIB_TEXTURE, 2, GL_FLOAT, 0, 0, coordVertices);  
  118.     checkGlError("glVertexAttribPointer");  
  119.     glEnableVertexAttribArray(ATTRIB_TEXTURE);  
  120.     checkGlError("glEnableVertexAttribArray");  
  121.   
  122.     glActiveTexture(GL_TEXTURE0);  
  123.     checkGlError("glActiveTexture");  
  124.     glBindTexture(GL_TEXTURE_2D, g_texYId);  
  125.     checkGlError("glBindTexture");  
  126.     glUniform1i(tex_y, 0);  
  127.     checkGlError("glUniform1i");  
  128.   
  129.     glActiveTexture(GL_TEXTURE1);  
  130.     checkGlError("glActiveTexture");  
  131.     glBindTexture(GL_TEXTURE_2D, g_texUId);  
  132.     checkGlError("glBindTexture");  
  133.     glUniform1i(tex_u, 1);  
  134.     checkGlError("glUniform1i");  
  135.   
  136.     glActiveTexture(GL_TEXTURE2);  
  137.     checkGlError("glActiveTexture");  
  138.     glBindTexture(GL_TEXTURE_2D, g_texVId);  
  139.     checkGlError("glBindTexture");  
  140.     glUniform1i(tex_v, 2);  
  141.     checkGlError("glUniform1i");  
  142.   
  143.     //glEnable(GL_TEXTURE_2D);  
  144.     //checkGlError("glEnable");  
  145.     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);  
  146.     checkGlError("glDrawArrays");  
  147. }  
  148.   
  149. static GLuint buildShader(const char* source, GLenum shaderType)   
  150. {  
  151.     GLuint shaderHandle = glCreateShader(shaderType);  
  152.   
  153.     if (shaderHandle)  
  154.     {  
  155.         glShaderSource(shaderHandle, 1, &source, 0);  
  156.         glCompileShader(shaderHandle);  
  157.   
  158.         GLint compiled = 0;  
  159.         glGetShaderiv(shaderHandle, GL_COMPILE_STATUS, &compiled);  
  160.         if (!compiled)  
  161.         {  
  162.             GLint infoLen = 0;  
  163.             glGetShaderiv(shaderHandle, GL_INFO_LOG_LENGTH, &infoLen);  
  164.             if (infoLen)  
  165.             {  
  166.                 char* buf = (char*) malloc(infoLen);  
  167.                 if (buf)  
  168.                 {  
  169.                     glGetShaderInfoLog(shaderHandle, infoLen, NULL, buf);  
  170.                     log_easy("error::Could not compile shader %d:\n%s\n", shaderType, buf);  
  171.                     free(buf);  
  172.                 }  
  173.                 glDeleteShader(shaderHandle);  
  174.                 shaderHandle = 0;  
  175.             }  
  176.         }  
  177.   
  178.     }  
  179.       
  180.     return shaderHandle;  
  181. }  
  182.   
  183. static GLuint buildProgram(const char* vertexShaderSource,  
  184.         const char* fragmentShaderSource)   
  185. {  
  186.     GLuint vertexShader = buildShader(vertexShaderSource, GL_VERTEX_SHADER);  
  187.     GLuint fragmentShader = buildShader(fragmentShaderSource, GL_FRAGMENT_SHADER);  
  188.     GLuint programHandle = glCreateProgram();  
  189.   
  190.     if (programHandle)  
  191.     {  
  192.         glAttachShader(programHandle, vertexShader);  
  193.         checkGlError("glAttachShader");  
  194.         glAttachShader(programHandle, fragmentShader);  
  195.         checkGlError("glAttachShader");  
  196.         glLinkProgram(programHandle);  
  197.   
  198.         GLint linkStatus = GL_FALSE;  
  199.         glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus);  
  200.         if (linkStatus != GL_TRUE) {  
  201.             GLint bufLength = 0;  
  202.             glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &bufLength);  
  203.             if (bufLength) {  
  204.                 char* buf = (char*) malloc(bufLength);  
  205.                 if (buf) {  
  206.                     glGetProgramInfoLog(programHandle, bufLength, NULL, buf);  
  207.                     log_easy("error::Could not link program:\n%s\n", buf);  
  208.                     free(buf);  
  209.                 }  
  210.             }  
  211.             glDeleteProgram(programHandle);  
  212.             programHandle = 0;  
  213.         }  
  214.   
  215.     }  
  216.   
  217.     return programHandle;  
  218. }  
  219.   
  220. static unsigned char * readYUV(const char *path)  
  221. {  
  222.   
  223.     FILE *fp;  
  224.     unsigned char * buffer;  
  225.     long size = 1280 * 720 * 3 / 2;  
  226.   
  227.     if((fp=fopen(path,"rb"))==NULL)  
  228.     {  
  229.         log("cant open the file");  
  230.        exit(0);  
  231.     }  
  232.   
  233.     buffer = (unsigned char *)malloc(size);  
  234.     memset(buffer,'\0',size);  
  235.     long len = fread(buffer,1,size,fp);  
  236.     //PRINTF("read data size:%ld", len);  
  237.     fclose(fp);  
  238.     return buffer;  
  239. }  
  240.   
  241. void gl_initialize()   
  242. {  
  243.     g_buffer = NULL;  
  244.   
  245.     simpleProgram = buildProgram(VERTEX_SHADER, FRAG_SHADER);  
  246.     glUseProgram(simpleProgram);  
  247.     glGenTextures(1, &g_texYId);  
  248.     glGenTextures(1, &g_texUId);  
  249.     glGenTextures(1, &g_texVId);  
  250. }  
  251.   
  252. void gl_uninitialize()  
  253. {  
  254.   
  255.     g_width = 0;  
  256.     g_height = 0;  
  257.   
  258.     if (g_buffer)  
  259.     {  
  260.         free(g_buffer);  
  261.         g_buffer = NULL;  
  262.     }  
  263. }  
  264. //设置图像数据  
  265. void gl_set_framebuffer(const char* buffer, int buffersize, int width, int height)  
  266. {  
  267.       
  268.     if (g_width != width || g_height != height)  
  269.     {  
  270.         if (g_buffer)  
  271.             free(g_buffer);  
  272.   
  273.         g_width = width;  
  274.         g_height = height;  
  275.   
  276.         g_buffer = (char *)malloc(buffersize);  
  277.     }  
  278.   
  279.     if (g_buffer)  
  280.         memcpy(g_buffer, buffer, buffersize);  
  281.   
  282. }  
  283. //画屏  
  284. void gl_render_frame()  
  285. {  
  286.     if (0 == g_width || 0 == g_height)  
  287.         return;  
  288.   
  289. #if 0  
  290.     int width = 448;  
  291.     int height = 336;  
  292.     static unsigned char *buffer = NULL;  
  293.   
  294.     if (NULL == buffer)  
  295.     {  
  296.         char filename[128] = {0};  
  297.         strcpy(filename, "/sdcard/yuv_448_336.yuv");  
  298.         buffer = readYUV(filename);  
  299.     }  
  300.   
  301. #else  
  302.     const char *buffer = g_buffer;  
  303.     int width = g_width;  
  304.     int height = g_height;  
  305. #endif  
  306.     glViewport(0, 0, width, height);  
  307.     bindTexture(g_texYId, buffer, width, height);  
  308.     bindTexture(g_texUId, buffer + width * height, width/2, height/2);  
  309.     bindTexture(g_texVId, buffer + width * height * 5 / 4, width/2, height/2);  
  310.    renderFrame();   
  311. }  
  312. //如果设置图像数据和画屏是两个线程的话，记住要加锁。  
[cpp]  view plain copy
  1. //Shader.frag文件内容  
  2. static const char* FRAG_SHADER =  
  3.     "varying lowp vec2 tc;\n"  
  4.     "uniform sampler2D SamplerY;\n"  
  5.     "uniform sampler2D SamplerU;\n"  
  6.     "uniform sampler2D SamplerV;\n"  
  7.     "void main(void)\n"  
  8.     "{\n"  
  9.         "mediump vec3 yuv;\n"  
  10.         "lowp vec3 rgb;\n"  
  11.         "yuv.x = texture2D(SamplerY, tc).r;\n"  
  12.         "yuv.y = texture2D(SamplerU, tc).r - 0.5;\n"  
  13.         "yuv.z = texture2D(SamplerV, tc).r - 0.5;\n"  
  14.         "rgb = mat3( 1,   1,   1,\n"  
  15.                     "0,       -0.39465,  2.03211,\n"  
  16.                     "1.13983,   -0.58060,  0) * yuv;\n"  
  17.         "gl_FragColor = vec4(rgb, 1);\n"  
  18.     "}\n";  
[cpp]  view plain copy
  1. //Shader.vert文件内容  
  2. static const char* VERTEX_SHADER =    
  3.       "attribute vec4 vPosition;    \n"  
  4.       "attribute vec2 a_texCoord;   \n"  
  5.       "varying vec2 tc;     \n"  
  6.       "void main()                  \n"  
  7.       "{                            \n"  
  8.       "   gl_Position = vPosition;  \n"  
  9.       "   tc = a_texCoord;  \n"  
  10.       "}                            \n";


Android平台使用OpenGLES2.0显示YUV数据
11-27
Android平台采集Camera的YUV原始数据后使用OpenGLES2.0显示，内置YV12格式的YUV分量分离。 附件为完整例子，感谢“李狗蛋52635”提供的GLProgram类。
通过opengl es 2.0来实现yuv的显示
Like Linux
07-19 8745
[cpp] view plaincopyprint? // OpenGL ES 2.0 code   [cpp] view plaincopyprint? #include "Shader.vert"  #include "Shader.frag"    #include   #include     #include   #include     #in
Android上使用OpenGLES2.0显示YUV数据
wurensen的专栏
03-11 3457
转自：http://blog.csdn.net/ueryueryuery/article/details/17608185 在Android上用OpenGLES来显示YUV图像，之所以这样做，是因为： 1.Android本身也不能直接显示YUV图像，YUV转成RGB还是必要的； 2.YUV手动转RGB会占用大量的CPU资源，如果以这样的形式播放视频，手机会很热，所以我
使用OpenGL ES对YUV图片进行显示
06-13
使用OpenGL ES对YUV图片进行显示，流程为先提取YUV数据中的Y,U,V分量，在通过纹理贴图的方式，这样就可以达到显示图片的效果
通过opengl es 2.0来实现yuv(NV21)的显示
shuwu
06-10 5677
基本思路参考如下文章，用opengl es2.0 来实现yuv（NV21）的显示。  http://blog.csdn.net/fu_shuwu/article/details/72972312 public static String VERTEX_SHADER = "attribute vec4 vPosition; \n"+
opengl es2.0 -YUV-RGB互转+显示到手机屏幕 DEMO
04-30
OpenGL ES 2.0 是移动设备上的一个图形处理标准，用于在...总的来说，这个DEMO提供了一个实践YUV到RGB转换以及在OpenGL ES 2.0环境下显示图像的实例，对于多媒体处理和移动图形开发人员来说，是一个有价值的学习资源。
android yuv数据处理_Android上使用OpenGLES2.0显示YUV数据
weixin_39560064的博客
12-22 573
在Android上用OpenGLES来显示YUV图像，之所以这样做，是因为：1.Android本身也不能直接显示YUV图像，YUV转成RGB还是必要的；2.YUV手动转RGB会占用大量的CPU资源，如果以这样的形式播放视频，手机会很热，所以我们尽量让GPU来做这件事；3.OpenGLES是Android集成到自身框架里的第三方库，它有很多的可取之处。博主的C/C++不是很好，所以整个过程是在Jav...
OpenGL ES2.0实现YUV与RGB格式互转并显示DEMO
开发一个OpenGL ES 2.0的DEMO来实现YUV到RGB的转换，并最终显示到手机屏幕上，需要以下知识点： 1. OpenGL ES 2.0的基本概念和编程模型：OpenGL ES 2.0使用着色器来处理图形。开发者需要编写顶点着色器（Vertex ...
Android OpenGLES2.0相关代码 包括一个yuv、RGB互转并显示图片demo 共两个资源
03-26
android使用OpenGLES2.0将YUV数据转为RGB显示. 总共两个资源，实现yuv格式视频显示播放。
Android OpenGL处理YUV数据（I420、NV12、NV21）
03-27
Android OpenGL 针对YUV格式（I420，NV12，NV21）数据渲染
Android Native层使用opengl es渲染yuv420
12-26
Android Native层使用opengl es渲染yuv420，通过egl绑定android的surface，直接在native层进行渲染 具体使用见http://blog.csdn.net/lidec/article/details/73732369#comments
使用OPENGL实现的YUV播放器
04-15
使用OPENGL实现的YUV播放器，自带H.265解算功能（默认未启动），在VS2017环境下亲测可用，可选择视频分辨率、支持多种格式的显示
opengles 显示 yuv
--------→成人不自在，自在不成人℃ ------------
05-07 1万+
// OpenGL ES 2.0 code#include "Shader.vert" #include "Shader.frag" #include #include #include #include #include #include #include enum { ATTRIB_VERTEX, ATTRIB_TEXTURE, }; static GL
Android OpenGL ES 2.0（二）------用shader实现将YUV转RGBA
xingfuyisheng的专栏
01-30 1232
代码地址 参考链接一, 参考链接二
六、opengles显示YUV数据
最新发布
zw1996的博客
06-06 2620
将yuv数据进行显示使用opengles
OpenGL ES 3.0 开发（三）：YUV 渲染
热门推荐
字节流动
07-24 4万+
YUV 渲染原理 前面文章一文掌握 YUV 图像的基本处理介绍了 YUV 常用的基本格式，本文以实现 NV21/NV12 的渲染为例。 前文提到，YUV 图不能直接用于显示，需要转换为 RGB 格式，而 YUV 转 RGB 是一个逐像素处理的耗时操作，在 CPU 端进行转换效率过低，这时正好可以利用 GPU 强大的并行处理能力来实现 YUV 到 RGB 的转换。 YUV 与 RGB 之间的转换公式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值