今天對顏色一些格式轉換有些不明白的地方，在網上找了一些文章,感謝原作者，現張貼如下：
顏色空間是一個三維座標系統，每一種顏色由一個點表示。在 RGB 顏色空間中，紅，綠，藍是基本元素。RGB 格式是顯示器通常使用的格式。在 YUV 空間中，每一個顏色有一個亮度信號 Y，和兩個色度信號 U 和 V。亮度信號是強度的感覺，它和色度信號斷開，這樣的話強度就可以在不影響顏色的情況下改變。YUV 格式通常用於 PAL制，即歐洲的電視傳輸標準，而且缺省情況下是圖像和視頻壓縮的標準。
YUV 使用RGB的信息，但它從全綵色圖像中產生一個黑白圖像，然後提取出三個主要的顏色變成兩個額外的信號來描述顏色。把這三個信號組合回來就可以產生一個全綵色圖像。
YUV 使用紅，綠，藍的點陣組合來減少信號中的信息量。Y 通道描述 Luma 信號，它與亮度信號有一點點不同，值的範圍介於亮和暗之間。 Luma 是黑白電視可以看到的信號。U (Cb) 和 V (Cr) 通道從紅 (U) 和藍 (V) 中提取亮度值來減少顏色信息量。這些值可以從新組合來決定紅，綠和藍的混合信號。
YUV和RGB的轉換:
Y = 0.299 R + 0.587 G +
0.114 B
U = -0.1687 R - 0.3313 G +
0.5 B + 128
V = 0.5 R - 0.4187 G -
0.0813 B + 128
R = Y + 1.402 (V-128) G
= Y - 0.34414 (U-128) - 0.71414 (V-128) B
= Y + 1.772 (U-128)
以前，一直沒明白yuv和YcbCr之間的差異，想必有些朋友也會有同樣的疑惑。所以，我看完之後就記載下來了。
一、和rgb之間換算公式的差異
yuv<-->rgb
Y'= 0.299*R' + 0.587*G' + 0.114*B'
U'= -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B'- Y')
V'= 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R'- Y')
R' = Y' + 1.140*V'
G' = Y' - 0.394*U' - 0.581*V'
B' = Y' + 2.032*U'
yCbCr<-->rgb
Y’ = 0.257*R' + 0.504*G' + 0.098*B' + 16
Cb' = -0.148*R' - 0.291*G' + 0.439*B' + 128
Cr' = 0.439*R' - 0.368*G' - 0.071*B' + 128
R' = 1.164*(Y’-16) + 1.596*(Cr'-128)
G' = 1.164*(Y’-16) - 0.813*(Cr'-128) - 0.392*(Cb'-128)
B' = 1.164*(Y’-16) + 2.017*(Cb'-128)
Note: 上面各個符號都帶了一撇，表示該符號在原值基礎上進行了gamma correction
二、來源上的差異
yuv色彩模型來源於rgb模型，
該模型的特點是將亮度和色度分離開，從而適合於圖像處理領域。
應用：basic color model used in analogue color TV broadcasting.
YCbCr模型來源於yuv模型。YCbCr is a scaled and offset version of the YUV color space.
應用：數字視頻，ITU-R BT.601 recommendation
ps:
通過上面的比較可以確定，我們在h.264,mpeg等編碼標準中用的yuv其實是YcbCr，大家不要被名稱搞混淆了。
人類視覺系統(HVS)相比亮度來說對於顏色不是那麼敏感的。在RGB顏色空間中，三種顏色被平等地看待，並用相同的分辨率
存放起來。但是通過把亮度與顏色信息分離，並對亮度值取更高的分辨率可以更有效地表示一個顏色圖像。
YCbCr顏色空間和它的變換(通常寫爲YUV)是一種流行而高效的表示一個顏色圖像的方法。Y是亮度值，由R,G,B的加權平均可以
得到： Y=krR + kgG + kbB
這裏k是加權因子。
顏色信號可以由不同的顏色差別來表示：
Cb = B-Y
Cr = R-Y
Cg = G-Y
對於一個顏色圖像的完整的描述由給定Y和三個色差:Cb,Cr,Cg來表示。
目前爲止，我們的表示方法好像並不那麼好，因爲相比RGB表示來說，我們這次用了四個參數。然後Cb+Cr+Cg是一個常數，那麼
我們只需要兩個色度參數就可以了，第三個可以通過其他兩個計算出來。在YCbCr空間中，只有Y和Cb,Cr值被傳輸和存儲，而且
Cb和Cr的分辨率可以比Y低，因爲人類視覺系統對於亮度更加敏感。這就減少了表示圖像的數據量。通常的觀察情況下，RGB和
YCbCr表示的圖像看上去沒有什麼不同。對於色度採用比亮度低的分辨率進行採樣是一種簡單而有效的壓縮辦法。
一個RGB圖像可以在捕捉之後轉換爲YCbCr格式用來減少存儲和傳輸負擔。在顯示圖象之前，再轉回爲RGB.注意沒有必要去指明
分別的加權值kg（因爲kb+kr+kg=1)，而且G可以從YCbCr中解壓出來，這說明不需要存儲和傳輸Cg參數。
Y = kr R + (1-kb-kr)G + kb B
Cb = 0.5/(1-kb) * (B-Y)
Cr = 0.5/(1-kr) * (R-Y)
R = Y + (1-kr)/0.5 * Cr
G = Y - 2kb(1-kb)/(1-kb-kr) * Cb - 2kr(1-kr)/(1-kb-kr) * Cr
B = Y + (1-kb)/0.5 * Cb
ITU-R的BT.601決議定義了kb=0.114,kr=0.299，那麼代換參數就有了如下等式：
Y = 0.299R + 0.587G +
0.114B
Cb = 0.564(B - Y )
Cr = 0.713(R - Y )
R = Y + 1.402Cr
G = Y - 0.344Cb - 0.714Cr
B = Y + 1.772Cb
2.4.3 YCbCr採樣格式
4:4:4採樣就是說三種元素Y,Cb,Cr有同樣的分辨率,這樣的話,在每一個像素點上都對這三種元素進行採樣.數字4是指在水平方向
上對於各種元素的採樣率,比如說,每四個亮度採樣點就有四個Cb的Cr採樣值.4:4:4採樣完整地保留了所有的信息值.4:2:2採樣中
(有時記爲YUY2),色度元素在縱向與亮度值有同樣的分辨率,而在橫向則是亮度分辨率的一半(4:2:2表示每四個亮度值就有兩個Cb
和Cr採樣.)4:2:2視頻用來構造高品質的視頻彩色信號.
在流行的4:2:0採樣格式中(常記爲YV12)Cb和Cr在水平和垂直方向上有Y分辨率的一半.4:2:0有些不同，因爲它並不是指在實際採樣
中使用4:2:0，而是在編碼史中定義這種編碼方法是用來區別於4:4:4和4:2:2方法的).4:2:0採樣被廣泛地應用於消費應用中，比如
視頻會議，數字電視和DVD存儲中。因爲每個顏色差別元素中包含了四分之一的Y採樣元素量，那麼4:2:0YCbCr視頻需要剛好4:4:4
或RGB視頻中採樣量的一半。
4:2:0採樣有時被描述是一個"每像素12位"的方法。這麼說的原因可以從對四個像素的採樣中看出.使用4:4:4採樣，一共要進行12次
採樣，對每一個Y,Cb和Cr，就需要12*8=96位，平均下來要96/4=24位。使用4:2:0就需要6*8=48位，平均每個像素48/4=12位。
在一個4:2:0隔行掃描的視頻序列中，對應於一個完整的視頻幀的Y,Cb,Cr採樣分配到兩個場中。可以得到，隔行掃描的總採樣數跟
漸進式掃描中使用的採樣數目是相同的。
2.5 視頻格式
這本書中描述的視頻壓縮標準可以壓縮很多種視頻幀格式。實際中，捕捉或轉化一箇中間格式或一系列中間格式是很平常的事情。
CIF就是一種常見的流行的格式，並由它衍生出了4CIF和Sub-QCif。幀分辨率的選擇取決於應用程序，可使用的存儲量以及傳輸帶寬
。比如說4CIF對於標準定義的電視和DVD視頻來說是合適的,CIF和QCIF在視頻會議中是常被使用的格式。QCIF和SQCIF對於移動設備
的多媒體程序來說是合適的，在這樣的情況下，顯示分辨率和碼率都是有限的。以下是各種格式的具體使用位數的需求（使用4:2:0
採樣，對於每個元素用8個位大小表示)：
格式： Sub-QCIF 亮度分辨率： 128*96 每幀使用的位: 147456
格式： QCIF 亮度分辨率： 176*144 每幀使用的位: 304128
格式： CIF 亮度分辨率： 352*288 每幀使用的位: 1216512
格式： 4CIF 亮度分辨率： 704*576 每幀使用的位: 4866048
一種在電視信號中被應用的很廣的數字視頻信號編碼格式就是ITU-R的BT.601-5 提案。亮度元素被在13.5MHz下采樣，而亮度值則
在6.75MHz下采樣，這樣就形成了一個4:2;2的Y:Cb:Cr採樣結果。採樣數字信號的參數取決於視頻碼率(對於NTSC來說是30Hz,對於
PAL/SECAM來說是25Hz)。NTSC的30Hz是對低空間分辨率的補償，這樣總的碼率就是216Mbps.實際顯示的激活部分的區域要比總量小
，因爲它去掉了在一幀邊緣處的水平和垂直空白間隔。
每一個採樣都有0-255的採樣範圍。0和255兩個等級被留作同步，而且激活的亮度信號被限制到26(黑色）到235(白色)之間.
YUV
視頻編解碼器功能
視頻編碼器要求YUV4:2:0格式的視頻輸入，因此可能根據應用需要進行視頻輸入的預處理，即對YUV4:2:2隔行掃描(例如從攝像機)到YUV 4:2:0非隔行掃描轉換，僅抽取但不過濾UV分。對視頻解碼器而言，還需要進行後處理，以將解碼的YUV 4:2:0數據轉換爲RGB進行顯示，包括：YUV 4:2:0到RGB轉換；16位或12位RGB顯示格式；0到90度旋轉，實現橫向或縱向顯示。此外，視頻編解碼器通常還要求具有以下功能和特性：
支持MPEG-4簡單類 0、1 與 2 級；
兼容H.263與 MPEG-4 編解碼標準；
MPEG-4視頻解碼器支持的可選項有：AC/DC預測、可逆可變長度編碼(RVLC)、再同步標誌(RM)、數據分割(DP)、錯誤隱藏專利技術、支持每個宏塊4個運動矢量(4MV)、自由運動補償、解碼VOS層；
MPEG-4視頻編碼器選項有：RVLC、RM、DP、支持每個宏塊4個運動矢量(4MV)、報頭擴展碼、支持編碼期間碼率改變、支持編碼期間編碼幀率改變、插入或不插入可視對象序列起始碼；
支持編碼期間序列中插入I幀；
支持編碼器自適應幀內刷新(AIR)；
支持多編解碼器，可用相同代碼運行多個編解碼器實例。
RGB
紅綠藍(RGB)是計算機顯示的基色，RGB565支持的色深可編程至高達每像素16位，即 RGB565(紅色5位，綠色6位，藍色5位)。
YCbCr
在DVD、攝像機、數字電視等消費類視頻產品中，常用的色彩編碼方案是YCbCr，其中Y是指亮度分量，Cb指藍色色度分量，而Cr指紅色色度分量。人的肉眼對視頻的Y分量更敏感，因此在通過對色度分量進行子採樣來減少色度分量後，肉眼將察覺不到的圖像質量的變化。主要的子採樣格式有 YCbCr 4:2:0、YCbCr 4:2:2 和 YCbCr 4:4:4。
4:2:0表示每4個像素有4個亮度分量，2個色度分量 (YYYYCbCr)，僅採樣奇數掃描線，是便攜式視頻設備(MPEG-4)以及電視會議(H.263)最常用格式；4：2：2表示每4個像素有4個亮度分量，4個色度分量(YYYYCbCrCbCr)，是DVD、數字電視、HDTV 以及其它消費類視頻設備的最常用格式；4：4：4表示全像素點陣(YYYYCbCrCbCrCbCrCbCr)，用於高質量視頻應用、演播室以及專業視頻產品。
小知識：RGB與YUV
計算機彩色顯示器顯示色彩的原理與彩色電視機一樣，都是採用R（Red）、G（Green）、B（Blue）相加混色的原理：通過發射出三種不同強度的電子束，使屏幕內側覆蓋的紅、綠、藍磷光材料發光而產生色彩。這種色彩的表示方法稱爲RGB色彩空間表示（它也是多媒體計算機技術中用得最多的一種色彩空間表示方法）。
根據三基色原理，任意一種色光F都可以用不同分量的R、G、B三色相加混合而成。
F = r [ R ] + g [ G ] + b [ B ]
其中，r、g、b分別爲三基色參與混合的係數。當三基色分量都爲0（最弱）時混合爲黑色光；而當三基色分量都爲k（最強）時混合爲白色光。調整r、g、b三個係數的值，可以混合出介於黑色光和白色光之間的各種各樣的色光。
那麼YUV又從何而來呢？在現代彩色電視系統中，通常採用三管彩色攝像機或彩色CCD攝像機進行攝像，然後把攝得的彩色圖像信號經分色、分別放大校正後得到 RGB，再經過矩陣變換電路得到亮度信號Y和兩個色差信號R－Y（即U）、B－Y（即V），最後發送端將亮度和色差三個信號分別進行編碼，用同一信道發送出去。這種色彩的表示方法就是所謂的YUV色彩空間表示。
採用YUV色彩空間的重要性是它的亮度信號Y和色度信號U、V是分離的。如果只有Y信號分量而沒有U、V分量，那麼這樣表示的圖像就是黑白灰度圖像。彩色電視採用YUV空間正是爲了用亮度信號Y解決彩色電視機與黑白電視機的兼容問題，使黑白電視機也能接收彩色電視信號。
YUV與RGB相互轉換的公式如下（RGB取值範圍均爲0-255）：
Y = 0.299R + 0.587G +
0.114B
U = -0.147R - 0.289G +
0.436B
V = 0.615R - 0.515G -
0.100B
R = Y + 1.14V
G = Y - 0.39U - 0.58V
B = Y + 2.03U
在DirectShow 中，常見的RGB格式有RGB1、RGB4、RGB8、RGB565、RGB555、RGB24、RGB32、ARGB32等；常見的YUV格式有 YUY2、YUYV、YVYU、UYVY、AYUV、Y41P、Y411、Y211、IF09、IYUV、YV12、YVU9、YUV411、 YUV420等。作爲視頻媒體類型的輔助說明類型（Subtype），它們對應的GUID見表2.3。
表2.3 常見的RGB和YUV格式
GUID 格式描述
MEDIASUBTYPE_RGB1 2色，每個像素用1位表示，需要調色板
MEDIASUBTYPE_RGB4 16色，每個像素用4位表示，需要調色板
MEDIASUBTYPE_RGB8 256色，每個像素用8位表示，需要調色板
MEDIASUBTYPE_RGB565 每個像素用16位表示，RGB分量分別使用5位、6位、5位
MEDIASUBTYPE_RGB555 每個像素用16位表示，RGB分量都使用5位（剩下的1位不用）
MEDIASUBTYPE_RGB24 每個像素用24位表示，RGB分量各使用8位
MEDIASUBTYPE_RGB32 每個像素用32位表示，RGB分量各使用8位（剩下的8位不用）
MEDIASUBTYPE_ARGB32 每個像素用32位表示，RGB分量各使用8位（剩下的8位用於表示Alpha通道值）
MEDIASUBTYPE_YUY2 YUY2格式，以4:2:2方式打包
MEDIASUBTYPE_YUYV YUYV格式（實際格式與YUY2相同）
MEDIASUBTYPE_YVYU YVYU格式，以4:2:2方式打包
MEDIASUBTYPE_UYVY UYVY格式，以4:2:2方式打包
MEDIASUBTYPE_AYUV 帶Alpha通道的4:4:4 YUV格式
MEDIASUBTYPE_Y41P Y41P格式，以4:1:1方式打包
MEDIASUBTYPE_Y411 Y411格式（實際格式與Y41P相同）
MEDIASUBTYPE_Y211 Y211格式
MEDIASUBTYPE_IF09 IF09格式
MEDIASUBTYPE_IYUV IYUV格式
MEDIASUBTYPE_YV12 YV12格式
MEDIASUBTYPE_YVU9 YVU9格式
下面分別介紹各種RGB格式。
¨ RGB1、RGB4、RGB8都是調色板類型的RGB格式，在描述這些媒體類型的格式細節時，通常會在BITMAPINFOHEADER數據結構後面跟着一個調色板（定義一系列顏色）。它們的圖像數據並不是真正的顏色值，而是當前像素顏色值在調色板中的索引。以RGB1（2色位圖）爲例，比如它的調色板中定義的兩種顏色值依次爲0x000000（黑色）和0xFFFFFF（白色），那麼圖像數據001101010111…（每個像素用1位表示）表示對應各像素的顏色爲：黑黑白白黑白黑白黑白白白…。
¨ RGB565使用16位表示一個像素，這16位中的5位用於R，6位用於G，5位用於B。程序中通常使用一個字（WORD，一個字等於兩個字節）來操作一個像素。當讀出一個像素後，這個字的各個位意義如下：
高字節 低字節
R R R R R G G G G G G B B B B B
可以組合使用屏蔽字和移位操作來得到RGB各分量的值：
#define RGB565_MASK_RED 0xF800
#define RGB565_MASK_GREEN 0x07E0
#define RGB565_MASK_BLUE 0x001F
R = (wPixel & RGB565_MASK_RED) >> 11; // 取值範圍0-31
G = (wPixel & RGB565_MASK_GREEN) >> 5; // 取值範圍0-63
B = wPixel &
RGB565_MASK_BLUE; // 取值範圍0-31
¨ RGB555是另一種16位的RGB格式，RGB分量都用5位表示（剩下的1位不用）。使用一個字讀出一個像素後，這個字的各個位意義如下：
高字節
低字節
X R R R R G G G G G B B B B
B （X表示不用，可以忽略）
可以組合使用屏蔽字和移位操作來得到RGB各分量的值：
#define RGB555_MASK_RED 0x7C00
#define RGB555_MASK_GREEN 0x03E0
#define RGB555_MASK_BLUE 0x001F
R = (wPixel & RGB555_MASK_RED) >> 10; // 取值範圍0-31
G = (wPixel & RGB555_MASK_GREEN) >> 5; // 取值範圍0-31
B = wPixel &
RGB555_MASK_BLUE; // 取值範圍0-31
¨ RGB24使用24位來表示一個像素，RGB分量都用8位表示，取值範圍爲0-255。注意在內存中RGB各分量的排列順序爲：BGR BGR BGR…。通常可以使用RGBTRIPLE數據結構來操作一個像素，它的定義爲：
typedef struct tagRGBTRIPLE {
BYTE rgbtBlue; // 藍色分量
BYTE rgbtGreen; // 綠色分量
BYTE rgbtRed; // 紅色分量
} RGBTRIPLE;
¨ RGB32使用32位來表示一個像素，RGB分量各用去8位，剩下的8位用作Alpha通道或者不用。（ARGB32就是帶Alpha通道的 RGB32。）注意在內存中RGB各分量的排列順序爲：BGRA BGRA BGRA…。通常可以使用RGBQUAD數據結構來操作一個像素，它的定義爲：
typedef struct tagRGBQUAD {
BYTE rgbBlue; //
藍色分量
BYTE rgbGreen; // 綠色分量
BYTE rgbRed;
// 紅色分量
BYTE rgbReserved; // 保留字節（用作Alpha通道或忽略）
} RGBQUAD;
下面介紹各種YUV格式。YUV格式通常有兩大類：打包（packed）格式和平面（planar）格式。前者將YUV分量存放在同一個數組中，通常是幾個相鄰的像素組成一個宏像素（macro-pixel）；而後者使用三個數組分開存放YUV三個分量，就像是一個三維平面一樣。表2.3中的YUY2到 Y211都是打包格式，而IF09到YVU9都是平面格式。（注意：在介紹各種具體格式時，YUV各分量都會帶有下標，如Y0、U0、V0表示第一個像素的YUV分量，Y1、U1、V1表示第二個像素的YUV分量，以此類推。）
¨ YUY2（和YUYV）格式爲每個像素保留Y分量，而UV分量在水平方向上每兩個像素採樣一次。一個宏像素爲4個字節，實際表示2個像素。（4:2:2的意思爲一個宏像素中有4個Y分量、2個U分量和2個V分量。）圖像數據中YUV分量排列順序如下：
Y0 U0 Y1 V0 Y2 U2 Y3 V2 …
¨ YVYU格式跟YUY2類似，只是圖像數據中YUV分量的排列順序有所不同：
Y0 V0 Y1 U0 Y2 V2 Y3 U2 …
¨ UYVY格式跟YUY2類似，只是圖像數據中YUV分量的排列順序有所不同：
U0 Y0 V0 Y1 U2 Y2 V2 Y3 …
¨ AYUV格式帶有一個Alpha通道，並且爲每個像素都提取YUV分量，圖像數據格式如下：
A0 Y0 U0 V0 A1 Y1 U1 V1 …
¨ Y41P（和Y411）格式爲每個像素保留Y分量，而UV分量在水平方向上每4個像素採樣一次。一個宏像素爲12個字節，實際表示8個像素。圖像數據中YUV分量排列順序如下：
U0 Y0 V0 Y1 U4 Y2 V4 Y3 Y4 Y5 Y6
Y8 …
¨ Y211格式在水平方向上Y分量每2個像素採樣一次，而UV分量每4個像素採樣一次。一個宏像素爲4個字節，實際表示4個像素。圖像數據中YUV分量排列順序如下：
Y0 U0 Y2 V0 Y4 U4 Y6 V4 …
¨ YVU9格式爲每個像素都提取Y分量，而在UV分量的提取時，首先將圖像分成若干個4 x 4的宏塊，然後每個宏塊提取一個U分量和一個V分量。圖像數據存儲時，首先是整幅圖像的Y分量數組，然後就跟着U分量數組，以及V分量數組。IF09格式與YVU9類似。
¨ IYUV格式爲每個像素都提取Y分量，而在UV分量的提取時，首先將圖像分成若干個2 x 2的宏塊，然後每個宏塊提取一個U分量和一個V分量。YV12格式與IYUV類似。
¨ YUV411、YUV420格式多見於DV數據中，前者用於NTSC制，後者用於PAL制。YUV411爲每個像素都提取Y分量，而UV分量在水平方向上每4個像素採樣一次。YUV420並非V分量採樣爲0，而是跟YUV411相比，在水平方向上提高一倍色差採樣頻率，在垂直方向上以U/V間隔的方式減小一半色差採樣，如圖2.12所示。
http://img.ogg.cn:8080/1308.jpg
YUV轉換爲RGB的公式
第一個公式是YUV轉換RGB（範圍0-255）時用的，第二個公式是用在YUV(601)也成爲YCbCr轉換RGB（範圍0-255)時用的。
1.Y = 0.299R + 0.587G + 0.114B
U = -0.147R - 0.289G
+ 0.436B
V = 0.615R - 0.515G
- 0.100B
R =
Y + 1.14V
G = Y - 0.39U - 0.58V
B = Y + 2.03U
2.B= 1.164 * (Y - 16) + 2.018 * (U - 128)
G= 1.164 * (Y - 16) - 0.38 * (U - 128) - 0.813 *
(V - 128)
R= 1.164 * (Y -
16)
+ 1.159 * (V - 128)
程序讀出來顯現的不正確,源代碼大概是這樣的:
Mywidth = 176;
Myheight = 144;
tmp = (uchar *)malloc(Mywidth * Myheight *3);
buffer = (uchar *)malloc(Mywidth * Myheight *4);
device_fd = open("/dev/video0", O_RDONLY);
static struct video_window vidwin;
vidwin.width = Mywidth;
vidwin.height = Myheight;
ioctl(device_fd, VIDIOCSWIN, &vidwin);
read(device_fd, tmp,
Mywidth*Myheight*3);
for(int i = 0; i < 176 * 144; ++i)
{
buffer[4*i] = tmp[3*i];//first bit is blue
buffer[4*i + 1] = tmp[3*i + 1];//second bit is green
buffer[4*i + 2] = tmp[3*i + 2] ;//third bit is red
buffer[4*i + 3] = 130;//forth bit
}
//後面這此是用QT庫寫的,意思是將buffer的內容轉爲image再轉爲pixmap,然後顯示出來
QImage img(buffer, Mywidth, Myheight, 32, NULL, 0, QImage::LittleEndian);
QPixmap pic;
pic.convertFromImage(img);
PixmapVideo->setPixmap(pic);
FillEllips 函數填充指定的橢圓。橢圓心爲（sx, sy），X 軸半徑爲 rx，Y 軸半徑爲 ry。
FillSector 函數填充由圓弧和兩條半徑形成的扇形。圓心爲（x, y），半徑爲 r，起始弧度爲 ang1，終止弧度爲 ang2。
FillPolygon 函數填充多邊形。pts 表示多邊形各個頂點，vertices 表示多邊形頂點個數。
FloodFill 從指定點（x, y）開始填注。
需要注意的是，所有填充函數使用當前畫刷屬性（顏色），並且受當前光柵操作的影響。
下面的例子說明了如何使用 FillCircle 和 FillEllipse 函數填充圓或者橢圓。假定給定了兩個點，pts[0] 和 pts[1]，其中 pts[0] 是圓心或者橢圓心，而 pts[1] 是圓或者橢圓外切矩形的一個頂點。
int rx = ABS (pts[1].x - pts[0].x);
int ry = ABS (pts[1].y - pts[0].y);
if (rx == ry)
FillCircle (hdc, pts[0].x, pts[0].y, rx);
else
FillEllipse (hdc, pts[0].x, pts[0].y, rx, ry);
5 建立複雜區域
除了利用填充生成器進行填充繪製以外，我們還可以使用填充生成器建立由封閉曲線包圍的複雜區域。我們知道，MiniGUI 當中的區域是由互不相交的矩形組成的，並且滿足 x-y-banned 的分佈規則。利用上述的多邊形或者封閉曲線生成器，可以將每條掃描線看成是組成區域的高度爲 1 的一個矩形，這樣，我們可以利用這些生成器建立複雜區域。MiniGUI 利用現有的封閉曲線生成器，實現瞭如下的複雜區域生成函數：
BOOL GUIAPI InitCircleRegion (PCLIPRGN dst, int x, int y, int r);
BOOL GUIAPI InitEllipseRegion (PCLIPRGN dst, int x, int y, int rx, int
ry);
BOOL GUIAPI InitPolygonRegion (PCLIPRGN dst, const POINT* pts, int
vertices);
BOOL GUIAPI InitSectorRegion (PCLIPRGN dst, const POINT* pts, int
vertices);
利用這些函數，我們可以將某個區域分別初始化爲圓、橢圓、多邊形和扇形區域。然後，可以利用這些區域進行點擊測試（PtInRegion 和 RectInRegion），或者選擇到 DC 當中作爲剪切域，從而獲得特殊顯示效果。
6 直接訪問顯示緩衝區
在新的 GDI 接口中，我們添加了用來直接訪問顯示緩衝區的函數，原型如下：
Uint8* GUIAPI LockDC (HDC hdc, const RECT* rw_rc, int* width, int* height,
int* pitch);
void GUIAPI UnlockDC (HDC hdc);
LockDC 函數鎖定給定 HDC 的指定矩形區域（由矩形 rw_rc指定，設備座標），然後返回緩衝區頭指針。當 width、height、pitch 三個指針不爲空時，該函數將返回鎖定之後的矩形有效寬度、有效高度和每掃描線所佔的字節數。
UnlockDC 函數解開已鎖定的 HDC。
鎖定一個 HDC 意味着 MiniGUI 進入以互斥方式訪問顯示緩衝區的狀態。如果被鎖定的 HDC 是一個屏幕 DC（即非內存 DC），則該函數將在必要時隱藏鼠標光標，並鎖定 HDC 對應的全局剪切域。在鎖定一個 HDC 之後，程序可通過該函數返回的指針對鎖定區域進行訪問。需要注意的是，不能長時間鎖定一個 HDC，也不應該在鎖定一個 HDC 時進行其他額外的系統調用。
假定以鎖定矩形左上角爲原點建立座標系，X 軸水平向右，Y 軸垂直向下，則可以通過如下的公式計算該座標系中（x, y）點對應的緩衝區地址（假定該函數返回的指針值爲 frame_buffer）：
Uint8* pixel_add = frame_buffer + y * (*pitch) + x * GetGDCapability
(hdc, GDCAP_BPP);
根據該 HDC 的顏色深度，就可以對該象素進行讀寫操作。作爲示例，下面的程序段隨機填充鎖定區域：
int i, width, height, pitch;
RECT rc = {0, 0, 200, 200};
int bpp = GetGDCapability (hdc, GDCAP_BPP);
Uint8* frame_buffer = LockDC (hdc, &rc, &width, &height,
&pitch);
Uint8* row = frame_buffer;
for (i = 0; i < *height; i++) {
memset (row, rand ()%0x100, *width * bpp);
row += *pitch;
}
UnlockDC (hdc);
7 YUV 覆蓋和 Gamma 校正
爲了增強 MiniGUI 對多媒體的支持，我們增加了對 YUV 覆蓋（Overlay）和 Gamma 校正的支持。
7.1 YUV 覆蓋（Overlay）
多媒體領域中，尤其在涉及到 MPEG 播放時，通常使用 YUV 顏色空間來表示顏色，如果要在屏幕上顯示一副 MPEG 解壓之後的圖片，則需要進行 YUV 顏色空間到 RGB 顏色空間的轉換。YUV 覆蓋最初來自一些顯示芯片的加速功能。這種顯示芯片能夠在硬件基礎上完成 YUV 到 RGB 的轉換，免去軟件轉換帶來的性能損失。在這種顯示芯片上建立了 YUV 覆蓋之後，可以直接將 YUV 信息寫入緩衝區，硬件能夠自動完成 YUV 到 RGB 的轉換，從而在 RGB 顯示器上顯示出來。在不支持 YUV 覆蓋的顯示芯片上，MiniGUI 也能夠通過軟件實現 YUV 覆蓋，這時，需要調用 DisplayYUVOverlay 函數將 YUV 信息轉換並縮放顯示在建立 YUV 覆蓋的 DC 設備上。
MiniGUI 提供的 YUV 覆蓋操作函數原型如下：
/***************************** YUV overlay support
***************************/
/* 最常見的視頻覆蓋格式.
*/
#define GAL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U (3 planes) */
#define GAL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V (3 planes) */
#define GAL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
#define GAL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 (1 plane) */
#define GAL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 (1 plane) */
/* 該函數創建一個視頻輸出覆蓋
*/
GAL_Overlay* GUIAPI CreateYUVOverlay (int width, int height,
Uint32 format, HDC hdc);
/* 鎖定覆蓋進行直接的緩衝區讀寫，結束後解鎖 */
int GAL_LockYUVOverlay (GAL_Overlay *overlay);
void GAL_UnlockYUVOverlay (GAL_Overlay *overlay);
#define LockYUVOverlay GAL_LockYUVOverlay
#define UnlockYUVOverlay GAL_UnlockYUVOverlay
/* 釋放視頻覆蓋 */
void GAL_FreeYUVOverlay (GAL_Overlay *overlay);
#define FreeYUVOverlay GAL_FreeYUVOverlay
/* 將視頻覆蓋傳送到指定 DC 設備上。該函數能夠進行 2 維縮放
*/
void GUIAPI DisplayYUVOverlay (GAL_Overlay* overlay, const RECT* dstrect);
有關視頻格式的信息，可參見：
http://www.webartz.com/fourcc/indexyuv.htm
有關顏色空間的相互關係的息，可參見：
http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
7.2 Gamma 校正
Gamma 校正通過爲 RGB 顏色空間的每個顏色通道設置 Gamma 因子，來動態調整 RGB 顯示器上的實際 RGB 效果。需要注意的是，Gamma 校正需要顯示芯片的硬件支持。
應用程序可以通過 SetGamma 函數設置 RGB 三個顏色通道的 Gamma 校正值。該函數原型如下：
int GAL_SetGamma (float red, float green, float blue);
#define SetGamma GAL_SetGamma
線性 Gamma 校正值的範圍在 0.1 到 10.0 之間。如果硬件不支持 Gamma 校正，該函數將返回 -1。
應用程序也可以通過 SetGammaRamp 函數設置 RGB 三個顏色通道的非線性 Gamma 校正值。該函數原型如下：
int GAL_SetGammaRamp (Uint16 *red, Uint16 *green, Uint16 *blue);
#define SetGammaRamp GAL_SetGammaRamp
int GAL_GetGammaRamp (Uint16 *red, Uint16 *green, Uint16 *blue);
#define GetGammaRamp GAL_GetGammaRamp
函數 SetGammaRamp 實際設置的是每個顏色通道的 Gamma 轉換表，每個表由 256 個值組成，表示設置值和實際值之間的對應關係。當設置屏幕上某個象素的 RGB 分別爲 R、G、B 時，實際在顯示器上獲得的象素 RGB 值分別爲：red[R]、green[G]、blue[B]。如果硬件不支持 Gamma 校正，該函數將返回 -1。
函數 GetGammaRamp 獲得當前的 Gamma 轉換表。
Gamma 校正的最初目的，是爲了能夠在顯示器上精確還原一副圖片。Gamma 值在某種程度上表示的是某個顏色通道的對比度變化。但 Gamma 在多媒體和遊戲程序中有一些特殊用途――通過 Gamma 校正，可以方便地獲得對比度漸進效果。
8 小結
本文描述了自 MiniGUI 1.1.0Pre4 版本發佈以來新增的 GDI 接口。這些接口涉及到曲線和填充生成器、複雜曲線的繪製、封閉曲線填充、複雜區域的創建、直接訪問 FrameBuffer、YUV 覆蓋和 Gamma 校正等等。通過本文的介紹，相信讀者能夠對 MiniGUI 的新 GDI 接口有一個更加全面的認識。
Content
1.驅動
2.應用程序書寫
1.驅動
Linux-2.4.18默認帶有ov511攝像頭的驅動，在USB設備中選中，並激活video選項，即可對ov511支持。
2.應用程序書寫
這是一個在MiniGui下的程序，可以用QVFB模擬，可以可以在板子上跑，效果還可以。
v4l.h
/*
* w3v4l.h
*
* Copyright (C) 1998 - 2000 Rasca, Berlin
* EMail: [email protected]
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __W3V4L_H__
#define __W3V4L_H__
class CV4L{
public:
CV4L();
CV4L(char *szDevName);
~CV4L();
bool init(int channel, int width, int
height);
unsigned char *Read();
void destroy();
private:
char *szDevName;
bool initialized;
unsigned char *m_Buff;
int m_BuffSize;
int fdVideo;
int m_Width, m_Height;
int m_MapSize;
};
#endif
v4l.cpp
/*
* v4l.c
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/types.h>
#include <string.h>
#include <linux/videodev.h>
#include "v4l.h"
/* v4l_init()
* function: init the video device
* references:
* dev: device name.
* input: channel number of video_channel structure.
* width: width value of video_window structure
* height: height value of video_window structure
*/
bool CV4L::init(int
channel, int width, int height)
{
int fd;
struct video_capability vid_caps;
struct video_mbuf vid_mbuf;
struct video_channel vid_chnl;
// open the video device
fd = open (szDevName, O_RDWR);
if (fd == -1) {
perror (szDevName);
return false;
}
fdVideo = fd;
// get video_capability structrue
if (ioctl (fd, VIDIOCGCAP, &vid_caps) == -1) {
perror ("ioctl (VIDIOCGCAP)");
return false;
}
// get the buffer information in video_mbuf
structure
// if can't use mmap()
if (ioctl (fd, VIDIOCGMBUF, &vid_mbuf) == -1) {
struct video_window vid_win;
m_MapSize = 0;
// set video window information
if (ioctl(fd, VIDIOCGWIN, &vid_win) != -1) {
vid_win.width = width;
vid_win.height= height;
ioctl (fd, VIDIOCSWIN, &vid_win);
}
} else {
m_MapSize = vid_mbuf.size;
m_BuffSize = m_MapSize;
}
#ifdef DEBUG
printf ("%s: mbuf.size=%d/n", __FILE__, vid_mbuf.size);
#endif
if (channel > -1) {
vid_chnl.channel = channel;
if (ioctl (fd, VIDIOCGCHAN, &vid_chnl) == -1) {
perror ("ioctl (VIDIOCGCHAN)");
} else {
vid_chnl.channel = channel;
if (ioctl (fd, VIDIOCSCHAN, &vid_chnl) == -1) {
perror ("ioctl (VIDIOCSCHAN)");
}
}
}
if (m_MapSize > 0) {
m_Buff = (unsigned char *)mmap (0,m_MapSize,
PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
if ((unsigned char *) -1 == (unsigned char *)m_Buff) {
perror ("mmap()");
close (fd);
return false;
}
} else {
m_BuffSize = width * height * 3;
m_Buff = (unsigned char *)malloc (m_BuffSize);
}
m_Width = width;
m_Height = height;
return true;
}
unsigned char
*CV4L::Read()
{
struct video_mmap vid_mmap;
if (m_MapSize == 0) {
printf (__FILE__": reading image .. /n");
if (read (fdVideo, (void *)m_Buff, m_BuffSize) <= 0) {
free (m_Buff);
return (0);
}
} else {
vid_mmap.format = VIDEO_PALETTE_RGB565; //VIDEO_PALETTE_RGB24;
vid_mmap.frame = 0;
vid_mmap.width = m_Width;
vid_mmap.height= m_Height;
if (ioctl (fdVideo, VIDIOCMCAPTURE, &vid_mmap) == -1) {
perror ("ioctl (VIDIOCMCAPTURE)");
return (0);
}
if (ioctl (fdVideo, VIDIOCSYNC, &vid_mmap) == -1) {
perror ("ioctl (VIDIOCSYNC)");
return (0);
}
}
return m_Buff;
}
void CV4L::destroy()
{
if (fdVideo >= 0) {
if (m_MapSize == 0)
free (m_Buff);
else
munmap (m_Buff, m_MapSize);
close (fdVideo);
}
}
CV4L::CV4L()
{
//
}
CV4L::CV4L(char *_szDevName)
{
szDevName = (char *)malloc(strlen(_szDevName)+1);
strcpy(szDevName, _szDevName);
//init(0, int width, int height);
//
}
CV4L::~CV4L()
{
destroy();
}
video.cpp
/*
** $Id: helloworld.c,v 1.7 2003/06/13 07:15:49 weiym Exp $
**
** Listing 2.1
**
** helloworld.c: Sample program for MiniGUI Programming Guide
** The first MiniGUI application.
**
** Copyright (C) 2003 Feynman Software.
**
** License: GPL
*/
#include <stdio.h>
#include <minigui/common.h>
#include <minigui/minigui.h>
#include <minigui/gdi.h>
#include <minigui/window.h>
#include <string.h>
#include <malloc.h>
#include "v4l.h"
#define VID_W 320
#define VID_H 240
static BITMAP bmp;
CV4L
*cVid; //"/dev/video0"
unsigned char *buf;
static int count = 0;
static int xdir = -3;
static int ydir = -3;
static int x = 1;
static int y = 11;
/*bool SwitchBuf24ToBmp16(unsigned char
*buf24, PBITMAP pBmp)
{
myBmp.bits = buf24;
//ExpandMyBitmap (HDC_SCREEN, &bmp, &myBmp, rgb, 0);
printf ("bmp.bmType = %i/n",
bmp.bmType);
printf ("bmp.bmBitsPerPixel = %i/n", bmp.bmBitsPerPixel);
printf ("bmp.bmBytesPerPixel = %i/n", bmp.bmBytesPerPixel);
printf ("bmp.bmAlpha = %i/n", bmp.bmAlpha);
printf ("bmp.bmColorKey = %i/n", bmp.bmColorKey);
printf ("bmp.bmWidth = %i/n", bmp.bmWidth);
printf ("bmp.bmHeight = %i/n", bmp.bmHeight);
printf ("bmp.bmPitch = %i/n", bmp.bmPitch);
printf ("bmp.bmBits = %i/n", bmp.bmBits);
printf ("bmp.bmAlphaPixelFormat = %i/n", bmp.bmAlphaPixelFormat);
return true;
}*/
void FillBitmap(BITMAP *bmp)
{
bmp->bmType = 0;
bmp->bmBitsPerPixel = 16;
bmp->bmBytesPerPixel = 2;
bmp->bmAlpha = 0;
bmp->bmColorKey = 0;
bmp->bmWidth = VID_W;
bmp->bmHeight = VID_H;
bmp->bmPitch = VID_W*2;
bmp->bmBits = NULL;
bmp->bmAlphaPixelFormat = NULL;
}
void FillMyBitmap(PMYBITMAP my_bmp)
{
my_bmp->flags = MYBMP_RGBSIZE_3 | MYBMP_TYPE_BGR | MYBMP_FLOW_DOWN;
my_bmp->frames = 1;
my_bmp->depth = 24;
my_bmp->alpha = 0;
my_bmp->reserved[0] = 0;
my_bmp->reserved[1] = 0;
my_bmp->transparent = 0;
my_bmp->w = 240;
my_bmp->h = 180;
my_bmp->pitch = 240*3;
my_bmp->size = 240*180*3;
my_bmp->bits = NULL;
}
static int HelloWinProc(HWND hWnd, int
message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
RECT rc;
switch (message) {
case MSG_PAINT:
hdc = BeginPaint
(hWnd);
if (bmp.bmBits)
FillBoxWithBitmap (hdc, 0, 0, bmp.bmWidth, bmp.bmHeight, &bmp);
SetBkColor (hdc, RGB2Pixel (hdc, 0xFF, 0xFF, 0xFF));
SetBkMode (hdc,
BM_TRANSPARENT);
SetTextColor (hdc,
RGB2Pixel (hdc, 0xFF, 0x00, 0x00));
rc.left = 0;
rc.top = 0;
rc.right = 300;
rc.bottom = 60;
TextOut (hdc, 0,
0, "??????");
if (x >= VID_W || x <=0)
{
xdir = 0 - xdir;
}
if (y >= VID_W || y <=10)
{
ydir = 0 - ydir;
}
x += xdir;
y += ydir;
TextOut (hdc, x, y, "kdf");
Rectangle (hdc, 0,
0, bmp.bmWidth, bmp.bmHeight);
/*FillBoxWithBitmap (hdc, 100, 0, 200, 200, &bmp);
Rectangle (hdc,
100, 0, 300, 200);
FillBoxWithBitmapPart (hdc, 0, 200, 400, 200, 0, 0, &bmp, 10, 10);
Rectangle (hdc, 0,
200, 400, 400);*/
EndPaint (hWnd, hdc);
return 0;
case
MSG_CREATE:
/*if (LoadBitmap
(HDC_SCREEN, &bmp, "bkgnd.bmp"))
return -1;*/
return 0;
case
MSG_CLOSE:
UnloadBitmap
(&bmp);
DestroyMainWindow
(hWnd);
PostQuitMessage
(hWnd);
return 0;
}
return DefaultMainWinProc(hWnd,
message, wParam, lParam);
}
int MiniGUIMain (int argc, const char*
argv[])
{
MSG Msg;
HWND hMainWnd;
MAINWINCREATE CreateInfo;
#ifdef _LITE_VERSION
SetDesktopRect(0, 0, 1024, 768);
#endif
CreateInfo.dwStyle = WS_VISIBLE
| WS_BORDER | WS_CAPTION;
CreateInfo.dwExStyle = WS_EX_NONE;
CreateInfo.spCaption = "Hello, world";
CreateInfo.hMenu = 0;
CreateInfo.hCursor = GetSystemCursor(0);
CreateInfo.hIcon = 0;
CreateInfo.MainWindowProc = HelloWinProc;
CreateInfo.lx = 0;
CreateInfo.ty = 0;
CreateInfo.rx = VID_W;
CreateInfo.by = VID_H;
CreateInfo.iBkColor = COLOR_lightwhite;
CreateInfo.dwAddData = 0;
CreateInfo.hHosting = HWND_DESKTOP;
hMainWnd = CreateMainWindow (&CreateInfo);
if (hMainWnd == HWND_INVALID)
return -1;
ShowWindow(hMainWnd, SW_SHOWNORMAL);
//////////////////////////////////////////////////////////////
// 1. Create my video class CV4L.
cVid = new CV4L("/dev/video0");
//////////////////////////////////////////////////////////////
// 2. Init the video device with channel and map size.
if (cVid->init(0, VID_W, VID_H) == false)
return -1;
//FillMyBitmap(&myBmp);
FillBitmap(&bmp);
//////////////////////////////////////////////////////////////
// 3. Read the data from video device.
if (buf = cVid->Read ())
{
bmp.bmBits = buf;
//InvalidateRect ();
SendMessage (hMainWnd, MSG_PAINT, 0, 0);
}
while (true)
{
if (!HavePendingMessage (hMainWnd))
{
if (!GetMessage
(&Msg, hMainWnd))
break;
TranslateMessage
(&Msg);
DispatchMessage
(&Msg);
} else {
//////////////////////////////////////////////////////////////
// 3. Read the
data from video device.
if (buf =
cVid->Read ())
{
bmp.bmBits = buf;
SendMessage (hMainWnd, MSG_PAINT, 0, 0);
} else {
// if Buffer is Null, vedeo device have pluged out.
PostQuitMessage (hMainWnd);
} /* end of read
video buffer */
} /* end of HavePendingMessage() */
} /* end of while */
//////////////////////////////////////////////////////////////
// 4. destroy the CV4L
class, and release resources.
cVid->destroy ();
UnloadBitmap (&bmp);
//free (bmp.bmBits);
MainWindowThreadCleanup (hMainWnd);
return 0;
}
#ifndef _LITE_VERSION
#include <minigui/dti.c>
#endif
把這些代碼添加到miniugi-1.3.3的helloworld程序中去編譯一下就可以了，也可以用如下命令
g++ -o video -I/minigui/include -L/minigui/lib video.cpp v4l.cpp
