码迷，mamicode.com
首页 > 其他好文 > 详细

YUY2(YUV) 与 RGB 格式图片的相互转换 以及 基于YUY2(YUV)的blending

时间：2014-07-14 17:55:55      阅读：324      评论：0      收藏：0      [点我收藏+]

标签：des   blog   http   使用   strong   os   

这是一个项目里使用的，API里从pool里取出的格式都是YUY2，但是图像处理的API库中要求都是jepg格式。

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信息。

上述函数的具体实现为：
[c-sharp] view plaincopy
 
  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. }  

YUY2(YUV) 与 RGB 格式图片的相互转换 以及 基于YUY2(YUV)的blending,布布扣,bubuko.com

YUY2(YUV) 与 RGB 格式图片的相互转换 以及 基于YUY2(YUV)的blending

标签：des   blog   http   使用   strong   os   

原文地址：http://www.cnblogs.com/lzf8888/p/3843013.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！