OpenGL播放yuv数据流(着色器SHADER)-windows(一)

点击打开原文链接

OpenGL播放yuv数据流(着色器SHADER)-windows(一)

在写这篇文章之前首先要感谢老雷，http://blog.csdn.net/leixiaohua1020/article/details/40379845这篇文章，可以老雷英年早逝，在此致敬...

下面是代码，具体看注释

//Lvs_OpenGl_Interface.h

[cpp] view
plain copy

/** Copyright (c/c++) <2016.11.22> <zwg/>

* Function

* Opanal for video rendering related implementation and definition, etc.

* OpanAl 用于视频渲染相关实现及定义，等

*/

#ifndef __LVS_OPENGL_INTERFACE_H__

#define __LVS_OPENGL_INTERFACE_H__

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <string.h>

//windows

#ifdef WIN32

//opengl库

#include "glew.h"

#include "glut.h"

#pragma comment(lib,"glew32.lib")

//ios

#elif __APPLE__

//opengl库

#include "glew.h"

#include "glut.h"

//ANDROID平台

#elif __ANDROID__

//opengl库

#include "glew.h"

#include "glut.h"

//linux

#else

//opengl库

#include "glew.h"

#include "glut.h"

#endif

//到处宏定义

//windows

#ifdef WIN32

#define LVS_DLLEXPORT __declspec(dllexport)

//ios

#elif __APPLE__

#define LVS_DLLEXPORT

//linux

#else

#define LVS_DLLEXPORT

#endif

//着色器用的顶点属性索引 position是由3个（x,y,z）组成，

#define ATTRIB_VERTEX 3

//着色器用的像素，纹理属性索引 而颜色是4个（r,g,b,a）

#define ATTRIB_TEXTURE 4

//是否旋转图像(纹理)

#define TEXTURE_ROTATE 0

//显示图像(纹理)的一半

#define TEXTURE_HALF 0

//窗口消息函数指针

typedef void (*WindowRepaintCK)(void);

//回调读取数据函数指针，数据及时间戳

typedef int (*DisplayDataCK)(void ** data,int * timer_millis);

//接口初始化

int lvs_opengl_interface_init(int screen_width,int screen_height,

int window_x, int window_y,

int yuvdata_width,int uvdata_height,

char * shader_vsh_pathname,char * shader_fsh_pathname,

DisplayDataCK displaydatack,

WindowRepaintCK windowrepaintcallback);

//接口释放

void lvs_opengl_interface_uninit();

//接口渲染数据(定时器，渲染时间,毫秒),数据及渲染定时时间在回调里面做处理

void lvs_opengl_interface_write(int value);

//接口opengl消息循环

void lvs_opengl_interface_messageloop();

//渲染数据(定时器，渲染时间,毫秒),数据及渲染定时时间在回调里面做处理

void TimerFunc1(int value); //这里如果有可能则调成类的成员函数，以后处理，暂时不知道怎么解决类成员函数递归??

using namespace std;

class cclass_opengl_interface;

class cclass_opengl_interface

{

public:

cclass_opengl_interface();

virtual ~cclass_opengl_interface();

//初始化

int initopengl(int screen_width,int screen_height,

int window_x, int window_y,

int yuvdata_width,int uvdata_height,

char * shader_vsh_pathname,char * shader_fsh_pathname,

DisplayDataCK displaydatack,

WindowRepaintCK windowrepaintcallback);

//初始化着色器，类似于告GPU当传进去数据的时候采用什么样的规则。

void InitShaders();

//具体显示图像的函数

int DisplayImage(void * parm);

//opengl消息循环

void messageloop();

private:

public:

DisplayDataCK m_displaydatack; //用于显示回调函数，参数数据及时间戳

char * m_yuvbuf; //存放yuv数据的buf指针，申请buffer在外面

int m_millis_realtime; //实时的时间戳，每次回调会更新

private:

int m_screen_width; //窗口宽

int m_screen_height; //窗口高

int m_window_x; //窗口的x坐标

int m_window_y; //窗口的y坐标

int m_yuvdata_width; //数据宽

int m_yuvdata_height; //数据高

WindowRepaintCK m_windowrepaintcallback; //窗口重绘的时候，例如最大化最小化窗口，缩放窗口等让窗口重绘的时候调用。//从而接收消息循环

char m_shader_vsh_pathname[256]; //shader的vsh源码位置

char m_shader_fsh_pathname[256]; //shader的fsh源码位置

GLuint m_textureid_y, m_textureid_u, m_textureid_v; //纹理的名称，并且，该纹理的名称在当前的应用中不能被再次使用。

GLuint m_textureUniformY, m_textureUniformU,m_textureUniformV; //用于纹理渲染的变量

};

