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

最新推荐文章于 2022-07-21 22:38:12 发布
最新推荐文章于 2022-07-21 22:38:12 发布
阅读量857 收藏
点赞数
分类专栏： 多媒体开发及图像处理 文章标签： c null

转： http://blog.csdn.net/jtujtujtu/archive/2009/02/10/3874621.aspx

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信息。上述函数的具体实现为：view plaincopy to clipboardprint?//   // YUV2RGB   // pYUV         point to the YUV data   // pRGB         point to the RGB data   // width        width of the picture   // height       height of the picture   // alphaYUV     is there an alpha channel in YUV   // alphaRGB     is there an alpha channel in RGB   //   int YUV2RGB(void* pYUV, void* pRGB, int width, int height, bool alphaYUV, bool alphaRGB)   {       if (NULL == pYUV)       {           return -1;       }       unsigned char* pYUVData = (unsigned char *)pYUV;       unsigned char* pRGBData = (unsigned char *)pRGB;       if (NULL == pRGBData)       {           if (alphaRGB)           {               pRGBData = new unsigned char[width*height*4];           }           else              pRGBData = new unsigned char[width*height*3];       }       int Y1, U1, V1, Y2, alpha1, alpha2, R1, G1, B1, R2, G2, B2;       int C1, D1, E1, C2;       if (alphaRGB)       {           if (alphaYUV)           {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       Y1 = *(pYUVData+i*width*3+j*6);                       U1 = *(pYUVData+i*width*3+j*6+1);                       Y2 = *(pYUVData+i*width*3+j*6+2);                       V1 = *(pYUVData+i*width*3+j*6+3);                       alpha1 = *(pYUVData+i*width*3+j*6+4);                       alpha2 = *(pYUVData+i*width*3+j*6+5);                       C1 = Y1-16;                       C2 = Y2-16;                       D1 = U1-128;                       E1 = V1-128;                       R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);                       G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);                         B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);                         R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);                       G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);                       B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);                         *(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;                       *(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;                       *(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;                       *(pRGBData+(height-i-1)*width*4+j*8+3) = alpha1;                           *(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;                       *(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;                       *(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;                       *(pRGBData+(height-i-1)*width*4+j*8+7) = alpha2;                       }               }              }           else          {               int alpha = 255;               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       Y1 = *(pYUVData+i*width*2+j*4);                       U1 = *(pYUVData+i*width*2+j*4+1);                       Y2 = *(pYUVData+i*width*2+j*4+2);                       V1 = *(pYUVData+i*width*2+j*4+3);                       C1 = Y1-16;                       C2 = Y2-16;                       D1 = U1-128;                       E1 = V1-128;                       R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);                       G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);                         B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);                         R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);                       G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);                       B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);                         *(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;                       *(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;                       *(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;                       *(pRGBData+(height-i-1)*width*4+j*8+3) = alpha;                        *(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;                       *(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;                       *(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;                       *(pRGBData+(height-i-1)*width*4+j*8+7) = alpha;                    }               }              }       }       else      {           if (alphaYUV)           {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       Y1 = *(pYUVData+i*width*3+j*4);                       U1 = *(pYUVData+i*width*3+j*4+1);                       Y2 = *(pYUVData+i*width*3+j*4+2);                       V1 = *(pYUVData+i*width*3+j*4+3);                       C1 = Y1-16;                       C2 = Y2-16;                       D1 = U1-128;                       E1 = V1-128;                       R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);                       G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);                         B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);                         R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);                       G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);                       B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);                         *(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;                       *(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;                       *(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;                       *(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;                       *(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;                       *(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;                   }               }           }           else          {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       Y1 = *(pYUVData+i*width*2+j*4);                       U1 = *(pYUVData+i*width*2+j*4+1);                       Y2 = *(pYUVData+i*width*2+j*4+2);                       V1 = *(pYUVData+i*width*2+j*4+3);                       C1 = Y1-16;                       C2 = Y2-16;                       D1 = U1-128;                       E1 = V1-128;                       R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);                       G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);                         B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);                         R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);                       G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);                       B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);                         *(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;                       *(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;                       *(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;                       *(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;                       *(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;                       *(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;                   }               }              }       }       return 0;   }     //   // RGB2YUV   // pRGB         point to the RGB data   // pYUV         point to the YUV data   // width        width of the picture   // height       height of the picture   // alphaYUV     is there an alpha channel in YUV   // alphaRGB     is there an alpha channel in RGB   //   int RGB2YUV(void* pRGB, void* pYUV, int width, int height, bool alphaYUV, bool alphaRGB)   {       if (NULL == pRGB)       {           return -1;       }       unsigned char* pRGBData = (unsigned char *)pRGB;       unsigned char* pYUVData = (unsigned char *)pYUV;       if (NULL == pYUVData)       {           if (alphaYUV)           {               pYUVData = new unsigned char[width*height*3];           }           else              pYUVData = new unsigned char[width*height*2];       }       int R1, G1, B1, R2, G2, B2, Y1, U1, Y2, V1;       int alpha1, alpha2;       if (alphaYUV)       {           if (alphaRGB)           {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       B1 = *(pRGBData+(height-i-1)*width*4+j*8);                       G1 = *(pRGBData+(height-i-1)*width*4+j*8+1);                       R1 = *(pRGBData+(height-i-1)*width*4+j*8+2);                       alpha1 = *(pRGBData+(height-i-1)*width*4+j*8+3);                       B2 = *(pRGBData+(height-i-1)*width*4+j*8+4);                       G2 = *(pRGBData+(height-i-1)*width*4+j*8+5);                       R2 = *(pRGBData+(height-i-1)*width*4+j*8+6);                       alpha2 = *(pRGBData+(height-i-1)*width*4+j*8+7);                       Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);                       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);                       Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;                       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);                       *(pYUVData+i*width*3+j*6) = Y1;                       *(pYUVData+i*width*3+j*6+1) = U1;                       *(pYUVData+i*width*3+j*6+2) = Y2;                       *(pYUVData+i*width*3+j*6+3) = V1;                       *(pYUVData+i*width*3+j*6+4) = alpha1;                       *(pYUVData+i*width*3+j*6+5) = alpha2;                   }               }              }           else          {               unsigned char alpha = 255;               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       B1 = *(pRGBData+(height-i-1)*width*3+j*6);                       G1 = *(pRGBData+(height-i-1)*width*3+j*6+1);                       R1 = *(pRGBData+(height-i-1)*width*3+j*6+2);                       B2 = *(pRGBData+(height-i-1)*width*3+j*6+3);                       G2 = *(pRGBData+(height-i-1)*width*3+j*6+4);                       R2 = *(pRGBData+(height-i-1)*width*3+j*6+5);                       Y1 = ((66*R1+129*G1+25*B1+128)>>8) + 16;                       U1 = ((-38*R1-74*G1+112*B1+128)>>8+(-38*R2-74*G2+112*B2+128)>>8)/2 + 128;                       Y2 = ((66*R2+129*G2+25*B2+128)>>8) + 16;                       V1 = ((112*R1-94*G1-18*B1+128)>>8 + (112*R2-94*G2-18*B2+128)>>8)/2 + 128;                       Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);                       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);                       Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;                       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);                       *(pYUVData+i*width*3+j*6) = Y1;                       *(pYUVData+i*width*3+j*6+1) = U1;                       *(pYUVData+i*width*3+j*6+2) = Y2;                       *(pYUVData+i*width*3+j*6+3) = V1;                       *(pYUVData+i*width*3+j*6+4) = alpha;                       *(pYUVData+i*width*3+j*6+5) = alpha;                   }               }              }       }       else      {           if (alphaRGB)           {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       B1 = *(pRGBData+(height-i-1)*width*4+j*8);                       G1 = *(pRGBData+(height-i-1)*width*4+j*8+1);                       R1 = *(pRGBData+(height-i-1)*width*4+j*8+2);                       B2 = *(pRGBData+(height-i-1)*width*4+j*8+4);                       G2 = *(pRGBData+(height-i-1)*width*4+j*8+5);                       R2 = *(pRGBData+(height-i-1)*width*4+j*8+6);                       Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);                       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);                       Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;                       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);                       *(pYUVData+i*width*2+j*4) = Y1;                       *(pYUVData+i*width*2+j*4+1) = U1;                       *(pYUVData+i*width*2+j*4+2) = Y2;                       *(pYUVData+i*width*2+j*4+3) = V1;                   }               }              }           else          {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       B1 = *(pRGBData+(height-i-1)*width*3+j*6);                       G1 = *(pRGBData+(height-i-1)*width*3+j*6+1);                       R1 = *(pRGBData+(height-i-1)*width*3+j*6+2);                       B2 = *(pRGBData+(height-i-1)*width*3+j*6+3);                       G2 = *(pRGBData+(height-i-1)*width*3+j*6+4);                       R2 = *(pRGBData+(height-i-1)*width*3+j*6+5);                       Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);                       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);                       Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;                       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);                       *(pYUVData+i*width*2+j*4) = Y1;                       *(pYUVData+i*width*2+j*4+1) = U1;                       *(pYUVData+i*width*2+j*4+2) = Y2;                       *(pYUVData+i*width*2+j*4+3) = V1;                   }               }              }       }       return 0;   }     //   // pGBYUV           point to the background YUV data   // pFGYUV           point to the foreground YUV data   // width            width of the picture   // height           height of the picture   // alphaBG          is there an alpha channel in background YUV data   // alphaFG          is there an alpha channel in fourground YUV data   //   int YUVBlending(void* pBGYUV, void* pFGYUV, int width, int height, bool alphaBG, bool alphaFG)   {       if (NULL == pBGYUV || NULL == pFGYUV)       {           return -1;       }       unsigned char* pBGData = (unsigned char*)pBGYUV;       unsigned char* pFGData = (unsigned char*)pFGYUV;       if (!alphaFG)       {           if (!alphaBG)           {               memcpy(pBGData, pFGData, width*height*2);           }           else          {               for (int i=0; i<height; ++i)               {                   for (int j=0; j<width/2; ++j)                   {                       *(pBGData+i*width*2+j*4) = *(pFGData+i*width*2+j*4);                       *(pBGData+i*width*2+j*4+1) = *(pFGData+i*width*2+j*4+1);                       *(pBGData+i*width*2+j*4+2) = *(pFGData+i*width*2+j*4+2);                       *(pBGData+i*width*2+j*4+3) = *(pFGData+i*width*2+j*4+3);                   }               }           }       }       int Y11, U11, V11, Y12, Y21, U21, V21, Y22;       int alpha1, alpha2;       if (!alphaBG)       {           for (int i=0; i<height; ++i)           {               for (int j=0; j<width/2; ++j)               {                   Y11 = *(pBGData+i*width*2+j*4);                   U11 = *(pBGData+i*width*2+j*4+1);                   Y12 = *(pBGData+i*width*2+j*4+2);                   V11 = *(pBGData+i*width*2+j*4+3);                     Y21 = *(pFGData+i*width*3+j*6);                   U21 = *(pFGData+i*width*3+j*6+1);                   Y22 = *(pFGData+i*width*3+j*6+2);                   V21 = *(pFGData+i*width*3+j*6+3);                   alpha1 = *(pFGData+i*width*3+j*6+4);                   alpha2 = *(pFGData+i*width*3+j*6+5);                     *(pBGData+i*width*2+j*4) = (Y21-16)*alpha1/255+(Y11-16)*(255-alpha1)/255+16;                   *(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;                   *(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;                   *(pBGData+i*width*2+j*4+2) = (Y22-16)*alpha2/255+(Y12-16)*(255-alpha2)/255+16;               }           }       }       else      {           for (int i=0; i<height; ++i)           {               for (int j=0; j<width/2; ++j)               {                   Y11 = *(pBGData+i*width*3+j*6);                   U11 = *(pBGData+i*width*3+j*6+1);                   Y12 = *(pBGData+i*width*3+j*6+2);                   V11 = *(pBGData+i*width*3+j*6+3);                     Y21 = *(pFGData+i*width*3+j*6);                   U21 = *(pFGData+i*width*3+j*6+1);                   Y22 = *(pFGData+i*width*3+j*6+2);                   V21 = *(pFGData+i*width*3+j*6+3);                   alpha1 = *(pFGData+i*width*3+j*6+4);                   alpha2 = *(pFGData+i*width*3+j*6+5);                     *(pBGData+i*width*3+j*6) = (Y21-16)*alpha1/255+(Y11-16)*(255-alpha1)/255+16;                   *(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;                   *(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;                   *(pBGData+i*width*3+j*6+2) = (Y22-16)*alpha2/255+(Y12-16)*(255-alpha2)/255+16;               }           }       }       return 0;   } 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jtujtujtu/archive/2009/02/10/3874621.aspx

