RGB 24和YUY2相互转换

 

YUY2经常用于电视制式以及许多摄像头的输出格式.而我们在处理时经常需要将其转化为RGB进行处理,这里简单介绍下YUY2(YUV)与RGB之间相互转化的关系:

http://msdn2.microsoft.com/en-us/library/ms893078.aspx

 

YUY2(YUV) To RGB:

C = Y - 16

D = U - 128

E = V - 128

R = clip(( 298 * C + 409 * E + 128) >> 8)
G = clip(( 298 * C - 100 * D - 208 * E + 128) >> 8)
B = clip(( 298 * C + 516 * D + 128) >> 8)

其中 clip()为限制函数,将其取值限制在0-255之间.

 

RGB To YUY2(YUV):

Y = ( ( 66 * R + 129 * G + 25 * B + 128) >> 8) + 16
U = ( ( -38 * R - 74 * G + 112 * B + 128) >> 8) + 128
V = ( ( 112 * R - 94 * G - 18 * B + 128) >> 8) + 128

上述两个公式在代码中的
int YUV2RGB(void* pYUV, void* pRGB, int width, int height, bool alphaYUV, bool alphaRGB);
int RGB2YUV(void* pRGB, void* pYUVX, int width, int height, bool alphaYUV, bool alphaRGB);
函数中转换。

在诸如摄像头的数据获取中,我们往往需要直接在YUY2(YUV)空间上进行一些图象处理,我们希望能够在YUY2
(YUV)进行一些RGB上可以做到的处理。这里已blending为例,将两张带有透明度的YUY2(YUV)图片进行叠加,
以达到在RGB空间进行图像合成的效果。

RGB空间进行图像叠加,通常背景(BG)是不透明的,而前景(FG)是带有透明度的。在RGB空间,可以简单表示为:
Rdest = Rfg*alpha + Rbg*(1-alpha);
Gdest = Gfg*alpha + Gbg*(1-alpha);
Bdest = Bfg*alpha + Bbg*(1-alpha);
// Rdest、Gdest、Bdest 为最终合成后的像素值

考虑到
Y = ( ( 66 * R + 129 * G + 25 * B + 128) >> 8) + 16
U = ( ( -38 * R - 74 * G + 112 * B + 128) >> 8) + 128
V = ( ( 112 * R - 94 * G - 18 * B + 128) >> 8) + 128
我们可以推导出

(Ydest-16)<<8 = ((Yfg-16)<<8)*alpha + ((Ybg-16)<<8)*(1-alpha);
(Udest-128)<<8 = ((Ufg-128)<<8)*alpha + ((Ubg-128)<<8)*(1-alpha);
(Vdest-128)<<8 = ((Vfg-128)<<8)*alpha + ((Vbg-128)<<8)*(1-alpha);

从而可以得到
Ydest = (Yfg-16)*alpha + (Ybg-16)*(1-alpha) + 16;
Udest = (Ufg-128)*alpha + (Ubg-128)*(1-alpha) + 128;
Vdest = (Vfg-128)*alpha + (Vbg-128)*(1-alpha) + 128;

这个叠加过程在函数
int YUVBlending(void* pBGYUV, void* pFGYUV, int width, int height, bool alphaBG, bool alphaFG)
中实现。

由于本文针对摄像头采集所得的数据进行处理,因此数据为YUY2格式,即4个字节来表示两个像素点的YUV信息,
排列为Y1 U1 Y2 V2, 对于像素点1为(Y1, U1, V1),像素点2为(Y2, U1, V1)。即两个像素点共用U、V信息。

这里假设带有alpha透明度的YUV格式用6个字节来表示两个像素点的YUV以及alpha信息,排列为 Y1 U1 Y2 V1 alpha1 alpha2
其中像素点1为(Y1, U1, V1, alpha1),像素点2为(Y2, U1, V1, alpha2)。其中alpha为对应点的透明度信息。

而带有alpha透明度RGB格式的图片,假设为32bits的BMP图片,每个像素点用4bytes来表示,分别为B G R alpha信息。

