睿豐德科技 專注RFID識別技術和條碼識別技術與管理軟件的集成項目。質量追溯系統、MES系統、金蝶與條碼系統對接、用友與條碼系統對接

前一篇文章對“Simplest Media Play”工程作了概括性介紹。后續幾篇文章打算詳細介紹每個子工程中的幾種技術。在記錄Direct3D，OpenGL這兩種相對復雜的技術之前，打算先記錄一種和它們屬于同一層面的的簡單的技術——GDI作為熱身。

GDI簡介

下面這段文字摘自維基百科：

圖形設備接口（Graphics Device Interface或Graphical Device Interface，縮寫GDI），是微軟公司視窗操作系統（Microsoft Windows）的三大核心部件（另外兩個是kernel、user）之一。GDI是微軟視窗系統表征圖形對象及將其傳送給諸如顯示器、打印機之類輸出設備的標準。其他系統也有類似GDI的東西，比如Macintosh的Quartz（傳統的QuickDraw），和GTK的GDK/Xlib。
GDI用來完成一些和繪制有關的工作，像直線或曲線的繪制，文字渲染，調色板控制。它最大的好處是它有可以直接訪問硬件設備的能力。通過GDI可以非常容易的在不同類型的設備上繪制圖形，像顯示屏和打印機或類似的顯示設備。這些能力是微軟Windows系統“所見即所得”程序的核心。
簡單的不需要快速圖形渲染的游戲可能會用到GDI。但是GDI對一些高級的動畫制作無能為力，它缺少顯卡中幀的概念，還缺少3D圖形硬件光柵化的支持等等。現代的游戲通常使用DirectX和OpenGL而不是GDI，因為這些技術能更好的讓程序員利用硬件的特性來加速圖形圖像的顯示。
下面這張圖可以很好的表現GDI（以及Direct3D）在系統中的位置。可以看出它們位于應用程序和硬件之間，和Direct3D屬于同一類型的東西。

我自己在之前做的碼流分析程序《VideoEye》中的“單幀詳細分析”模塊中曾經大量使用了GDI，因為那個功能需要在窗口中繪制幀圖像，量化參數，宏塊類型，運動矢量等參數。因此對GDI這部分的函數還算熟悉。例如下圖是當時畫出的“量化參數”，“宏塊劃分”和“運動矢量”分析結果。圖中的背景圖像，數字，直線都是通過GDI畫上去的。

 

視頻像素數據

視頻顯示的輸入數據一般情況下是非壓縮的RGB/YUV數據。像H.264這些壓縮碼流是不能用于顯示的。非壓縮的RGB/YUV數據在我們電腦里并不常見，因為它的體積實在是太大了。幾秒鐘的RGB/YUV數據就有幾十MB甚至上百MB大。舉個例子，5秒分辨率為1280x720，格式為RGB24的視頻數據體積（按照每秒25幀計算）為：

1280*720*3*25*5=345600000B=345.6MB

我們日常生活中比較常見的存儲非壓縮的RGB像素數據的格式就是BMP。它的文件體（除去文件頭）中存儲的是RGB數據。很容易發現，BMP文件明顯大于JPEG等壓縮格式的文件。

本文記錄的例子的使用的是純像素數據，和BMP這種封裝過的RGB數據最大的不同在于沒有文件頭，需要使用特定的播放器，設定參數之后才能正確播放。

PS：純像素數據播放器推薦以下兩個：

YUV Player Deluxe： 只能播放YUV格式，但是確實很好使。

Vooya： 除了支持YUV之外，還支持各種各樣的RGB數據，更加強大。

視頻顯示的要點

用GDI顯示像素數據是極其簡單的，難度遠遠低于Direct3D和OpenGL。可以分成兩步：

1. 構造一張BMP。

（1） 構造文件頭
（2） 讀取像素數據

2. 調用函數畫上去。

下面分步說明：

1. 構造一張BMP

（1） 構造文件頭

構造BMP需要用到結構體BITMAPINFO，該結構體主要用于存儲BMP文件頭信息：

[cpp] view plaincopy  

