最簡單的視音頻播放示例5：OpenGL播放RGB/YUV

本文記錄OpenGL播放視頻的技術。OpenGL是一個和Direct3D同一層面的技術。相比於Direct3D，OpenGL具有跨平台的優勢。盡管在游戲領域，DirectX的影響力已漸漸超越OpenGL並被大多數PC游戲開發商所采用，但在專業高端繪圖領域，OpenGL因為色彩准確，仍然是不能被取代的主角。

OpenGL簡介

從網上搜集了一些有關OpenGL簡介方面的知識，在這里列出來。
開放圖形庫（英語：Open Graphics Library，縮寫為OpenGL）是個定義了一個跨編程語言、跨平台的應用程序接口（API）的規范，它用於生成二維、三維圖像。
OpenGL規范由1992年成立的OpenGL架構評審委員會（ARB）維護。ARB由一些對創建一個統一的、普遍可用的API特別感興趣的公司組成。根據OpenGL官方網站，2002年6月的ARB投票成員包括3Dlabs、Apple Computer、ATI Technologies、Dell Computer、Evans & Sutherland、Hewlett-Packard、IBM、Intel、Matrox、NVIDIA、SGI和Sun Microsystems，Microsoft曾是創立成員之一，但已於2003年3月退出。
OpenGL仍然是唯一能夠取代微軟對3D圖形技術的完全控制的API。它仍然具有一定的生命力，但是Silicon Graphics已經不再以任何讓微軟不悅的方式推廣OpenGL，因而它存在較高的風險。在高端的圖形設備和專業應用方面OpenGL占據着統治地位（Direct3D目前還不支持）。開放源碼社區（尤其是Mesa項目）一直致力於提供OpenGL支持。
 

OpenGL渲染管線

下文也是網上看的，搞懂了一部分，但是由於3D方面基礎不牢固有些方面還沒有完全弄懂。

OpenGL渲染管線（OpenGL Pipeline）按照特定的順序對圖形信息進行處理，這些圖形信息可以分為兩個部分：頂點信息(坐標、法向量等)和像素信息(圖像、紋理等)。圖形信息最終被寫入幀緩存中，存儲在幀緩存中的數據(圖像)，可以被應用程序獲得(用於保存結果，或作為應用程序的輸入等，見下圖中灰色虛線)。

Display List（顯示列表）
顯示列表是一組OpenGL命令，被存儲（編譯）起來用於后續的執行。所有數據，幾何（頂點）數據和像素數據都可以存入顯示列表。數據和命令緩存到顯示列表中可以提高性能。
Vertex Operation（頂點處理）
頂點坐標和法線坐標經過模式視圖矩陣從物體坐標系（object coordinates）轉換為觀察坐標系（eye coordinates）。若啟用了光照，對轉換后的定點和法線坐標執行光照計算。光照計算更新了頂點的顏色值。

Primitive Assembly（圖元裝配）

頂點處理之后，基本圖元（點、線、多邊形）經過投影矩陣變換，再被視見體裁剪平面裁剪，從觀察坐標系轉換為裁剪坐標系。之后，進行透視除法（除以w）和視口變換（viewport transform），將3d場景投影到窗口坐標系。

Pixel Transfer Operation（像素操作）

像素從客戶內存中解包出來之后，要經過縮放、偏移、映射、箝拉（clamping）。這些處理即為像素轉換操作。轉換的數據存在紋理內存或直接經過光柵化轉為片段（fragment）。

Texture Memory（紋理內存）

紋理圖像載入到紋理內存中，然后應用到幾何對象上。 

Raterization（光柵化）

光柵化就是把幾何(頂點坐標等)和像素數據轉換為片段(fragment)的過程，每個片段對應於幀緩沖區中的一個像素，該像素對應屏幕上一點的顏色和不透明度信息。片段是一個矩形數組，包含了顏色、深度、線寬、點的大小等信息(反鋸齒計算等)。如果渲染模式被設置為GL_FILL，多邊形內部的像素信息在這個階段會被填充。