上述函数的具体实现为:
  1. //////////////////////////////////////////////////////////////////////////   
  2. // YUV2RGB   
  3. // pYUV         point to the YUV data   
  4. // pRGB         point to the RGB data   
  5. // width        width of the picture   
  6. // height       height of the picture   
  7. // alphaYUV     is there an alpha channel in YUV   
  8. // alphaRGB     is there an alpha channel in RGB   
  9. //////////////////////////////////////////////////////////////////////////   
  10. int YUV2RGB(void* pYUV, void* pRGB, int width, int height, bool alphaYUV, bool alphaRGB)  
  11. {  
  12.     if (NULL == pYUV)  
  13.     {  
  14.         return -1;  
  15.     }  
  16.     unsigned char* pYUVData = (unsigned char *)pYUV;  
  17.     unsigned char* pRGBData = (unsigned char *)pRGB;  
  18.     if (NULL == pRGBData)  
  19.     {  
  20.         if (alphaRGB)  
  21.         {  
  22.             pRGBData = new unsigned char[width*height*4];  
  23.         }  
  24.         else  
  25.             pRGBData = new unsigned char[width*height*3];  
  26.     }  
  27.     int Y1, U1, V1, Y2, alpha1, alpha2, R1, G1, B1, R2, G2, B2;  
  28.     int C1, D1, E1, C2;  
  29.     if (alphaRGB)  
  30.     {  
  31.         if (alphaYUV)  
  32.         {  
  33.             for (int i=0; i<height; ++i)  
  34.             {  
  35.                 for (int j=0; j<width/2; ++j)  
  36.                 {  
  37.                     Y1 = *(pYUVData+i*width*3+j*6);  
  38.                     U1 = *(pYUVData+i*width*3+j*6+1);  
  39.                     Y2 = *(pYUVData+i*width*3+j*6+2);  
  40.                     V1 = *(pYUVData+i*width*3+j*6+3);  
  41.                     alpha1 = *(pYUVData+i*width*3+j*6+4);  
  42.                     alpha2 = *(pYUVData+i*width*3+j*6+5);  
  43.                     C1 = Y1-16;  
  44.                     C2 = Y2-16;  
  45.                     D1 = U1-128;  
  46.                     E1 = V1-128;  
  47.                     R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
  48.                     G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
  49.                     B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
  50.                     R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
  51.                     G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
  52.                     B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
  53.                     *(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;  
  54.                     *(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;  
  55.                     *(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;  
  56.                     *(pRGBData+(height-i-1)*width*4+j*8+3) = alpha1;      
  57.                     *(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;  
  58.                     *(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;  
  59.                     *(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;  
  60.                     *(pRGBData+(height-i-1)*width*4+j*8+7) = alpha2;      
  61.                 }  
  62.             }     
  63.         }  
  64.         else  
  65.         {  
  66.             int alpha = 255;  
  67.             for (int i=0; i<height; ++i)  
  68.             {  
  69.                 for (int j=0; j<width/2; ++j)  
  70.                 {  
  71.                     Y1 = *(pYUVData+i*width*2+j*4);  
  72.                     U1 = *(pYUVData+i*width*2+j*4+1);  
  73.                     Y2 = *(pYUVData+i*width*2+j*4+2);  
  74.                     V1 = *(pYUVData+i*width*2+j*4+3);  
  75.                     C1 = Y1-16;  
  76.                     C2 = Y2-16;  
  77.                     D1 = U1-128;  
  78.                     E1 = V1-128;  
  79.                     R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
  80.                     G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
  81.                     B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
  82.                     R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
  83.                     G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
  84.                     B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
  85.                     *(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;  
  86.                     *(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;  
  87.                     *(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;  
  88.                     *(pRGBData+(height-i-1)*width*4+j*8+3) = alpha;   
  89.                     *(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;  
  90.                     *(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;  
  91.                     *(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;  
  92.                     *(pRGBData+(height-i-1)*width*4+j*8+7) = alpha;   
  93.                 }  
  94.             }     
  95.         }  
  96.     }  
  97.     else  
  98.     {  
  99.         if (alphaYUV)  
  100.         {  
  101.             for (int i=0; i<height; ++i)  
  102.             {  
  103.                 for (int j=0; j<width/2; ++j)  
  104.                 {  
  105.                     Y1 = *(pYUVData+i*width*3+j*4);  
  106.                     U1 = *(pYUVData+i*width*3+j*4+1);  
  107.                     Y2 = *(pYUVData+i*width*3+j*4+2);  
  108.                     V1 = *(pYUVData+i*width*3+j*4+3);  
  109.                     C1 = Y1-16;  
  110.                     C2 = Y2-16;  
  111.                     D1 = U1-128;  
  112.                     E1 = V1-128;  
  113.                     R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
  114.                     G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
  115.                     B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
  116.                     R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
  117.                     G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
  118.                     B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
  119.                     *(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;  
  120.                     *(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;  
  121.                     *(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;  
  122.                     *(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;  
  123.                     *(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;  
  124.                     *(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;  
  125.                 }  
  126.             }  
  127.         }  
  128.         else  
  129.         {  
  130.             for (int i=0; i<height; ++i)  
  131.             {  
  132.                 for (int j=0; j<width/2; ++j)  
  133.                 {  
  134.                     Y1 = *(pYUVData+i*width*2+j*4);  
  135.                     U1 = *(pYUVData+i*width*2+j*4+1);  
  136.                     Y2 = *(pYUVData+i*width*2+j*4+2);  
  137.                     V1 = *(pYUVData+i*width*2+j*4+3);  
  138.                     C1 = Y1-16;  
  139.                     C2 = Y2-16;  
  140.                     D1 = U1-128;  
  141.                     E1 = V1-128;  
  142.                     R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
  143.                     G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
  144.                     B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
  145.                     R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
  146.                     G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
  147.                     B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
  148.                     *(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;  
  149.                     *(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;  
  150.                     *(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;  
  151.                     *(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;  
  152.                     *(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;  
  153.                     *(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;  
  154.                 }  
  155.             }     
  156.         }  
  157.     }  
  158.     return 0;  
  159. }  
  160.   
  161. //////////////////////////////////////////////////////////////////////////   
  162. // RGB2YUV   
  163. // pRGB         point to the RGB data   
  164. // pYUV         point to the YUV data   
  165. // width        width of the picture   
  166. // height       height of the picture   
  167. // alphaYUV     is there an alpha channel in YUV   
  168. // alphaRGB     is there an alpha channel in RGB   
  169. //////////////////////////////////////////////////////////////////////////   
  170. int RGB2YUV(void* pRGB, void* pYUV, int width, int height, bool alphaYUV, bool alphaRGB)  
  171. {  
  172.     if (NULL == pRGB)  
  173.     {  
  174.         return -1;  
  175.     }  
  176.     unsigned char* pRGBData = (unsigned char *)pRGB;  
  177.     unsigned char* pYUVData = (unsigned char *)pYUV;  
  178.     if (NULL == pYUVData)  
  179.     {  
  180.         if (alphaYUV)  
  181.         {  
  182.             pYUVData = new unsigned char[width*height*3];  
  183.         }  
  184.         else  
  185.             pYUVData = new unsigned char[width*height*2];  
  186.     }  
  187.     int R1, G1, B1, R2, G2, B2, Y1, U1, Y2, V1;  
  188.     int alpha1, alpha2;  
  189.     if (alphaYUV)  
  190.     {  
  191.         if (alphaRGB)  
  192.         {  
  193.             for (int i=0; i<height; ++i)  
  194.             {  
  195.                 for (int j=0; j<width/2; ++j)  
  196.                 {  
  197.                     B1 = *(pRGBData+(height-i-1)*width*4+j*8);  
  198.                     G1 = *(pRGBData+(height-i-1)*width*4+j*8+1);  
  199.                     R1 = *(pRGBData+(height-i-1)*width*4+j*8+2);  
  200.                     alpha1 = *(pRGBData+(height-i-1)*width*4+j*8+3);  
  201.                     B2 = *(pRGBData+(height-i-1)*width*4+j*8+4);  
  202.                     G2 = *(pRGBData+(height-i-1)*width*4+j*8+5);  
  203.                     R2 = *(pRGBData+(height-i-1)*width*4+j*8+6);  
  204.                     alpha2 = *(pRGBData+(height-i-1)*width*4+j*8+7);  
  205.                     Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);  
  206.                     U1 = ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128)>255 ? 255 : ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128);  
  207.                     Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;  
  208.                     V1 = ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128)>255 ? 255 : ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128);  
  209.                     *(pYUVData+i*width*3+j*6) = Y1;  
  210.                     *(pYUVData+i*width*3+j*6+1) = U1;  
  211.                     *(pYUVData+i*width*3+j*6+2) = Y2;  
  212.                     *(pYUVData+i*width*3+j*6+3) = V1;  
  213.                     *(pYUVData+i*width*3+j*6+4) = alpha1;  
  214.                     *(pYUVData+i*width*3+j*6+5) = alpha2;  
  215.                 }  
  216.             }     
  217.         }  
  218.         else  
  219.         {  
  220.             unsigned char alpha = 255;  
  221.             for (int i=0; i<height; ++i)  
  222.             {  
  223.                 for (int j=0; j<width/2; ++j)  
  224.                 {  
  225.                     B1 = *(pRGBData+(height-i-1)*width*3+j*6);  
  226.                     G1 = *(pRGBData+(height-i-1)*width*3+j*6+1);  
  227.                     R1 = *(pRGBData+(height-i-1)*width*3+j*6+2);  
  228.                     B2 = *(pRGBData+(height-i-1)*width*3+j*6+3);  
  229.                     G2 = *(pRGBData+(height-i-1)*width*3+j*6+4);  
  230.                     R2 = *(pRGBData+(height-i-1)*width*3+j*6+5);  
  231.                     Y1 = ((66*R1+129*G1+25*B1+128)>>8) + 16;  
  232.                     U1 = ((-38*R1-74*G1+112*B1+128)>>8+(-38*R2-74*G2+112*B2+128)>>8)/2 + 128;  
  233.                     Y2 = ((66*R2+129*G2+25*B2+128)>>8) + 16;  
  234.                     V1 = ((112*R1-94*G1-18*B1+128)>>8 + (112*R2-94*G2-18*B2+128)>>8)/2 + 128;  
  235.                     Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);  
  236.                     U1 = ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128)>255 ? 255 : ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128);  
  237.                     Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;  
  238.                     V1 = ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128)>255 ? 255 : ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128);  
  239.                     *(pYUVData+i*width*3+j*6) = Y1;  
  240.                     *(pYUVData+i*width*3+j*6+1) = U1;  
  241.                     *(pYUVData+i*width*3+j*6+2) = Y2;  
  242.                     *(pYUVData+i*width*3+j*6+3) = V1;  
  243.                     *(pYUVData+i*width*3+j*6+4) = alpha;  
  244.                     *(pYUVData+i*width*3+j*6+5) = alpha;  
  245.                 }  
  246.             }     
  247.         }  
  248.     }  
  249.     else  
  250.     {  
  251.         if (alphaRGB)  
  252.         {  
  253.             for (int i=0; i<height; ++i)  
  254.             {  
  255.                 for (int j=0; j<width/2; ++j)  
  256.                 {  
  257.                     B1 = *(pRGBData+(height-i-1)*width*4+j*8);  
  258.                     G1 = *(pRGBData+(height-i-1)*width*4+j*8+1);  
  259.                     R1 = *(pRGBData+(height-i-1)*width*4+j*8+2);  
  260.                     B2 = *(pRGBData+(height-i-1)*width*4+j*8+4);  
  261.                     G2 = *(pRGBData+(height-i-1)*width*4+j*8+5);  
  262.                     R2 = *(pRGBData+(height-i-1)*width*4+j*8+6);  
  263.                     Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);  
  264.                     U1 = ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128)>255 ? 255 : ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128);  
  265.                     Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;  
  266.                     V1 = ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128)>255 ? 255 : ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128);  
  267.                     *(pYUVData+i*width*2+j*4) = Y1;  
  268.                     *(pYUVData+i*width*2+j*4+1) = U1;  
  269.                     *(pYUVData+i*width*2+j*4+2) = Y2;  
  270.                     *(pYUVData+i*width*2+j*4+3) = V1;  
  271.                 }  
  272.             }     
  273.         }  
  274.         else  
  275.         {  
  276.             for (int i=0; i<height; ++i)  
  277.             {  
  278.                 for (int j=0; j<width/2; ++j)  
  279.                 {  
  280.                     B1 = *(pRGBData+(height-i-1)*width*3+j*6);  
  281.                     G1 = *(pRGBData+(height-i-1)*width*3+j*6+1);  
  282.                     R1 = *(pRGBData+(height-i-1)*width*3+j*6+2);  
  283.                     B2 = *(pRGBData+(height-i-1)*width*3+j*6+3);  
  284.                     G2 = *(pRGBData+(height-i-1)*width*3+j*6+4);  
  285.                     R2 = *(pRGBData+(height-i-1)*width*3+j*6+5);  
  286.                     Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);  
  287.                     U1 = ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128)>255 ? 255 : ((((-38*R1-74*G1+112*B1+128)>>8)+((-38*R2-74*G2+112*B2+128)>>8))/2 + 128);  
  288.                     Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;  
  289.                     V1 = ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128)>255 ? 255 : ((((112*R1-94*G1-18*B1+128)>>8) + ((112*R2-94*G2-18*B2+128)>>8))/2 + 128);  
  290.                     *(pYUVData+i*width*2+j*4) = Y1;  
  291.                     *(pYUVData+i*width*2+j*4+1) = U1;  
  292.                     *(pYUVData+i*width*2+j*4+2) = Y2;  
  293.                     *(pYUVData+i*width*2+j*4+3) = V1;  
  294.                 }  
  295.             }     
  296.         }  
  297.     }  
  298.     return 0;  
  299. }  
  300.   
  301. //////////////////////////////////////////////////////////////////////////   
  302. // pGBYUV           point to the background YUV data   
  303. // pFGYUV           point to the foreground YUV data   
  304. // width            width of the picture   
  305. // height           height of the picture   
  306. // alphaBG          is there an alpha channel in background YUV data   
  307. // alphaFG          is there an alpha channel in fourground YUV data   
  308. //////////////////////////////////////////////////////////////////////////   
  309. int YUVBlending(void* pBGYUV, void* pFGYUV, int width, int height, bool alphaBG, bool alphaFG)  
  310. {  
  311.     if (NULL == pBGYUV || NULL == pFGYUV)  
  312.     {  
  313.         return -1;  
  314.     }  
  315.     unsigned char* pBGData = (unsigned char*)pBGYUV;  
  316.     unsigned char* pFGData = (unsigned char*)pFGYUV;  
  317.     if (!alphaFG)  
  318.     {  
  319.         if (!alphaBG)  
  320.         {  
  321.             memcpy(pBGData, pFGData, width*height*2);  
  322.         }  
  323.         else  
  324.         {  
  325.             for (int i=0; i<height; ++i)  
  326.             {  
  327.                 for (int j=0; j<width/2; ++j)  
  328.                 {  
  329.                     *(pBGData+i*width*2+j*4) = *(pFGData+i*width*2+j*4);  
  330.                     *(pBGData+i*width*2+j*4+1) = *(pFGData+i*width*2+j*4+1);  
  331.                     *(pBGData+i*width*2+j*4+2) = *(pFGData+i*width*2+j*4+2);  
  332.                     *(pBGData+i*width*2+j*4+3) = *(pFGData+i*width*2+j*4+3);  
  333.                 }  
  334.             }  
  335.         }  
  336.     }  
  337.     int Y11, U11, V11, Y12, Y21, U21, V21, Y22;  
  338.     int alpha1, alpha2;  
  339.     if (!alphaBG)  
  340.     {  
  341.         for (int i=0; i<height; ++i)  
  342.         {  
  343.             for (int j=0; j<width/2; ++j)  
  344.             {  
  345.                 Y11 = *(pBGData+i*width*2+j*4);  
  346.                 U11 = *(pBGData+i*width*2+j*4+1);  
  347.                 Y12 = *(pBGData+i*width*2+j*4+2);  
  348.                 V11 = *(pBGData+i*width*2+j*4+3);  
  349.   
  350.                 Y21 = *(pFGData+i*width*3+j*6);  
  351.                 U21 = *(pFGData+i*width*3+j*6+1);  
  352.                 Y22 = *(pFGData+i*width*3+j*6+2);  
  353.                 V21 = *(pFGData+i*width*3+j*6+3);  
  354.                 alpha1 = *(pFGData+i*width*3+j*6+4);  
  355.                 alpha2 = *(pFGData+i*width*3+j*6+5);  
  356.   
  357.                 *(pBGData+i*width*2+j*4) = (Y21-16)*alpha1/255+(Y11-16)*(255-alpha1)/255+16;  
  358.                 *(pBGData+i*width*2+j*4+1) = ((U21-128)*alpha1/255+(U11-128)*(255-alpha1)/255 + (U21-128)*alpha2/255+(U11-128)*(255-alpha2)/255)/2+128;  
  359.                 *(pBGData+i*width*2+j*4+3) = ((V21-128)*alpha1/255+(V11-128)*(255-alpha1)/255 + (V21-128)*alpha2/255+(V11-128)*(255-alpha2)/255)/2+128;  
  360.                 *(pBGData+i*width*2+j*4+2) = (Y22-16)*alpha2/255+(Y12-16)*(255-alpha2)/255+16;  
  361.             }  
  362.         }  
  363.     }  
  364.     else  
  365.     {  
  366.         for (int i=0; i<height; ++i)  
  367.         {  
  368.             for (int j=0; j<width/2; ++j)  
  369.             {  
  370.                 Y11 = *(pBGData+i*width*3+j*6);  
  371.                 U11 = *(pBGData+i*width*3+j*6+1);  
  372.                 Y12 = *(pBGData+i*width*3+j*6+2);  
  373.                 V11 = *(pBGData+i*width*3+j*6+3);  
  374.   
  375.                 Y21 = *(pFGData+i*width*3+j*6);  
  376.                 U21 = *(pFGData+i*width*3+j*6+1);  
  377.                 Y22 = *(pFGData+i*width*3+j*6+2);  
  378.                 V21 = *(pFGData+i*width*3+j*6+3);  
  379.                 alpha1 = *(pFGData+i*width*3+j*6+4);  
  380.                 alpha2 = *(pFGData+i*width*3+j*6+5);  
  381.   
  382.                 *(pBGData+i*width*3+j*6) = (Y21-16)*alpha1/255+(Y11-16)*(255-alpha1)/255+16;  
  383.                 *(pBGData+i*width*3+j*6+1) = ((U21-128)*alpha1/255+(U11-128)*(255-alpha1)/255 + (U21-128)*alpha2/255+(U11-128)*(255-alpha2)/255)/2+128;  
  384.                 *(pBGData+i*width*3+j*6+3) = ((V21-128)*alpha1/255+(V11-128)*(255-alpha1)/255 + (V21-128)*alpha2/255+(V11-128)*(255-alpha2)/255)/2+128;  
  385.                 *(pBGData+i*width*3+j*6+2) = (Y22-16)*alpha2/255+(Y12-16)*(255-alpha2)/255+16;  
  386.             }  
  387.         }  
  388.     }  
  389.     return 0;  
  390. }  
经测试,功能已经实现,如有错误或者不妥的地方,恳请指出。 mosesyuan at gmail dot com
阅读更多
文章标签: c null gmail 测试
上一篇YUV420、YUV422、RGB24转换
下一篇如何用DirectDraw显示YUV数据
想对作者说点什么? 我来说一句

高效YUY2转灰度

2015年07月21日 541KB 下载

没有更多推荐了,返回首页

关闭
关闭
关闭