#endif

//Lvs_OpenGl_Interface.cpp

[cpp] view
plain copy

#include "Lvs_OpenGl_Interface.h"

static cclass_opengl_interface * copengl_interface = NULL;

int lvs_opengl_interface_init(int screen_width,int screen_height,

int window_x, int window_y,

int yuvdata_width,int uvdata_height,

char * shader_vsh_pathname,char * shader_fsh_pathname,

DisplayDataCK displaydatack,

WindowRepaintCK windowrepaintcallback)

{

int ret = 0;

printf("Device : lvs_opengl_interface_init\n");

if(copengl_interface == NULL)

{

copengl_interface = new cclass_opengl_interface();

//初始化

copengl_interface->initopengl(screen_width,screen_height,

window_x,window_y,

yuvdata_width,uvdata_height,

shader_vsh_pathname,shader_fsh_pathname,

displaydatack,

windowrepaintcallback);

//初始化着色器，类似于告GPU当传进去数据的时候采用什么样的规则。

copengl_interface->InitShaders();

}

return ret;

}

void lvs_opengl_interface_uninit()

{

printf("Device : lvs_opengl_interface_uninit\n");

if(copengl_interface)

{

delete copengl_interface;

copengl_interface = NULL;

}

return ;

}

void lvs_opengl_interface_write(int value)

{

//这里如果有可能则调成类的成员函数，以后处理，暂时不知道怎么解决类成员函数递归

TimerFunc1(value);

}

void lvs_opengl_interface_messageloop()

{

copengl_interface->messageloop();

}

void TimerFunc1(int value)

{

int ret = 0;

//调用回调函数获取数据

copengl_interface->m_displaydatack((void **)&copengl_interface->m_yuvbuf,&copengl_interface->m_millis_realtime);

//这里做具体的处理

ret = copengl_interface->DisplayImage(NULL);

//因为glut的定时器是调用一次才产生一次定时，所以如果要持续产生定时的话，

//在定时函数末尾再次调用glutTimerFunc

//这里如果有可能则调成类的成员函数，以后处理，暂时不知道怎么解决类成员函数递归

glutTimerFunc(copengl_interface->m_millis_realtime, TimerFunc1, 0);

}

cclass_opengl_interface::cclass_opengl_interface()

{

m_screen_width = 0;

m_screen_height = 0;

m_window_x = 0;

m_window_y = 0;

m_yuvdata_width = 0;

m_yuvdata_height = 0;

memset(m_shader_vsh_pathname,0,256);

memset(m_shader_fsh_pathname,0,256);

m_windowrepaintcallback = NULL;

m_textureid_y = 0;

m_textureid_u = 0;

m_textureid_v = 0;

m_textureUniformY = 0;

m_textureUniformU = 0;

m_textureUniformV = 0;

m_displaydatack = NULL;

m_yuvbuf = NULL;

m_millis_realtime = 0;

}

cclass_opengl_interface::~cclass_opengl_interface()

{

m_screen_width = 0;

m_screen_height = 0;

m_window_x = 0;

m_window_y = 0;

m_yuvdata_width = 0;

m_yuvdata_height = 0;

memset(m_shader_vsh_pathname,0,256);

memset(m_shader_fsh_pathname,0,256);

m_windowrepaintcallback = NULL;

m_textureid_y = 0;

m_textureid_u = 0;

m_textureid_v = 0;

m_textureUniformY = 0;

m_textureUniformU = 0;

m_textureUniformV = 0;

m_displaydatack = NULL;

m_yuvbuf = NULL;

m_millis_realtime = 0;

}

int cclass_opengl_interface::initopengl(int screen_width,int screen_height,

int window_x, int window_y,

int yuvdata_width,int uvdata_height,

char * shader_vsh_pathname,char * shader_fsh_pathname,

DisplayDataCK displaydatack,

WindowRepaintCK windowrepaintcallback)

{

int ret = 0;

m_screen_width = screen_width;

m_screen_height = screen_height;

m_window_x = window_x;

m_window_y = window_y;

m_yuvdata_width = yuvdata_width;

m_yuvdata_height = uvdata_height;

sprintf(m_shader_vsh_pathname,"%s",shader_vsh_pathname);

sprintf(m_shader_fsh_pathname,"%s",shader_fsh_pathname);

m_windowrepaintcallback = windowrepaintcallback;

m_displaydatack = displaydatack;

//初始化 GLUT opengl函数库

int zwg_argc=1;

//添加函数库名称

char* zwg_argv[]={"ZWG_GLUT"};

glutInit(&zwg_argc, zwg_argv);

//设置显示模型

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA /*| GLUT_STENCIL | GLUT_DEPTH*/);