如上圖中的三角形，輸入三角形的三個頂點坐標以及其顏色，頂點操作會對三角形的頂點坐標以及法向量進行變換，顏色信息不需要經過變換，但光照計算會影響頂點的顏色信息。經過光柵化后，三角形被離散為一個個點，不在是三個坐標表示，而是由一系列的點組成，每個點存儲了相應的顏色、深度和不透明度等信息。
 
Fragment Operation（片段操作）
這是將片段轉為幀緩沖區中的像素要進行的最后處理。首先是紋理單元（texel）生成。一個紋理單元由紋理內存中的數據生成，然后應用到每個片段上。之后進行霧計算。 霧計算完成后，還要按序進行若干片段測試，依次為蒙板（scissor）測試，alpha測試，模版（stencil）測試，深度測試。最后，執行混合，抖動，邏輯操作和遮蔽操作，最終的像素存入framebuffer。
 

OpenGL與Direct3D的對比

有關視頻顯示的技術在《Direct3D》文章中已經有過敘述，在這里不再重復。在網上看了一下有關於他們不同點的文章，寫得簡單明了，在這里引用一下：
OpenGL與Direct3D的一點點對比
OGL比D3D好的地方：
OGL是業界標准，許多非Windows操作系統下還找不到D3D
OGL的色彩比D3D的要好，表面更光滑
OGL的函數很有規律，不像D3D的，都是指針method，函數名太長了！！
OGL是右手坐標系，這是數學里用慣了的.D3D雖然也可以改變成右手坐標系，但是需要d3dx9_36.dll的支持
OGL的常用Matrix，如WorldMatrix都封裝好了，D3D要自己寫。
OGL的繪圖方式很靈活，而D3D的則要事先定義好FVF，要等所有信息寫進Stream中才繪制。這就使它產生了VertexBuffer和IndexBuffer.好象微軟嫌D3D的Buffer不夠多？搞的多不好學？？看人家OGL,哪里要這個東西？
D3D有好多版本，要是顯卡不支持就廢柴一垛了。而OGL從幾年前就一直沒變過，所以大部分顯卡都支持。
還有，我發現D3D的半透明功能有很大的問題！！就是兩個半透明的物體前后順序的問題——前面的會被后面的擋住。
 
但是D3D也有比OGL好的地方：
D3D支持許多格式的圖片文件，而OGL載入jpg都得自己寫代碼。
因為D3D是指針調用模式，所以做D3D的鈎子有難度，從而增加了外掛的制作難度。
D3D是DirectX的成員。程序員要實現聲音播放可以用DirectMusic,配套用總是好的，而OGL則只能畫畫
D3D是被微軟大力推廣的連接庫。相反，微軟則大力壓制OGL(都是Microsoft參與研制出來的產品，待遇怎這么大？)
正因為此，D3D已成為中國大型游戲界的主流（我覺得他們是盲目跟風。其實國外很多游戲都是用OGL）
 

OpenGL視頻顯示的流程

使用OpenGL播放視頻最簡單的情況下需要如下步驟：
1.       初始化

1)         初始化
2)         創建窗口
3)         設置繪圖函數
4)         設置定時器
5)         進入消息循環

2.       循環顯示畫面

1)       調整顯示位置，圖像大小
2)       畫圖
3)       顯示

在這里有一點需要說明。即OpenGL不需要使用Direct3D那種使用WinMain()作為主函數的程序初始化窗口。在Direct3D中是必須要這樣做的，即使用Win32的窗口程序並且調用CreateWindow()創建一個對話框，然后才可以在對話框上繪圖。OpenGL只需要使用普通的控制台程序即可（入口函數為main()）。當然，OpenGL也可以像Direct3D那樣把圖像繪制在Win32程序的窗口中。
 