max123456
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YUY2 到 RGB 转换器：将来自我的罗技相机的 YUY2 输入转换为 RGB。 可能与 YUV 到 RGB 转换器相同。-matlab开发
06-01
将我的罗技相机的 YUY2 输入转换为 RGB。 可能与 YUV 到 RGB 转换器相同。 如果您需要此文件来处理来自相机的视频输入，这里有另一种方法（我还没有测试过）。 引用 Lautaro Camona ( http://www.mathworks.com/matlabcentral/newsreader/view_thread/263490#716245)： “我最近遇到了同样的问题，我的网络摄像头只能使用 YUY2 格式...... 我这样做解决了这个问题： %1st 您设置要使用的相机。 %'camera' 是你的相机的 DeviceID。 vinfo = imaqhwinfo('winvideo',camera); %然后你设置视频对象'vid'，其中'camera'是你的相机的DeviceID。 %'format' 是指定相机 YUY2 格式之一的索引。 vid
YUY2转换为RGB的多种方法
tong5956的专栏
12-31 2594
在视频采集图像分析中，需要将采集的格式转换为所需的RGB格式，这里有两种方法： 方法1： 步骤1：转换为RGB24格式 int ConvertYUY2toRGB24(char* pOutputRgb, unsigned char* pInputBuffer, int tInputWidth, int tInputHeight) { unsigned char*
YUY2 转 rgb24
max123456的专栏
04-07 3740
typedef       struct       tagTABLE_YUV2RGB   {    unsigned       short       YtoR[256];    unsigned       short       YtoG[256];    unsigned       short       YtoB[256];      unsigned       short    
matlab yuy2转rgb,YUY2/RGB转换公式
weixin_28481133的博客
03-18 457
YUY2/RGB转换公式Y = 0.299 R + 0.587 G + 0.114 BCb = - 0.1687 R - 0.3313 G + 0.5 B + 128Cr = 0.5 R - 0.4187 G - 0.0813 B + 128反过来也可以：R = Y + 1.402 (Cr-128)G = Y - 0.34414 (Cb-128) - 0.71414 (Cr-128)B = Y +...
YUV2RGB.rar_matlab图像处理_yuv2rgb_yuv2rgb avi_yuv2rgb24_yuy2图片格式
09-24
将视频采集卡中的采集到的原始视频数据（YUY2格式）转换成RGB24格式，保存成位图。 用于抓取帧
( YUV420(YV12)与YUY2(YUV422,YUYV)格式互转
08-02
做美颜要进行格式转换，就做了两种格式的互转，( YUV420(YV12)与YUY2(YUV422,YUYV)格式互转
YUY2-RGB.rar_YUY2 to RGB_yuy2_yuy2 rgb
09-19
yuy to RGB，包含多种算法，课自行选择
YUY420(YV12)转YUY2(YUV420)，读取yuv文件转成YUY2文件
08-02
从磁盘中读取YUY420(YV12)文件解析处理按YUY2(YUV420)格式写入磁盘，利用格式检查工具可以进行检查
YUV颜色空间转换（YV12、NV12、NV21、I420、RGB等）
08-17
本程序实现了简单的YUV数据之间的转换和YUV与RGB的转换。 注：1、本程序只是简单YUV之间的颜色空间转换和YUV与RGB的转换。 2、本程序使用的vs2019创建的，需使用2019打开工程。 3、包含功能： 1）YV12_2_I420； ...
YUY2转RGB程序
01-09
YUY2转RGB程序YUY2转RGB程序YUY2转RGB程序YUY2转RGB程序YUY2转RGB程序
YUY2、MJPG、V4L2、UVC等的介绍与分析
weixin_55749979的博客
07-21 1万+
简单介绍YUY2、MJPG、V4L2、UVC等名词的意思
谈谈RGB、YUY2、YUYV、YVYU、UYVY、AYUV
热门推荐
cuiy0001的专栏
02-19 2万+
1） YUV 4:4:4 YUV三个信道的抽样率相同，因此在生成的图像里，每个象素的三个分量信息完整（每个分量通常8比特），经过8比特量化之后，未经压缩的每个像素占用3个字节。 下面的四个像素为: [Y0 U0 V0] [Y1 U1 V1] [Y2 U2 V2] [Y3 U3 V3] 存放的码流为: Y0 U0 V0 Y1 U1 V1 Y2 U2 V2 Y3 U3 V3 （2） Y
YUY2转RGB(或BGR)
山的那一边
03-30 5014
//YUY2视频转化RGB格式 inline void YUY2_RGB(BYTE *YUY2buff,BYTE *RGBbuff,int dwSize) { //B = 1.164(Y - 16) + 2.018(U - 128) //G = 1.164(Y - 16) - 0.813(V - 128) - 0.391(U - 128) /
YV12和YUY2的基本知识
sidemap的博客
01-09 3842
YUV格式在存储上存在两类布局： Packed：把相邻的几个像素打包起来；比如把水平方向2个像素打包到一个DWORD Plannar：方式相反；Y分量和UV分量完全分开来保存 YUY2和YV12是最常用的两个代表。 YUY2是packed方式的。水平方向两个像素打包到一个DWORD，并且UV采样率只有Y的一半，这符合人的视觉特征能有效的压缩数据,具体布局为[Y0, U0,Y1,V0]。 这种...
RGB、YUY2、YUYV、YVYU、UYVY、AYUV格式详解
jerry3564的博客
07-06 4291
YUV是指亮度参量和色度参量分开表示的像素格式，而这样分开的好处就是不但可以避免相互干扰，还可以降低色度的采样率而不会对图像质量影响太大。YUV是一个比较笼统地说法，针对它的具体排列方式，可以分为很多种具体的格式。转载一篇对yuv格式解释的比较清楚地文章，也可以直接参考微软的那篇文章。对于YUV格式，比较原始的讲解是MPEG-2 VIDEO部分的解释，当然后来微软有一个比较经典的解释，中文的大多是...
YUY2(YUYV)转YUV420源码分析
qinjinghua2012的专栏
04-19 4388
此文记录自己的学习过程，程序为网上下载的源码。 视频监控，用到ARM11的H.264硬件编码器，由于其要求输入的视频为YUV420格式，所以需要对自己USB摄像头输出的YUY2格式进行转换。 YUY2与YUV422内部排列形式一样！理论性分析，可参考此文：http://blog.csdn.net/searchsun/article/details/2443867 源码思路： 1、YUV有打
yuv格式 yuyv yuy2
最新发布
07-12
YUV格式中的YUYV和YUY2都是基于4:2:2采样的格式，常用于视频和图像的存储和传输。 YUV是一种将亮度（Y）和色度（U和V）分离的颜色空间。Y表示图像的亮度信息，而U和V表示图像的色度信息。在YUV中，对于每个像素，一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值