程序博客网 > 淘宝里的评价怎么删除

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

来源：互联网 发布：淘宝里的评价怎么删除 编辑：程序博客网 时间：2024/05/21 15:07
原文地址：（转）YUY2(YUV) 与 RGB 格式图片的相互转换 以及 基于YUY2(YUV)的blending作者：南冠彤

http://blog.csdn.net/jtujtujtu/article/details/3874621

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) + 16U = ( ( -38 * R - 74 * G + 112 * B + 128) >> 8) + 128V = ( ( 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) + 16U = ( ( -38 * R - 74 * G + 112 * B + 128) >> 8) + 128V = ( ( 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. }  
经测试，功能已经实现，如有错误或者不妥的地方，恳请指出。
淘宝里的评价怎么删除 淘宝里的评价怎么删除
原创粉丝点击
热门IT博客
校园网络借贷主题班会校园网络借贷主题班会
完美假期周晨曦淘宝店完美假期周晨曦淘宝店
接亲堵门游戏 知乎
飞鸟淘宝客学习
手机怎么抢网络
林湖景苑网络
淘宝中国质造什么意思
越南网络电视直播
手游英雄杀十连抽数据
淘宝怎么关联小号
python 数据接口
sqlserver分页sql语句
从零开始学java电子书
法国 知乎
网络文学社简介
手机淘宝 占用空间
湖南教师网络研修
notepad 执行python
淘宝网天猫儿童凉鞋
免费画漫画软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 煎锅平底锅 小煎锅批发 中药煎锅什么牌子好 煎锅多少钱一个 煎锅的价格 水煎包煎锅 煎锅用什么材质的好 早餐煎锅 苏伯尔煎锅 煎锅 不粘锅 煎锅 炒菜 煎锅什么品牌好 不锈钢煎锅价格 如何选煎锅 不锈钢煎锅好不好 平底锅 煎锅 手抓饼煎锅 煎锅可以炒菜么 什么样的煎锅比较好 煎锅煎鸡蛋 钻石煎锅 火锅的锅 苏泊尔火红点煎锅 水煎饺子的做法 水煎饺子的做法图解 煎饺子怎么煎才好吃 煎饺子 煎饺做法 速冻饺子煎饺 煎饺怎么做 怎么做煎饺 做煎饺 速冻饺子做煎饺小窍门 水煎饺 糯米煎饺 冰花煎饺 鸡蛋煎饺 煎饺图片 日式煎饺 煎饺热量 煎饺怎么煎

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里