//设置在屏幕上的起始位置

glutInitWindowPosition(m_window_x, m_window_y);

//设置显示窗口大小，宽高

glutInitWindowSize(m_screen_width, m_screen_height);

//设置显示窗口名称

glutCreateWindow("Lvs_OpenGl");

//OpenGL扩展库是个简单的工具，opengl纹理程序用的着色程序初始化

GLenum lvs_glew = glewInit();

//输出版本号

printf("OpenGl Version: %s\n", glGetString(GL_VERSION));

//设置绘制窗口时候接收消息的回调函数

glutDisplayFunc(m_windowrepaintcallback);

ret = 1;

return ret;

}

void cclass_opengl_interface::InitShaders()

{

GLint vertCompiled, fragCompiled; //调试 shader的返回值，如果一切正常返回GL_TRUE代，否则返回GL_FALSE。

GLuint p; //Program着色器程序的id

GLint linked; //调试 param的返回值，如果一切正常返回GL_TRUE代，否则返回GL_FALSE。

GLint v, f; //shader的id;

char vs[1024 *10] = {0}; //shader源码的字串vsh 是Vertex Shader（顶点着色器）

char fs[1024 *10] = {0}; //shader源码的字串fsh 是Fragment Shader（片元着色器）

const char * vs_buf = vs;

const char * fs_buf = fs;

//shader的处理类似于将OpenGL Shader Language,简称GLSL的源码编译成2进制程序

//“vsh负责搞定像素位置，填写gl_Posizion；fsh负责搞定像素外观，填写 gl_FragColor。”

//Shader: step1 创建两个shader 实例。

v = glCreateShader(GL_VERTEX_SHADER);

f = glCreateShader(GL_FRAGMENT_SHADER);

//着色器源码

//penGL的着色器有.fsh和.vsh两个文件。这两个文件在被编译和链接后就可以产生可执行程序与GPU交互。

//shader.vsh 是Vertex Shader（顶点着色器），用于顶点计算，可以理解控制顶点的位置，在这个文件中我们通常会传入当前顶点的位置，和纹理的坐标。

//shader.fsh 是Fragment Shader（片源着色器），在这里面我可以对于每一个像素点进行重新计算。

//将Vertex Shader和Fragment Shader源码读取到字符串中。

FILE * infile_vsh = fopen(m_shader_vsh_pathname, "rb");

int len_vsh = fread((char *)vs, 1, 1024 *10, infile_vsh);

fclose(infile_vsh);

infile_vsh = NULL;

vs[len_vsh] = 0;

FILE * infile_fsh = fopen(m_shader_fsh_pathname, "rb");

int len_fsh = fread((char *)fs, 1, 1024 *10, infile_fsh);

fclose(infile_fsh);

infile_fsh = NULL;

vs[len_fsh] = 0;

//Shader: step2 给Shader实例指定源码。

glShaderSource(v, 1, &vs_buf,NULL);

glShaderSource(f, 1, &fs_buf,NULL);

//Shader: step3 在线编译Shader源码。

glCompileShader(v);

//Shader: step4 调试一个Shader

//void glGetShaderiv( GLuint shader,GLenum pname,GLint *params);

//params：返回值，如果一切正常返回GL_TRUE代，否则返回GL_FALSE。

glGetShaderiv(v, GL_COMPILE_STATUS, &vertCompiled);

glCompileShader(f);

glGetShaderiv(f, GL_COMPILE_STATUS, &fragCompiled);

//Program有点类似于一个程序的链接器。program对象提供了把需要做的事连接在一起的机制。在一个program中，shader对象可以连接在一起。

//Program 这个类似于运行OpenGL Shader Language,简称GLSL的源码编译成2进制程序的执行环境，链接器

//Program: Step1 创建program

p = glCreateProgram();

//Program: Step2 绑定shader到program

glAttachShader(p,v);

glAttachShader(p,f);

//通过glBindAttribLocation()把“顶点属性索引”绑定到“顶点属性名”

glBindAttribLocation(p, ATTRIB_VERTEX, "vertexIn");

//通过glBindAttribLocation()把“像素纹理属性索引”绑定到“像素纹理属性名”

glBindAttribLocation(p, ATTRIB_TEXTURE, "textureIn");

//Program: Step3 链接program

glLinkProgram(p);

//void glGetProgramiv (int program, int pname, int[] params, int offset)

//参数含义：

// program：一个着色器程序的id；

// pname：GL_LINK_STATUS；

// param：返回值，如果一切正常返回GL_TRUE代，否则返回GL_FALSE。

glGetProgramiv(p, GL_LINK_STATUS, &linked);

//Program: Step4 在链接了程序以后，我们可以使用glUseProgram()函数来加载并使用链接好的程序

glUseProgram(p);

//获取片源着色器源码中的变量,用于纹理渲染

m_textureUniformY = glGetUniformLocation(p, "tex_y");

m_textureUniformU = glGetUniformLocation(p, "tex_u");

m_textureUniformV = glGetUniformLocation(p, "tex_v");

//顶点数组(物体表面坐标取值范围是-1到1,数组坐标：左下，右下，左上，右上)

#if TEXTURE_ROTATE

static const GLfloat vertexVertices[] = {

-1.0f, -0.5f,

0.5f, -1.0f,

-0.5f, 1.0f,

1.0f, 0.5f,

};

#else

static const GLfloat vertexVertices[] = {

-1.0f, -1.0f,

1.0f, -1.0f,

-1.0f, 1.0f,

1.0f, 1.0f,

};

#endif

//像素，纹理数组(纹理坐标取值范围是0-1，坐标原点位于左下角,数组坐标：左上，右上，左下，右下,如果先左下，图像会倒过来)

#if TEXTURE_HALF

static const GLfloat textureVertices[] = {

0.0f, 1.0f,

0.5f, 1.0f,

0.0f, 0.0f,

0.5f, 0.0f,

};

#else

static const GLfloat textureVertices[] = {

0.0f, 1.0f,

1.0f, 1.0f,

0.0f, 0.0f,

1.0f, 0.0f,

};

#endif

//定义顶点数组

glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, vertexVertices);