1. //BMP Header  
2. BITMAPINFO m_bmphdr={0};  
3. DWORD dwBmpHdr = sizeof(BITMAPINFO);  
4. m_bmphdr.bmiHeader.biBitCount = 24;  
5. m_bmphdr.bmiHeader.biClrImportant = 0;  
6. m_bmphdr.bmiHeader.biSize = dwBmpHdr;  
7. m_bmphdr.bmiHeader.biSizeImage = 0;  
8. m_bmphdr.bmiHeader.biWidth = pixel_w;  
9. //注意BMP在y方向是反著存儲的，一次必須設置一個負值，才能使圖像正著顯示出來  
10. m_bmphdr.bmiHeader.biHeight = -pixel_h;  
11. m_bmphdr.bmiHeader.biXPelsPerMeter = 0;  
12. m_bmphdr.bmiHeader.biYPelsPerMeter = 0;  
13. m_bmphdr.bmiHeader.biClrUsed = 0;  
14. m_bmphdr.bmiHeader.biPlanes = 1;  
15. m_bmphdr.bmiHeader.biCompression = BI_RGB;  

 

從構造BMP這一步我們可以得知：像素格式必須轉換為RGB（即不能是YUV）才能使用GDI畫上去。因為BMP存儲像素是RGB格式的。

（2） 讀取像素數據

大端和小端

讀取像素數據的時候，又涉及到一個知識點：大端模式和小端模式。

假使我們直接讀取rgb24格式的一幀數據（在硬盤中的存儲方式為R1|G1|B1，R2|G2|B2，R3|G3|B3），然后顯示出來，會發現所有的人物都變成了“阿凡達”（忽然感覺這個比喻還挺形象的）：就是人的皮膚都變成了藍色了。導致這個的原因實際上是系統把“R”當成“B”，而把“B”當成“R”的結果。因此，如果我們如果把“R”和“B”的順序調換一下的話（“G”保持不變），顯示就正常了。
針對上述現象，我們可以得知BMP的RGB24格式的數據實際上是B1|G1|R1，B2|G2|R2這樣的順序存儲的。那么問題來了，為什么會這么存儲呢？這么存儲的話，豈不是把像素格式起名字叫“BGR24”更合適？下面就詳細分析一下這個問題。
首先來看一下“RGB24”這種名稱的起名規則。它們是按照“高字節->低字節”的方式起名的。即高字節存“R”，低字節存“B”。在系統中，一個像素點的像素值（RGB24則是包含R，G，B三個8Byte的數據；RGBA則包含R，G，B，A四個8Byte的數據）被認為是一個“顏色”變量（官方有正規的結構體定義：tagRGBTRIPLE，tagRGBQUAD。也是類似于int，char這樣的變量）。這種長度超過1Byte的變量（int的長度也超過了1Byte）存儲的時候就涉及到一個的問題：變量的低字節應該保存在內存的高地址還是低地址？
對于上述問題，有兩種存儲方法：
大端模式（Big Endian），是指數據的低字節（注意是整個字節）保存在內存的高地址中，而數據的高字節，保存在內存的低地址中。其實這是一個更符合人類習慣的存儲方式。
小端模式（Little Endian），是指數據的低字節保存在內存的低地址中，而數據的高字節保存在內存的高地址中。

大部分用戶的操作系統（如Windows，FreeBsd，Linux）是Little Endian的。少部分，如MAC OS是Big Endian 的。此外，網絡字節序是Big Endian的。BMP文件的存儲規定是Little Endian。因此，例如對于3Byte的RGB24變量，其低字節為“B”，而低字節應該保存在內存的低地址中，因此應該保存在最“前面”。所以RGB24格式的像素數據，在BMP文件中的存儲方式是B1|G1|R1，B2|G2|R2…

也可以看一下官方的定義：

 

[cpp] view plaincopy  

1. typedef struct tagRGBTRIPLE {  
2. BYTE rgbtBlue;  // 藍色分量  
3. BYTE rgbtGreen; // 綠色分量  
4. BYTE rgbtRed;   // 紅色分量  
5. } RGBTRIPLE;  
6.   
7. typedef struct tagRGBQUAD {  
8. BYTE rgbBlue;   // 藍色分量  
9. BYTE rgbGreen;  // 綠色分量  
10. BYTE rgbRed;    // 紅色分量  
11. BYTE rgbReserved; // 保留字節  
12. } RGBQUAD。  

 

大端和小端的轉換

大端和小端的轉換其實非常簡單，只要交換它們的字節就可以了。下面代碼列出了24bit（3字節）的數據的大端和小端之間的轉換方法。

[cpp] view plaincopy  