下面結合OpenGL播放YUV/RGB的示例代碼，詳細分析一下上文的流程。
在詳述播放流程之前，再說一點自己學習OpenGL時候的一個明顯的感覺：OpenGL的函數好多啊。OpenGL的函數的特點是數量多，但是每個函數的參數少。而Direct3D的特點和它正好反過來，函數少，但是每個函數的參數多。

1.       初始化

1)         初始化
glutInit()用於初始化glut庫。它原型如下：

void glutInit(int *argcp, char **argv);

它包含兩個參數：argcp和argv。一般情況下，直接把main()函數中的argc，argv傳遞給它即可。
在這里簡單介紹OpenGL中的3個庫：glu，glut，glew
glu是實用庫，包含有43個函數，函數名的前綴為glu。Glu 為了減輕繁重的編程工作，封裝了OpenGL函數，Glu函數通過調用核心庫的函數，為開發者提供相對簡單的用法，實現一些較為復雜的操作。
　　glut是實用工具庫，基本上是用於做窗口界面的，並且是跨平台的。

        glew是一個跨平台的擴展庫。不是必需的。它能自動識別當前平台所支持的全部OpenGL高級擴展函數。還沒有深入研究。

glutInitDisplayMode()用於設置初始顯示模式。它的原型如下。

void glutInitDisplayMode(unsigned int mode)

其中mode可以選擇以下值或組合：

GLUT_RGB: 指定 RGB 顏色模式的窗口
GLUT_RGBA: 指定 RGBA 顏色模式的窗口
GLUT_INDEX: 指定顏色索引模式的窗口
GLUT_SINGLE: 指定單緩存窗口
GLUT_DOUBLE: 指定雙緩存窗口
GLUT_ACCUM: 窗口使用累加緩存
GLUT_ALPHA: 窗口的顏色分量包含 alpha 值
GLUT_DEPTH: 窗口使用深度緩存
GLUT_STENCIL: 窗口使用模板緩存
GLUT_MULTISAMPLE: 指定支持多樣本功能的窗口
GLUT_STEREO: 指定立體窗口
GLUT_LUMINANCE: 窗口使用亮度顏色模型

需要注意的是，如果使用雙緩沖（GLUT_DOUBLE），則需要用glutSwapBuffers ()繪圖。如果使用單緩沖（GLUT_SINGLE），則需要用glFlush()繪圖。
在使用OpenGL播放視頻的時候，我們可以使用下述代碼：

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB );

 
2)         創建窗口
glutInitWindowPosition()用於設置窗口的位置。可以指定x，y坐標。
glutInitWindowSize()用於設置窗口的大小。可以設置窗口的寬，高。
glutCreateWindow()創建一個窗口。可以指定窗口的標題。
上述幾個函數十分基礎，不再詳細敘述。直接貼出一段示例代碼：

glutInitWindowPosition(100, 100);
glutInitWindowSize(500, 500);
glutCreateWindow("Simplest Video Play OpenGL");

 
3)         設置繪圖函數
glutDisplayFunc()用於設置繪圖函數。操作系統在必要時刻就會調用該函數對窗體進行重新繪制操作。類似於windows程序設計中處理WM_PAINT消息。例如，當把窗口移動到屏幕邊上，然后又移動回來的時候，就會調用該函數對窗口進行重繪。它的原型如下。

 

void glutDisplayFunc(void (*func)(void));

 

其中(*func)用於指定重繪函數。

例如在視頻播放的時候，指定display()函數用於重繪：

glutDisplayFunc(&display);

4)         設置定時器
播放視頻的時候，每秒需要播放一定的畫面（一般是25幀），因此使用定時器每間隔一段時間調用一下繪圖函數繪制圖形。定時器函數glutTimerFunc()的原型如下。

void glutTimerFunc(unsigned int millis, void (*func)(int value), int value);