//启用属性数组

glEnableVertexAttribArray(ATTRIB_VERTEX);

//定义像素纹理数组

glVertexAttribPointer(ATTRIB_TEXTURE, 2, GL_FLOAT, 0, 0, textureVertices);

//启用属性数组

glEnableVertexAttribArray(ATTRIB_TEXTURE);

//初始化纹理

glGenTextures(1, &m_textureid_y);

//绑定纹理

glBindTexture(GL_TEXTURE_2D, m_textureid_y);

//设置该纹理的一些属性

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_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);

glGenTextures(1, &m_textureid_u);

glBindTexture(GL_TEXTURE_2D, m_textureid_u);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_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);

glGenTextures(1, &m_textureid_v);

glBindTexture(GL_TEXTURE_2D, m_textureid_v);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_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);

}

int cclass_opengl_interface::DisplayImage(void * parm)

{

int ret = 0;

unsigned char * yuvplaner[3] = {0}; //存放yuv数据的分量数组(y,u,v)

//关联到yuv数据的分量数组

yuvplaner[0] = (unsigned char *)m_yuvbuf;

yuvplaner[1] = yuvplaner[0] + m_yuvdata_width*m_yuvdata_height;

yuvplaner[2] = yuvplaner[1] + m_yuvdata_width*m_yuvdata_height/4;

//Clear

//清除颜色设为黑色，把整个窗口清除为当前的清除颜色，glClear（）的唯一参数表示需要被清除的缓冲区。

glClearColor(0.0,0.0,0.0,0.0);

glClear(GL_COLOR_BUFFER_BIT);

//显卡中有N个纹理单元（具体数目依赖你的显卡能力），每个纹理单元（GL_TEXTURE0、GL_TEXTURE1等）都有GL_TEXTURE_1D、GL_TEXTURE_2D等

//Y

//选择当前活跃的纹理单元

glActiveTexture(GL_TEXTURE0);

//允许建立一个绑定到目标纹理的有名称的纹理

glBindTexture(GL_TEXTURE_2D, m_textureid_y);

//根据指定的参数，生成一个2D纹理（Texture）。相似的函数还有glTexImage1D、glTexImage3D。

glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, m_yuvdata_width, m_yuvdata_height, 0, GL_RED, GL_UNSIGNED_BYTE, yuvplaner[0]);

glUniform1i(m_textureUniformY, 0); //设置纹理，按照前面设置的规则怎样将图像或纹理贴上（参数和选择的活跃纹理单元对应，GL_TEXTURE0）

//U

glActiveTexture(GL_TEXTURE1);