1. //change endian of a pixel (24bit)  
2. void CHANGE_ENDIAN_24(unsigned char *data){  
3.     char temp2=data[2];  
4.     data[2]=data[0];  
5.     data[0]=temp2;  
6. }  

 

下面代碼列出了32bit（4字節）的數據的大端和小端之間轉換的方法。

 

[cpp] view plaincopy  

1. //change endian of a pixel (32bit)  
2. void CHANGE_ENDIAN_32(unsigned char *data){  
3.     char temp3,temp2;  
4.     temp3=data[3];  
5.     temp2=data[2];  
6.     data[3]=data[0];  
7.     data[2]=data[1];  
8.     data[0]=temp3;  
9.     data[1]=temp2;  
10. }  

通過調用上述兩個函數，可以實現整張RGB（24bit或者32bit）圖片的大端與小端之間的轉換。

 

 

[cpp] view plaincopy  

1. //Change endian of a picture  
2. void CHANGE_ENDIAN_PIC(unsigned char *image,int w,int h,int bpp){  
3.     unsigned char *pixeldata=NULL;  
4.     for(int i =0;i<h;i++)  
5.         for(int j=0;j<w;j++){  
6.             pixeldata=image+(i*w+j)*bpp/8;  
7.             if(bpp==32){  
8.                 CHANGE_ENDIAN_32(pixeldata);  
9.             }else if(bpp==24){  
10.                 CHANGE_ENDIAN_24(pixeldata);  
11.             }  
12.         }  
13. }  

 

 

綜上所述，需要把輸入的rgb24格式的數據（在硬盤中的存儲方式為R1|G1|B1，R2|G2|B2，R3|G3|B3），經過大端和小端的轉換，然后調用顯示的函數，才能正確的顯示出來。
PS：當然，如果輸入是bgr24格式的數據（在硬盤中的存儲方式為B1|G1|R1，B2|G2|R2，B3|G3|R3）的話，是可以不用轉換直接正確的顯示的。但是要了解到并不是BMP硬性規定了B|G|R這樣的存儲順序。其中是有原因的。

顯示YUV420P數據

如果輸入像素格式是YUV420P的話，需要使用函數CONVERT_YUV420PtoRGB24()先將YUV420P格式數據轉換為rgb24的數據。需要注意的是轉換完的數據同樣要把“大端”轉換成“小端”才能正確的在屏幕上顯示。CONVERT_YUV420PtoRGB24()代碼要稍微復雜些，如下所示。其中提供了兩套公式用于YUV420P向rgb24轉換，效果略微有些區別，可以自己改改試試。

 

[cpp] view plaincopy  

1. inline byte CONVERT_ADJUST(double tmp)  
2. {  
3.     return (byte)((tmp >= 0 && tmp <= 255)?tmp:(tmp < 0 ? 0 : 255));  
4. }  
5. //YUV420P to RGB24  
6. void CONVERT_YUV420PtoRGB24(unsigned char* yuv_src,unsigned char* rgb_dst,int nWidth,int nHeight)  
7. {  
8.     unsigned char *tmpbuf=(unsigned char *)malloc(nWidth*nHeight*3);  
9.     unsigned char Y,U,V,R,G,B;  
10.     unsigned char* y_planar,*u_planar,*v_planar;  
11.     int rgb_width , u_width;  
12.     rgb_width = nWidth * 3;  
13.     u_width = (nWidth >> 1);  
14.     int ypSize = nWidth * nHeight;  
15.     int upSize = (ypSize>>2);  
16.     int offSet = 0;  
17.   
18.   
19.     y_planar = yuv_src;  
20.     u_planar = yuv_src + ypSize;  
21.     v_planar = u_planar + upSize;  
22.   
23.   
24.     for(int i = 0; i < nHeight; i++)  
25.     {  
26.         for(int j = 0; j < nWidth; j ++)  
27.         {  
28.             // Get the Y value from the y planar  
29.             Y = *(y_planar + nWidth * i + j);  
30.             // Get the V value from the u planar  
31.             offSet = (i>>1) * (u_width) + (j>>1);  
32.             V = *(u_planar + offSet);  
33.             // Get the U value from the v planar  
34.             U = *(v_planar + offSet);  
35.   
36.   
37.             // Cacular the R,G,B values  
38.             // Method 1  
39.             R = CONVERT_ADJUST((Y + (1.4075 * (V - 128))));  
40.             G = CONVERT_ADJUST((Y - (0.3455 * (U - 128) - 0.7169 * (V - 128))));  
41.             B = CONVERT_ADJUST((Y + (1.7790 * (U - 128))));  
42.             /* 
43.             // The following formulas are from MicroSoft' MSDN 
44.             int C,D,E; 
45.             // Method 2 
46.             C = Y - 16; 
47.             D = U - 128; 
48.             E = V - 128; 
49.             R = CONVERT_ADJUST(( 298 * C + 409 * E + 128) >> 8); 
50.             G = CONVERT_ADJUST(( 298 * C - 100 * D - 208 * E + 128) >> 8); 
51.             B = CONVERT_ADJUST(( 298 * C + 516 * D + 128) >> 8); 
52.             R = ((R - 128) * .6 + 128 )>255?255:(R - 128) * .6 + 128;  
53.             G = ((G - 128) * .6 + 128 )>255?255:(G - 128) * .6 + 128;  
54.             B = ((B - 128) * .6 + 128 )>255?255:(B - 128) * .6 + 128;  
55.             */  
56.   
57.   
58.             offSet = rgb_width * i + j * 3;  
59.   
60.   
61.             rgb_dst[offSet] = B;  
62.             rgb_dst[offSet + 1] = G;  
63.             rgb_dst[offSet + 2] = R;  
64.         }  
65.     }  
66.     free(tmpbuf);  
67. }  

 

 