它的參數含義如下：
millis：定時的時間，單位是毫秒。1秒=1000毫秒。
(*func)(int value)：用於指定定時器調用的函數。
value：給回調函數傳參。比較高端，沒有接觸過。
如果只在主函數中寫一個glutTimerFunc()函數的話，會發現只會調用該函數一次。因此需要在回調函數中再寫一個glutTimerFunc()函數，並調用回調函數自己。只有這樣才能實現反反復復循環調用回調函數。
例如在視頻播放的時候，指定每40毫秒調用一次timeFunc ()函數：
主函數中：

glutTimerFunc(40, timeFunc, 0);

而后在timeFunc()函數中如下設置。

void timeFunc(int value){
    display();
    // Present frame every 40 ms
    glutTimerFunc(40, timeFunc, 0);
}

這樣就實現了每40ms調用一次display()。
 
5)         進入消息循環
glutMainLoop()將會進入GLUT事件處理循環。一旦被調用，這個程序將永遠不會返回。視頻播放的時候，調用該函數之后即開始播放視頻。
 

2.       循環顯示畫面

1)       調整顯示位置，圖像大小
這一步主要是調整一下圖像的大小和位置。如果不做這一步而直接使用glDrawPixels()進行繪圖的話，會發現圖像位於窗口的左下角，而且是上下顛倒的（當然，如果窗口和圖像一樣大的話，就不存在圖像位於角落的問題）。效果如下圖所示。

為了解決上述問題，需要調用有關的函數對圖像進行變換。變換用到了兩個函數：glRasterPos3f()和glPixelZoom()。
glRasterPos3f()可以平移圖像。它的原型如下。

void glRasterPos3f (GLfloat x, GLfloat y, GLfloat z);

其中x用於指定x坐標；y用於指定y坐標。Z這里還沒有用到。
在這里介紹一下OpenGL的坐標。原點位於屏幕的中心。屏幕的邊上對應的值是1.0。和數學中的坐標系基本上是一樣的。屏幕的左下角是（-1，-1），左上角是（-1，1）。

例如我們使用glRasterPos3f(-1.0f,0.0f,0)，圖像就會移動至（-1，0），如下圖所示。

glPixelZoom()可以放大、縮小和翻轉圖像。它的原型如下。

void glPixelZoom (GLfloat xfactor, GLfloat yfactor);

其中xfactor、yfactor用於指定在x軸，y軸上放大的倍數（如果數值小於1則是縮小）。如果指定負值，則可以實現翻轉。上文已經說過，使用OpenGL直接顯示像素數據的話，會發現圖像是倒着的。因此需要在Y軸方向對圖像進行翻轉。

例如：像素數據的寬高分別為pixel_w ，pixel_h ；窗口大小為screen_w，screen_h的話，使用下述代碼可以將圖像拉伸至窗口大小，並且翻轉：

glPixelZoom((float)screen_w/(float)pixel_w, -(float)screen_h/pixel_h);

結合上述兩個函數，即“平移+翻轉+拉伸之后”，就可以得到全屏的圖像了，如下圖所示。

 

PS：這個方法屬於比較笨的方法，應該還有更好的方法吧。不過再沒有進行深入研究了。

 

2)       畫圖
使用glDrawPixels()可以繪制指定內存中的像素數據。該函數的原型如下。

void glDrawPixels (
GLsizei width, GLsizei height,
GLenum format,
GLenum type,
const GLvoid *pixels);

該函數的參數的含義如下所示：
Width：像素數據的寬。
Height：像素數據的高。
Format：像素數據的格式，例如GL_RGB，GL_BGR，GL_BGRA等。
Type：像素數據在內存中的格式。
Pixels：指針，指向存儲像素數據的內存。
例如繪制RGB24格式的數據，寬為pixel_w，高為pixel_h，像素數據存儲在buffer中。可以使用如下代碼。