glBindTexture(GL_TEXTURE_2D, m_textureid_u);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, m_yuvdata_width/2, m_yuvdata_height/2, 0, GL_RED, GL_UNSIGNED_BYTE, yuvplaner[1]);

glUniform1i(m_textureUniformU, 1);

//V

glActiveTexture(GL_TEXTURE2);

glBindTexture(GL_TEXTURE_2D, m_textureid_v);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, m_yuvdata_width/2, m_yuvdata_height/2, 0, GL_RED, GL_UNSIGNED_BYTE, yuvplaner[2]);

glUniform1i(m_textureUniformV, 2);

// 绘制

glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

//双缓冲显示

glutSwapBuffers();

//单缓冲显示

//glFlush();

return 1;

}

void cclass_opengl_interface::messageloop()

{

//glutMainLoop进入GLUT事件处理循环，让所有的与“事件”有关的函数调用无限循环。开始时间循环

glutMainLoop();

}

//main.cpp

[cpp] view
plain copy

#include "Lvs_OpenGl_Interface.h"

//要显示的yuv文件路径及名称

#define YUV_STREAM_PATH_NAME "../yuv_stream/352_288_yuv420p.yuv"

//yuv数据宽

#define YUVDATA_WIDTH 352

//yuv数据高

#define YUVDATA_HEIGHT 288

//shader的vsh源码位置

#define SHADER_VSH_SOURCE "../opengl_win32/Shader.vsh"

//shader的fsh源码位置

#define SHADER_FSH_SOURCE "../opengl_win32/Shader.fsh"

static FILE * m_inyuvfile = NULL; //yuv文件句柄

static unsigned char m_yuvbuf[YUVDATA_WIDTH*YUVDATA_HEIGHT*3/2]; //存放yuv数据的buf

static unsigned char * m_yuvplane[3] = {0}; //存放yuv数据的分量数组(y,u,v)

static int m_timer_realtime = 40; //每一次回调渲染数据定时器时间，可根据时间戳变化，毫秒

//窗口重绘的时候，例如最大化最小化窗口，缩放窗口等让窗口重绘的时候调用。

//从而接收消息循环

void WindowRepaintCallback();

//回调读取数据函数，参数数据及时间戳

int DisplayDataCallback(void * data,int * timer_millis);

//窗口重绘的时候，例如最大化最小化窗口，缩放窗口等让窗口重绘的时候调用。

//从而接收消息循环

void WindowRepaintCallback()

{

//可以做一些处理

printf("窗口重绘了...\n");

}

int DisplayDataCallback(void ** data,int * timer_millis)

{

int ret = 0;

//循环读取文件

ret = fread(m_yuvbuf, 1, YUVDATA_WIDTH*YUVDATA_HEIGHT*3/2, m_inyuvfile);

if (ret != YUVDATA_WIDTH*YUVDATA_HEIGHT*3/2)

{

//seek到文件开头

fseek(m_inyuvfile, 0, SEEK_SET);

fread(m_yuvbuf, 1,YUVDATA_WIDTH*YUVDATA_HEIGHT*3/2, m_inyuvfile);

}

//将数据返回去

*data = m_yuvbuf;

*timer_millis = m_timer_realtime;

return ret;

}

int main()

{

int ret = 0;

//打开 YUV420P 文件

if((m_inyuvfile = fopen(YUV_STREAM_PATH_NAME, "rb")) == NULL)

{

printf("filed open file : %s\n",YUV_STREAM_PATH_NAME);

return getchar();

}

else

{

printf("success open file : %s\n",YUV_STREAM_PATH_NAME);

}

//初始化

ret = lvs_opengl_interface_init(500,500,

100,100,

YUVDATA_WIDTH,YUVDATA_HEIGHT,

SHADER_VSH_SOURCE,SHADER_FSH_SOURCE,

DisplayDataCallback,

WindowRepaintCallback);

//渲染，带定时器,数据回调，及渲染时间回调

lvs_opengl_interface_write(m_timer_realtime);

//glutMainLoop进入GLUT事件处理循环，让所有的与“事件”有关的函数调用无限循环。开始时间循环

lvs_opengl_interface_messageloop();

//关闭yuv420p文件

if (m_inyuvfile != NULL)

{

fclose(m_inyuvfile);

m_inyuvfile = NULL;

}

return 1;

}

程序运行效果：



暂时不知道怎么解决类成员函数递归，以后待解决。

本demo还需完善。

如有错误请指正：

交流请加QQ群：62054820

QQ：379969650.