2. 調用函數畫上去。

最關鍵的繪圖函數只有一個：StretchDIBits()。該函數將矩形區域內像素數據拷貝到指定的目標矩形中。如果目標矩形與源矩形大小不一樣，那么函數將會對顏色數據的行和列進行拉伸或壓縮，以與目標矩形匹配。

StretchDIBits()這個函數的參數實在是太多了一共12個。它的原型如下：

 

[cpp] view plaincopy  

1. int StretchDIBits(HDC hdc, int XDest , int YDest , int nDestWidth, int nDestHeight, int XSrc, int Ysrc, int nSrcWidth, int nSrcHeight, CONST VOID *lpBits, CONST BITMAPINFO * lpBitsInfo, UINT iUsage, DWORD dwRop);  

 

 

它的參數的意義：

hdc：指向目標設備環境的句柄。
XDest：指定目標矩形左上角位置的X軸坐標，按邏輯單位來表示坐標。
YDest：指定目標矩形左上角的Y軸坐標，按邏輯單位表示坐標。
nDestWidth：指定目標矩形的寬度。
nDestHeight：指定目標矩形的高度。
XSrc：指定DIB中源矩形（左上角）的X軸坐標，坐標以像素點表示。
YSrc：指定DIB中源矩形（左上角）的Y軸坐標，坐標以像素點表示。
nSrcWidth：按像素點指定DIB中源矩形的寬度。
nSrcHeight：按像素點指定DIB中源矩形的高度。
lpBits：指向DIB位的指針，這些位的值按字節類型數組存儲，有關更多的信息，參考下面的備注一節。
lpBitsInfo：指向BITMAPINFO結構的指針，該結構包含有關DIB方面的信息。
iUsage：表示是否提供了BITMAPINFO結構中的成員bmiColors，如果提供了，那么該bmiColors是否包含了明確的RGB值或索引。參數iUsage必須取下列值，這些值的含義如下：
DIB_PAL_COLORS：表示該數組包含對源設備環境的邏輯調色板進行索引的16位索引值。
DIB_RGB_COLORS：表示該顏色表包含原義的RGB值。
dwRop：指定源像素點、目標設備環境的當前刷子和目標像素點是如何組合形成新的圖像。

返回值：如果函數執行成功，那么返回值是拷貝的掃描線數目，如果函數執行失敗，那么返回值是GDI_ERROR。

別看StretchDIBits()那個函數看似很復雜，實際上我們只需要指定下面4個信息：源矩形，目標矩形，BMP文件頭，BMP文件數據。參考代碼如下。

[cpp] view plaincopy  

1. //將RGB數據畫在控件上  
2. int nResult = StretchDIBits(hdc,  
3.     0,0,  
4.     screen_w,screen_h,  
5.     0, 0,  
6.     pixel_w, pixel_h,  
7.     raw_buffer,  
8.     &m_bmphdr,  
9.     DIB_RGB_COLORS,  
10.     SRCCOPY);  