glDrawPixels(pixel_w, pixel_h,GL_RGB, GL_UNSIGNED_BYTE, buffer);

 
3)       顯示
使用雙緩沖的時候，調用函數glutSwapBuffers()進行顯示。
使用單緩沖的時候，調用函數glFlush()進行顯示。
 
 

視頻顯示的流程總結

視頻顯示的函數調用結構可以總結為下圖

 

代碼

貼上源代碼。

 

/**
 * 最簡單的OpenGL播放視頻的例子（OpenGL播放RGB/YUV）
 * Simplest Video Play OpenGL (OpenGL play RGB/YUV)
 *
 * 雷霄驊 Lei Xiaohua
 * [e-mail]
 * 中國傳媒大學/數字電視技術
 * Communication University of China / Digital TV Technology
 * http://blog.csdn.net/leixiaohua1020
 *
 * 本程序使用OpenGL播放RGB/YUV視頻像素數據。本程序實際上只能
 * 播放RGB（RGB24，BGR24，BGRA）數據。如果輸入數據為YUV420P
 * 數據的話，需要先轉換為RGB數據之后再進行播放。
 * 本程序是最簡單的使用OpenGL播放像素數據的例子，適合OpenGL新手學習。
 *
 * 函數調用步驟如下:
 *
 * [初始化]
 * glutInit(): 初始化glut庫。
 * glutInitDisplayMode(): 設置顯示模式。
 * glutCreateWindow(): 創建一個窗口。
 * glutDisplayFunc(): 設置繪圖函數（重繪的時候調用）。
 * glutTimerFunc(): 設置定時器。
 * glutMainLoop(): 進入消息循環。
 *
 * [循環渲染數據]
 * glRasterPos3f(),glPixelZoom(): 調整顯示位置，圖像大小。
 * glDrawPixels(): 繪制。
 * glutSwapBuffers(): 顯示。
 *
 * This software plays RGB/YUV raw video data using OpenGL. This
 * software support show RGB (RGB24, BGR24, BGRA) data on the screen.
 * If the input data is YUV420P, it need to be convert to RGB first.
 * This program is the simplest example about play raw video data
 * using OpenGL, Suitable for the beginner of OpenGL.
 *
 * The process is shown as follows:
 *
 * [Init]
 * glutInit(): Init glut library.
 * glutInitDisplayMode(): Set display mode.
 * glutCreateWindow(): Create a window.
 * glutDisplayFunc(): Set the display callback.
 * glutTimerFunc(): Set timer.
 * glutMainLoop(): Start message loop.
 *
 * [Loop to Render data]
 * glRasterPos3f(),glPixelZoom(): Change picture's size and position.
 * glDrawPixels(): draw.
 * glutSwapBuffers(): show.
 */

#include <stdio.h>

#include "glew.h"
#include "glut.h"

#include <stdlib.h>
#include <malloc.h>
#include <string.h>

//set '1' to choose a type of file to play
#define LOAD_RGB24   1
#define LOAD_BGR24   0
#define LOAD_BGRA    0
#define LOAD_YUV420P 0

int screen_w=500,screen_h=500;
const int pixel_w = 320, pixel_h = 180;
//Bit per Pixel
#if LOAD_BGRA
const int bpp=32;
#elif LOAD_RGB24|LOAD_BGR24
const int bpp=24;
#elif LOAD_YUV420P
const int bpp=12;
#endif
//YUV file
FILE *fp = NULL;
unsigned char buffer[pixel_w*pixel_h*bpp/8];
unsigned char buffer_convert[pixel_w*pixel_h*3];