最后補充一句，在畫圖之前首先要獲取目標窗口的HDC（Handle of Device Context，設備上下文句柄）。在畫圖完成之后要釋放HDC。

[cpp] view plaincopy  

1. HDC hdc=GetDC(hwnd);  
2. //畫圖…  
3. ReleaseDC(hwnd,hdc);  

 

其他要點

本程序使用的是Win32的API創建的窗口。但注意這個并不是MFC應用程序的窗口。MFC代碼量太大，并不適宜用來做教程。因此使用Win32的API創建窗口。程序的入口函數是WinMain()，其中調用了CreateWindow()創建了顯示視頻的窗口。此外，程序中的消息循環使用的是PeekMessage()而不是GetMessage()。GetMessage()獲取消息后，將消息從系統中移除，當系統無消息時，會等待下一條消息，是阻塞函數。而函數PeekMesssge()是以查看的方式從系統中獲取消息，可以不將消息從系統中移除（相當于“偷看”消息），是非阻塞函數；當系統無消息時，返回FALSE，繼續執行后續代碼。使用PeekMessage()的好處是可以保證每隔40ms可以顯示下一幀畫面。

源代碼

下面貼上GDI顯示YUV/RGB的完整源代碼

 

[cpp] view plaincopy  

1. /** 
2.  * 最簡單的GDI播放視頻的例子（GDI播放RGB/YUV） 
3.  * Simplest Video Play GDI (GDI play RGB/YUV)  
4.  * 
5.  * 雷霄驊 Lei Xiaohua 
6.  * leixiaohua1020@126.com 
7.  * 中國傳媒大學/數字電視技術 
8.  * Communication University of China / Digital TV Technology 
9.  * http://blog.csdn.net/leixiaohua1020 
10.  * 
11.  * 本程序使用GDI播放RGB/YUV視頻像素數據。GDI實際上只能直接播放RGB數據。 
12.  * 因此如果輸入數據為YUV420P的話，需要先轉換為RGB數據之后再進行播放。 
13.  *  
14.  * 函數調用步驟如下： 
15.  * GetDC()：獲得顯示設備的句柄。 
16.  * 像素數據格式的轉換（如果需要的話） 
17.  * 設置BMP文件頭... 
18.  * StretchDIBits()：指定BMP文件頭，以及像素數據，繪制。 
19.  * ReleaseDC()：釋放顯示設備的句柄。 
20.  * 
21.  * 在該示例程序中，包含了像素轉換的幾個工具函數，以及“大端”， 
22.  * “小端”（字節順序）相互轉換的函數。 
23.  * 
24.  * This software plays RGB/YUV raw video data using GDI. 
25.  * In fact GDI only can draw RGB data. So If input data is 
26.  * YUV420P, it need to be convert to RGB first. 
27.  * It's the simplest GDI tutorial (About video playback). 
28.  * 
29.  * The process is shown as follows: 
30.  * 
31.  * GetDC()：retrieves a handle to a device context (DC). 
32.  * Convert pixel data format(if needed). 
33.  * Set BMP Header... 
34.  * StretchDIBits()：Set pixel data and BMP data and begin to draw. 
35.  * ReleaseDC()：release the handle. 
36.  * 
37.  * In this program there are some functions about conversion 
38.  * between pixel format and conversion between "Big Endian" and  
39.  * "Little Endian". 
40.  */  
41.   
42. #include <stdio.h>  
43. #include <tchar.h>  
44. #include <Windows.h>  
45.   
46. //set '1' to choose a type of file to play  
47. #define LOAD_BGRA    0  
48. #define LOAD_RGB24   0  
49. #define LOAD_BGR24   0  
50. #define LOAD_YUV420P 1  
51.   
52. //Width, Height  
53. const int screen_w=500,screen_h=500;  
54. const int pixel_w=320,pixel_h=180;  
55.   
56. //Bit per Pixel  
57. #if LOAD_BGRA  
58. const int bpp=32;  
59. #elif LOAD_RGB24|LOAD_BGR24  
60. const int bpp=24;  
61. #elif LOAD_YUV420P  
62. const int bpp=12;  
63. #endif  
64.   
65. FILE *fp=NULL;  
66.   
67. //Storage frame data  
68. unsigned char buffer[pixel_w*pixel_h*bpp/8];  
69.   
70. unsigned char buffer_convert[pixel_w*pixel_h*3];  
71.   
72. //Not Efficient, Just an example  
73. //change endian of a pixel (32bit)  
74. void CHANGE_ENDIAN_32(unsigned char *data){  
75.     char temp3,temp2;  
76.     temp3=data[3];  
77.     temp2=data[2];  
78.     data[3]=data[0];  
79.     data[2]=data[1];  
80.     data[0]=temp3;  
81.     data[1]=temp2;  
82. }  
83. //change endian of a pixel (24bit)  
84. void CHANGE_ENDIAN_24(unsigned char *data){  
85.     char temp2=data[2];  
86.     data[2]=data[0];  
87.     data[0]=temp2;  
88. }  
89.   
90. //RGBA to RGB24 (or BGRA to BGR24)  
91. void CONVERT_RGBA32toRGB24(unsigned char *image,int w,int h){  
92.     for(int i =0;i<h;i++)  
93.         for(int j=0;j<w;j++){  
94.             memcpy(image+(i*w+j)*3,image+(i*w+j)*4,3);  
95.         }  
96. }  
97. //RGB24 to BGR24  
98. void CONVERT_RGB24toBGR24(unsigned char *image,int w,int h){  
99.     for(int i =0;i<h;i++)  
100.         for(int j=0;j<w;j++){  
101.             char temp2;  
102.             temp2=image[(i*w+j)*3+2];  
103.             image[(i*w+j)*3+2]=image[(i*w+j)*3+0];  
104.             image[(i*w+j)*3+0]=temp2;  
105.         }  
106. }  
107.   
108. //Change endian of a picture  
109. void CHANGE_ENDIAN_PIC(unsigned char *image,int w,int h,int bpp){  
110.     unsigned char *pixeldata=NULL;  
111.     for(int i =0;i<h;i++)  
112.         for(int j=0;j<w;j++){  
113.             pixeldata=image+(i*w+j)*bpp/8;  
114.             if(bpp==32){  
115.                 CHANGE_ENDIAN_32(pixeldata);  
116.             }else if(bpp==24){  
117.                 CHANGE_ENDIAN_24(pixeldata);  
118.             }  
119.         }  
120. }  
121.   
122. inline unsigned char CONVERT_ADJUST(double tmp)  
123. {  
124.     return (unsigned char)((tmp >= 0 && tmp <= 255)?tmp:(tmp < 0 ? 0 : 255));  
125. }  
126. //YUV420P to RGB24  
127. void CONVERT_YUV420PtoRGB24(unsigned char* yuv_src,unsigned char* rgb_dst,int nWidth,int nHeight)  
128. {  
129.     unsigned char *tmpbuf=(unsigned char *)malloc(nWidth*nHeight*3);  
130.     unsigned char Y,U,V,R,G,B;  
131.     unsigned char* y_planar,*u_planar,*v_planar;  
132.     int rgb_width , u_width;  
133.     rgb_width = nWidth * 3;  
134.     u_width = (nWidth >> 1);  
135.     int ypSize = nWidth * nHeight;  
136.     int upSize = (ypSize>>2);  
137.     int offSet = 0;  
138.   
139.     y_planar = yuv_src;  
140.     u_planar = yuv_src + ypSize;  
141.     v_planar = u_planar + upSize;  
142.   
143.     for(int i = 0; i < nHeight; i++)  
144.     {  
145.         for(int j = 0; j < nWidth; j ++)  
146.         {  
147.             // Get the Y value from the y planar  
148.             Y = *(y_planar + nWidth * i + j);  
149.             // Get the V value from the u planar  
150.             offSet = (i>>1) * (u_width) + (j>>1);  
151.             V = *(u_planar + offSet);  
152.             // Get the U value from the v planar  
153.             U = *(v_planar + offSet);  
154.   
155.             // Cacular the R,G,B values  
156.             // Method 1  
157.             R = CONVERT_ADJUST((Y + (1.4075 * (V - 128))));  
158.             G = CONVERT_ADJUST((Y - (0.3455 * (U - 128) - 0.7169 * (V - 128))));  
159.             B = CONVERT_ADJUST((Y + (1.7790 * (U - 128))));  
160.             /* 
161.             // The following formulas are from MicroSoft' MSDN 
162.             int C,D,E; 
163.             // Method 2 
164.             C = Y - 16; 
165.             D = U - 128; 
166.             E = V - 128; 
167.             R = CONVERT_ADJUST(( 298 * C + 409 * E + 128) >> 8); 
168.             G = CONVERT_ADJUST(( 298 * C - 100 * D - 208 * E + 128) >> 8); 
169.             B = CONVERT_ADJUST(( 298 * C + 516 * D + 128) >> 8); 
170.             R = ((R - 128) * .6 + 128 )>255?255:(R - 128) * .6 + 128;  
171.             G = ((G - 128) * .6 + 128 )>255?255:(G - 128) * .6 + 128;  
172.             B = ((B - 128) * .6 + 128 )>255?255:(B - 128) * .6 + 128;  
173.             */  
174.   
175.             offSet = rgb_width * i + j * 3;  
176.   
177.             rgb_dst[offSet] = B;  
178.             rgb_dst[offSet + 1] = G;  
179.             rgb_dst[offSet + 2] = R;  
180.         }  
181.     }  
182.     free(tmpbuf);  
183. }  
184.   
185.   
186.   
187. bool Render(HWND hwnd)  
188. {  
189.     //Read Pixel Data  
190.     if (fread(buffer, 1, pixel_w*pixel_h*bpp/8, fp) != pixel_w*pixel_h*bpp/8){  
191.         // Loop  
192.         fseek(fp, 0, SEEK_SET);  
193.         fread(buffer, 1, pixel_w*pixel_h*bpp/8, fp);  
194.     }  
195.       
196.     HDC hdc=GetDC(hwnd);  
197.   
198.     //Note:  
199.     //Big Endian or Small Endian?  
200.     //ARGB order:high bit -> low bit.  
201.     //ARGB Format Big Endian (low address save high MSB, here is A) in memory : A|R|G|B  
202.     //ARGB Format Little Endian (low address save low MSB, here is B) in memory : B|G|R|A  
203.       
204.     //Microsoft Windows is Little Endian  
205.     //So we must change the order  
206. #if LOAD_BGRA  
207.     CONVERT_RGBA32toRGB24(buffer,pixel_w,pixel_h);  
208.     //we don't need to change endian  
209.     //Because input BGR24 pixel data(B|G|R) is same as RGB in Little Endian (B|G|R)  
210. #elif LOAD_RGB24  
211.     //Change to Little Endian  
212.     CHANGE_ENDIAN_PIC(buffer,pixel_w,pixel_h,24);  
213. #elif LOAD_BGR24  
214.     //In fact we don't need to do anything.  
215.     //Because input BGR24 pixel data(B|G|R) is same as RGB in Little Endian (B|G|R)  
216.     //CONVERT_RGB24toBGR24(buffer,pixel_w,pixel_h);  
217.     //CHANGE_ENDIAN_PIC(buffer,pixel_w,pixel_h,24);  
218. #elif LOAD_YUV420P  
219.     //YUV Need to Convert to RGB first  
220.     //YUV420P to RGB24  
221.     CONVERT_YUV420PtoRGB24(buffer,buffer_convert,pixel_w,pixel_h);  
222.     //Change to Little Endian  
223.     CHANGE_ENDIAN_PIC(buffer_convert,pixel_w,pixel_h,24);  
224. #endif  
225.   
226.     //BMP Header  
227.     BITMAPINFO m_bmphdr={0};  
228.     DWORD dwBmpHdr = sizeof(BITMAPINFO);  
229.     //24bit  
230.     m_bmphdr.bmiHeader.biBitCount = 24;  
231.     m_bmphdr.bmiHeader.biClrImportant = 0;  
232.     m_bmphdr.bmiHeader.biSize = dwBmpHdr;  
233.     m_bmphdr.bmiHeader.biSizeImage = 0;  
234.     m_bmphdr.bmiHeader.biWidth = pixel_w;  
235.     //Notice: BMP storage pixel data in opposite direction of Y-axis (from bottom to top).  
236.     //So we must set reverse biHeight to show image correctly.  
237.     m_bmphdr.bmiHeader.biHeight = -pixel_h;  
238.     m_bmphdr.bmiHeader.biXPelsPerMeter = 0;  
239.     m_bmphdr.bmiHeader.biYPelsPerMeter = 0;  
240.     m_bmphdr.bmiHeader.biClrUsed = 0;  
241.     m_bmphdr.bmiHeader.biPlanes = 1;  
242.     m_bmphdr.bmiHeader.biCompression = BI_RGB;  
243.     //Draw data  
244. #if LOAD_YUV420P  
245.     //YUV420P data convert to another buffer  
246.     int nResult = StretchDIBits(hdc,  
247.         0,0,  
248.         screen_w,screen_h,  
249.         0, 0,  
250.         pixel_w, pixel_h,  
251.         buffer_convert,  
252.         &m_bmphdr,  
253.         DIB_RGB_COLORS,  
254.         SRCCOPY);  
255. #else  
256.     //Draw data  
257.     int nResult = StretchDIBits(hdc,  
258.         0,0,  
259.         screen_w,screen_h,  
260.         0, 0,  
261.         pixel_w, pixel_h,  
262.         buffer,  
263.         &m_bmphdr,  
264.         DIB_RGB_COLORS,  
265.         SRCCOPY);  
266. #endif  
267.   
268.     ReleaseDC(hwnd,hdc);  
269.   
270.     return true;  
271. }  
272.   
273.   
274. LRESULT WINAPI MyWndProc(HWND hwnd, UINT msg, WPARAM wparma, LPARAM lparam)  
275. {  
276.     switch(msg){  
277.     case WM_DESTROY:  
278.         PostQuitMessage(0);  
279.         return 0;  
280.     }  
281.   
282.     return DefWindowProc(hwnd, msg, wparma, lparam);  
283. }  
284.   
285. int WINAPI WinMain( __in HINSTANCE hInstance, __in_opt HINSTANCE hPrevInstance, __in LPSTR lpCmdLine, __in int nShowCmd )  
286. {  
287.     WNDCLASSEX wc;  
288.     ZeroMemory(&wc, sizeof(wc));  
289.   
290.     wc.cbSize = sizeof(wc);  
291.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);  
292.     wc.lpfnWndProc = (WNDPROC)MyWndProc;  
293.     wc.lpszClassName = _T("GDI");  
294.     wc.style = CS_HREDRAW | CS_VREDRAW;  
295.   
296.     RegisterClassEx(&wc);  
297.   
298.     HWND hwnd = NULL;  
299.     hwnd = CreateWindow(_T("GDI"), _T("Simplest Video Play GDI"), WS_OVERLAPPEDWINDOW, 100, 100, 500, 500, NULL, NULL, hInstance, NULL);  
300.     if (hwnd==NULL){  
301.         return -1;  
302.     }  
303.   
304.     ShowWindow(hwnd, nShowCmd);  
305.     UpdateWindow(hwnd);  
306.   
307. #if LOAD_BGRA  
308.     fp=fopen("../test_bgra_320x180.rgb","rb+");  
309. #elif LOAD_RGB24  
310.     fp=fopen("../test_rgb24_320x180.rgb","rb+");  
311. #elif LOAD_BGR24  
312.     fp=fopen("../test_bgr24_320x180.rgb","rb+");  
313. #elif LOAD_YUV420P  
314.     fp=fopen("../test_yuv420p_320x180.yuv","rb+");  
315. #endif  
316.     if(fp==NULL){  
317.         printf("Cannot open this file.\n");  
318.         return -1;  
319.     }  
320.   
321.     MSG msg;  
322.     ZeroMemory(&msg, sizeof(msg));  
323.   
324.     while (msg.message != WM_QUIT){  
325.         //PeekMessage() is not same as GetMessage  
326.         if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)){  
327.             TranslateMessage(&msg);  
328.             DispatchMessage(&msg);  
329.         }  
330.         else{  
331.             Sleep(40);  
332.             Render(hwnd);  
333.         }  
334.     }  
335.   
336.   
337.     UnregisterClass(_T("GDI"), hInstance);  
338.     return 0;  
339. }  

 

代碼注意事項

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

 

[cpp] view plaincopy  

1. //set '1' to choose a type of file to play  
2. #define LOAD_BGRA    0  
3. #define LOAD_RGB24   0  
4. #define LOAD_BGR24   0  
5. #define LOAD_YUV420P 1  

 

 

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

 

[cpp] view plaincopy  

1. //Width, Height  
2. const int screen_w=500,screen_h=500;  
3. const int pixel_w=320,pixel_h=180;  

 

 

程序流程圖

 

程序的流程圖可以簡單概括如下所示。

結果

不論選擇讀取哪個格式的文件，程序的最終輸出效果都是一樣的，如下圖所示。

 

下載

代碼位于“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/40266503

RFID管理系統集成商 RFID中間件 條碼系統中間層 物聯網軟件集成