inline unsigned char CONVERT_ADJUST(double tmp)
{
    return (unsigned char)((tmp >= 0 && tmp <= 255)?tmp:(tmp < 0 ? 0 : 255));
}
//YUV420P to RGB24
void CONVERT_YUV420PtoRGB24(unsigned char* yuv_src,unsigned char* rgb_dst,int nWidth,int nHeight)
{
    unsigned char *tmpbuf=(unsigned char *)malloc(nWidth*nHeight*3);
    unsigned char Y,U,V,R,G,B;
    unsigned char* y_planar,*u_planar,*v_planar;
    int rgb_width , u_width;
    rgb_width = nWidth * 3;
    u_width = (nWidth >> 1);
    int ypSize = nWidth * nHeight;
    int upSize = (ypSize>>2);
    int offSet = 0;

    y_planar = yuv_src;
    u_planar = yuv_src + ypSize;
    v_planar = u_planar + upSize;

    for(int i = 0; i < nHeight; i++)
    {
        for(int j = 0; j < nWidth; j ++)
        {
            // Get the Y value from the y planar
            Y = *(y_planar + nWidth * i + j);
            // Get the V value from the u planar
            offSet = (i>>1) * (u_width) + (j>>1);
            V = *(u_planar + offSet);
            // Get the U value from the v planar
            U = *(v_planar + offSet);

            // Cacular the R,G,B values
            // Method 1
            R = CONVERT_ADJUST((Y + (1.4075 * (V - 128))));
            G = CONVERT_ADJUST((Y - (0.3455 * (U - 128) - 0.7169 * (V - 128))));
            B = CONVERT_ADJUST((Y + (1.7790 * (U - 128))));
            /*
            // The following formulas are from MicroSoft' MSDN
            int C,D,E;
            // Method 2
            C = Y - 16;
            D = U - 128;
            E = V - 128;
            R = CONVERT_ADJUST(( 298 * C + 409 * E + 128) >> 8);
            G = CONVERT_ADJUST(( 298 * C - 100 * D - 208 * E + 128) >> 8);
            B = CONVERT_ADJUST(( 298 * C + 516 * D + 128) >> 8);
            R = ((R - 128) * .6 + 128 )>255?255:(R - 128) * .6 + 128;
            G = ((G - 128) * .6 + 128 )>255?255:(G - 128) * .6 + 128;
            B = ((B - 128) * .6 + 128 )>255?255:(B - 128) * .6 + 128;
            */
            offSet = rgb_width * i + j * 3;

            rgb_dst[offSet] = B;
            rgb_dst[offSet + 1] = G;
            rgb_dst[offSet + 2] = R;
        }
    }
    free(tmpbuf);
}

void display(void){
    if (fread(buffer, 1, pixel_w*pixel_h*bpp/8, fp) != pixel_w*pixel_h*bpp/8){
        // Loop
        fseek(fp, 0, SEEK_SET);
        fread(buffer, 1, pixel_w*pixel_h*bpp/8, fp);
    }

    //Make picture full of window
    //Move to(-1.0,1.0)
    glRasterPos3f(-1.0f,1.0f,0);
    //Zoom, Flip
    glPixelZoom((float)screen_w/(float)pixel_w, -(float)screen_h/(float)pixel_h);



#if LOAD_BGRA
    glDrawPixels(pixel_w, pixel_h,GL_BGRA, GL_UNSIGNED_BYTE, buffer);
#elif LOAD_RGB24
    glDrawPixels(pixel_w, pixel_h,GL_RGB, GL_UNSIGNED_BYTE, buffer);
#elif LOAD_BGR24
    glDrawPixels(pixel_w, pixel_h,GL_BGR_EXT, GL_UNSIGNED_BYTE, buffer);
#elif LOAD_YUV420P
    CONVERT_YUV420PtoRGB24(buffer,buffer_convert,pixel_w,pixel_h);
    glDrawPixels(pixel_w, pixel_h,GL_RGB, GL_UNSIGNED_BYTE, buffer_convert);
#endif
    //GLUT_DOUBLE
    glutSwapBuffers();

    //GLUT_SINGLE
    //glFlush();
}

void timeFunc(int value){
    display();
    // Present frame every 40 ms
    glutTimerFunc(40, timeFunc, 0);
}



int main(int argc, char* argv[])
{
#if LOAD_BGRA
    fp=fopen("../test_bgra_320x180.rgb","rb+");
#elif LOAD_RGB24
    fp=fopen("../test_rgb24_320x180.rgb","rb+");
#elif LOAD_BGR24
    fp=fopen("../test_bgr24_320x180.rgb","rb+");
#elif LOAD_YUV420P
    fp=fopen("../test_yuv420p_320x180.yuv","rb+");
#endif
    if(fp==NULL){
        printf("Cannot open this file.\n");
        return -1;
    }

    // GLUT init
    glutInit(&argc, argv);
    //Double, Use glutSwapBuffers() to show
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB );
    //Single, Use glFlush() to show
    //glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB );

    glutInitWindowPosition(100, 100);
    glutInitWindowSize(screen_w, screen_h);
    glutCreateWindow("Simplest Video Play OpenGL");
    printf("Simplest Video Play OpenGL\n");
    printf("Lei Xiaohua\n");
    printf("http://blog.csdn.net/leixiaohua1020\n");
    printf("OpenGL Version: %s\n", glGetString(GL_VERSION));

    glutDisplayFunc(&display);
    glutTimerFunc(40, timeFunc, 0);

    // Start!
    glutMainLoop();

    return 0;
}

 

 

 

 

代碼注意事項

1.       可以通過設置定義在文件開始出的宏，決定讀取哪個格式的像素數據（bgra，rgb24，bgr24，yuv420p）。
 

//set '1' to choose a type of file to play
#define LOAD_RGB24   1
#define LOAD_BGR24   0
#define LOAD_BGRA    0
#define LOAD_YUV420P 0

 
2.       窗口的寬高為screen_w，screen_h。像素數據的寬高為pixel_w,pixel_h。它們的定義如下。
 

//Width, Height
const int screen_w=500,screen_h=500;
const int pixel_w=320,pixel_h=180;

3.       注意顯示方式的不同
BGRA，BGR24，RGB24這3種格式可以直接在glDrawPixels()中設置像素格式顯示出來。而YUV420P是不能直接顯示出來的。本文示例采用的方式是先將YUV420P轉換成RGB24，然后進行顯示。

運行結果

無論選擇加載哪個文件，運行結果都是一樣的，如下圖所示。

 

下載

代碼位於“Simplest Media Play”中
 
 

SourceForge項目地址：https://sourceforge.net/projects/simplestmediaplay/

CSDN下載地址：http://download.csdn.net/detail/leixiaohua1020/8054395

 
 

上述工程包含了使用各種API（Direct3D，OpenGL，GDI，DirectSound，SDL2）播放多媒體例子。其中音頻輸入為PCM采樣數據。輸出至系統的聲卡播放出來。視頻輸入為YUV/RGB像素數據。輸出至顯示器上的一個窗口播放出來。

通過本工程的代碼初學者可以快速學習使用這幾個API播放視頻和音頻的技術。

一共包括了如下幾個子工程：

simplest_audio_play_directsound:         使用DirectSound播放PCM音頻采樣數據。
simplest_audio_play_sdl2:                       使用SDL2播放PCM音頻采樣數據。
simplest_video_play_direct3d:                使用Direct3D的Surface播放RGB/YUV視頻像素數據。
simplest_video_play_direct3d_texture:使用Direct3D的Texture播放RGB視頻像素數據。
simplest_video_play_gdi:                          使用GDI播放RGB/YUV視頻像素數據。
simplest_video_play_opengl:                   使用OpenGL播放RGB/YUV視頻像素數據。
simplest_video_play_opengl_texture:    使用OpenGL的Texture播放YUV視頻像素數據。
simplest_video_play_sdl2:                        使用SDL2播放RGB/YUV視頻像素數據。
 

 

from:http://blog.csdn.net/leixiaohua1020/article/details/40333583