这是一个项目里使用的，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) +  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. // RGB2YUV
  162. // pRGB         point to the RGB data
  163. // pYUV         point to the YUV data
  164. // width        width of the picture
  165. // height       height of the picture
  166. // alphaYUV     is there an alpha channel in YUV
  167. // alphaRGB     is there an alpha channel in RGB
  168. //
  169. int RGB2YUV(void* pRGB, void* pYUV, int width, int height, bool alphaYUV, bool alphaRGB)
  170. {
  171. if (NULL == pRGB)
  172. {
  173. return -1;
  174. }
  175. unsigned char* pRGBData = (unsigned char *)pRGB;
  176. unsigned char* pYUVData = (unsigned char *)pYUV;
  177. if (NULL == pYUVData)
  178. {
  179. if (alphaYUV)
  180. {
  181. pYUVData = new unsigned char[width*height*3];
  182. }
  183. else
  184. pYUVData = new unsigned char[width*height*2];
  185. }
  186. int R1, G1, B1, R2, G2, B2, Y1, U1, Y2, V1;
  187. int alpha1, alpha2;
  188. if (alphaYUV)
  189. {
  190. if (alphaRGB)
  191. {
  192. for (int i=0; i<height; ++i)
  193. {
  194. for (int j=0; j<width/2; ++j)
  195. {
  196. B1 = *(pRGBData+(height-i-1)*width*4+j*8);
  197. G1 = *(pRGBData+(height-i-1)*width*4+j*8+1);
  198. R1 = *(pRGBData+(height-i-1)*width*4+j*8+2);
  199. alpha1 = *(pRGBData+(height-i-1)*width*4+j*8+3);
  200. B2 = *(pRGBData+(height-i-1)*width*4+j*8+4);
  201. G2 = *(pRGBData+(height-i-1)*width*4+j*8+5);
  202. R2 = *(pRGBData+(height-i-1)*width*4+j*8+6);
  203. alpha2 = *(pRGBData+(height-i-1)*width*4+j*8+7);
  204. Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);
  205. 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);
  206. Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;
  207. 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);
  208. *(pYUVData+i*width*3+j*6) = Y1;
  209. *(pYUVData+i*width*3+j*6+1) = U1;
  210. *(pYUVData+i*width*3+j*6+2) = Y2;
  211. *(pYUVData+i*width*3+j*6+3) = V1;
  212. *(pYUVData+i*width*3+j*6+4) = alpha1;
  213. *(pYUVData+i*width*3+j*6+5) = alpha2;
  214. }
  215. }
  216. }
  217. else
  218. {
  219. unsigned char alpha = 255;
  220. for (int i=0; i<height; ++i)
  221. {
  222. for (int j=0; j<width/2; ++j)
  223. {
  224. B1 = *(pRGBData+(height-i-1)*width*3+j*6);
  225. G1 = *(pRGBData+(height-i-1)*width*3+j*6+1);
  226. R1 = *(pRGBData+(height-i-1)*width*3+j*6+2);
  227. B2 = *(pRGBData+(height-i-1)*width*3+j*6+3);
  228. G2 = *(pRGBData+(height-i-1)*width*3+j*6+4);
  229. R2 = *(pRGBData+(height-i-1)*width*3+j*6+5);
  230. Y1 = ((66*R1+129*G1+25*B1+128)>>8) + 16;
  231. U1 = ((-38*R1-74*G1+112*B1+128)>>8+(-38*R2-74*G2+112*B2+128)>>8)/2 + 128;
  232. Y2 = ((66*R2+129*G2+25*B2+128)>>8) + 16;
  233. V1 = ((112*R1-94*G1-18*B1+128)>>8 + (112*R2-94*G2-18*B2+128)>>8)/2 + 128;
  234. Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);
  235. 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);
  236. Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;
  237. 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);
  238. *(pYUVData+i*width*3+j*6) = Y1;
  239. *(pYUVData+i*width*3+j*6+1) = U1;
  240. *(pYUVData+i*width*3+j*6+2) = Y2;
  241. *(pYUVData+i*width*3+j*6+3) = V1;
  242. *(pYUVData+i*width*3+j*6+4) = alpha;
  243. *(pYUVData+i*width*3+j*6+5) = alpha;
  244. }
  245. }
  246. }
  247. }
  248. else
  249. {
  250. if (alphaRGB)
  251. {
  252. for (int i=0; i<height; ++i)
  253. {
  254. for (int j=0; j<width/2; ++j)
  255. {
  256. B1 = *(pRGBData+(height-i-1)*width*4+j*8);
  257. G1 = *(pRGBData+(height-i-1)*width*4+j*8+1);
  258. R1 = *(pRGBData+(height-i-1)*width*4+j*8+2);
  259. B2 = *(pRGBData+(height-i-1)*width*4+j*8+4);
  260. G2 = *(pRGBData+(height-i-1)*width*4+j*8+5);
  261. R2 = *(pRGBData+(height-i-1)*width*4+j*8+6);
  262. Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);
  263. 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);
  264. Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;
  265. 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);
  266. *(pYUVData+i*width*2+j*4) = Y1;
  267. *(pYUVData+i*width*2+j*4+1) = U1;
  268. *(pYUVData+i*width*2+j*4+2) = Y2;
  269. *(pYUVData+i*width*2+j*4+3) = V1;
  270. }
  271. }
  272. }
  273. else
  274. {
  275. for (int i=0; i<height; ++i)
  276. {
  277. for (int j=0; j<width/2; ++j)
  278. {
  279. B1 = *(pRGBData+(height-i-1)*width*3+j*6);
  280. G1 = *(pRGBData+(height-i-1)*width*3+j*6+1);
  281. R1 = *(pRGBData+(height-i-1)*width*3+j*6+2);
  282. B2 = *(pRGBData+(height-i-1)*width*3+j*6+3);
  283. G2 = *(pRGBData+(height-i-1)*width*3+j*6+4);
  284. R2 = *(pRGBData+(height-i-1)*width*3+j*6+5);
  285. Y1 = (((66*R1+129*G1+25*B1+128)>>8) + 16) > 255 ? 255 : (((66*R1+129*G1+25*B1+128)>>8) + 16);
  286. 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);
  287. Y2 = (((66*R2+129*G2+25*B2+128)>>8) + 16)>255 ? 255 : ((66*R2+129*G2+25*B2+128)>>8) + 16;
  288. 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);
  289. *(pYUVData+i*width*2+j*4) = Y1;
  290. *(pYUVData+i*width*2+j*4+1) = U1;
  291. *(pYUVData+i*width*2+j*4+2) = Y2;
  292. *(pYUVData+i*width*2+j*4+3) = V1;
  293. }
  294. }
  295. }
  296. }
  297. return 0;
  298. }
  299. //
  300. // pGBYUV           point to the background YUV data
  301. // pFGYUV           point to the foreground YUV data
  302. // width            width of the picture
  303. // height           height of the picture
  304. // alphaBG          is there an alpha channel in background YUV data
  305. // alphaFG          is there an alpha channel in fourground YUV data
  306. //
  307. int YUVBlending(void* pBGYUV, void* pFGYUV, int width, int height, bool alphaBG, bool alphaFG)
  308. {
  309. if (NULL == pBGYUV || NULL == pFGYUV)
  310. {
  311. return -1;
  312. }
  313. unsigned char* pBGData = (unsigned char*)pBGYUV;
  314. unsigned char* pFGData = (unsigned char*)pFGYUV;
  315. if (!alphaFG)
  316. {
  317. if (!alphaBG)
  318. {
  319. memcpy(pBGData, pFGData, width*height*2);
  320. }
  321. else
  322. {
  323. for (int i=0; i<height; ++i)
  324. {
  325. for (int j=0; j<width/2; ++j)
  326. {
  327. *(pBGData+i*width*2+j*4) = *(pFGData+i*width*2+j*4);
  328. *(pBGData+i*width*2+j*4+1) = *(pFGData+i*width*2+j*4+1);
  329. *(pBGData+i*width*2+j*4+2) = *(pFGData+i*width*2+j*4+2);
  330. *(pBGData+i*width*2+j*4+3) = *(pFGData+i*width*2+j*4+3);
  331. }
  332. }
  333. }
  334. }
  335. int Y11, U11, V11, Y12, Y21, U21, V21, Y22;
  336. int alpha1, alpha2;
  337. if (!alphaBG)
  338. {
  339. for (int i=0; i<height; ++i)
  340. {
  341. for (int j=0; j<width/2; ++j)
  342. {
  343. Y11 = *(pBGData+i*width*2+j*4);
  344. U11 = *(pBGData+i*width*2+j*4+1);
  345. Y12 = *(pBGData+i*width*2+j*4+2);
  346. V11 = *(pBGData+i*width*2+j*4+3);
  347. Y21 = *(pFGData+i*width*3+j*6);
  348. U21 = *(pFGData+i*width*3+j*6+1);
  349. Y22 = *(pFGData+i*width*3+j*6+2);
  350. V21 = *(pFGData+i*width*3+j*6+3);
  351. alpha1 = *(pFGData+i*width*3+j*6+4);
  352. alpha2 = *(pFGData+i*width*3+j*6+5);
  353. *(pBGData+i*width*2+j*4) = (Y21-16)*alpha1/255+(Y11-16)*(255-alpha1)/255+16;
  354. *(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;
  355. *(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;
  356. *(pBGData+i*width*2+j*4+2) = (Y22-16)*alpha2/255+(Y12-16)*(255-alpha2)/255+16;
  357. }
  358. }
  359. }
  360. else
  361. {
  362. for (int i=0; i<height; ++i)
  363. {
  364. for (int j=0; j<width/2; ++j)
  365. {
  366. Y11 = *(pBGData+i*width*3+j*6);
  367. U11 = *(pBGData+i*width*3+j*6+1);
  368. Y12 = *(pBGData+i*width*3+j*6+2);
  369. V11 = *(pBGData+i*width*3+j*6+3);
  370. Y21 = *(pFGData+i*width*3+j*6);
  371. U21 = *(pFGData+i*width*3+j*6+1);
  372. Y22 = *(pFGData+i*width*3+j*6+2);
  373. V21 = *(pFGData+i*width*3+j*6+3);
  374. alpha1 = *(pFGData+i*width*3+j*6+4);
  375. alpha2 = *(pFGData+i*width*3+j*6+5);
  376. *(pBGData+i*width*3+j*6) = (Y21-16)*alpha1/255+(Y11-16)*(255-alpha1)/255+16;
  377. *(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;
  378. *(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;
  379. *(pBGData+i*width*3+j*6+2) = (Y22-16)*alpha2/255+(Y12-16)*(255-alpha2)/255+16;
  380. }
  381. }
  382. }
  383. return 0;
  384. }

转载于:https://www.cnblogs.com/lzf8888/p/3843013.html

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

  1. YUY2(YUV) 与 RGB 格式图片的相互转换

    [版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/jtujtujtu/article/d ...

  2. 【DSP开发】【VS开发】YUV与RGB格式转换

    [视频处理]YUV与RGB格式转换 YUV格式具有亮度信息和色彩信息分离的特点,但大多数图像处理操作都是基于RGB格式. 因此当要对图像进行后期处理显示时,需要把YUV格式转换成RGB格式. RGB与 ...

  3. 数据压缩实验一：yuv转rgb格式实验报告

    数据压缩实验一:yuv转rgb格式实验报告 一:实验基本原理 yuv转rgb格式转换公式: R=Y+1.4020*(V-128) G=Y-0.3441*(U-128)-0.7141*(V-128) B ...

  4. YUV与RGB格式的相互转换及误差

    一.RGB转YUV 1.原理 a.YUV的计算公式: b.动态保护范围: 2.源代码 源代码为老师发的代码此处略 3.实验结果 a.原rgb: b.转换后yuv: 二.YUV转RGB 1.原理 a.R ...

  5. java+解析png+gif图片_Java 转换png jpg gif格式图片的相互转换的实现

    利用JDK原生支持对png jpg gif格式图片做相互转换,结合脚本就可以达到批量处理的能力,比PS来的快啊!而且是JAVA代码 在Windows和Linux上都可以用. import java.a ...

  6. YUV与RGB格式详解

    YUV 是一种颜色编码方法,和它等同的还有 RGB 颜色编码方法. RGB 颜色编码 RGB 三个字母分别代表了 红(Red).绿(Green).蓝(Blue),这三种颜色称为 三原色,将它们以不同的 ...

  7. YUV 格式与 RGB 格式的相互转换公式总结（C++版）

    YUV 格式与 RGB 格式的相互转换公式 最近在用的一个工业相机,输出的图像格式是 YUY2 格式.而在电脑上显示时需要 RGB 格式,所以就花了些时间在网上查了些相关的资料.说实话,网上关于 YU ...

  8. 图片YUV格式与RGB格式的转换

    YUV格式与RGB格式的转换 YUV格式介绍 YUV420.YUV422.YUV444 (1) YUV4:2:0 (2) YUV4:2:2 (3) YUV4:4:4 内存排列方式 YUV与RGB转换 ...

  9. 使用C++实现YUV格式图像与RGB格式图像之间相互转换

    使用C++实现YUV格式图像与RGB格式图像之间相互转换 一.RGB与YUV转换公式 1.RGB转YUV 1)RGB转换亮度与色差信号公试: 2)归一化为YUV的转化公试为: 2.YUV转RGB 二. ...

最新文章

  1. Git常见问题解决方案指北
  2. Win7桌面快捷切换技巧？
  3. 【不同的子序列问题】面试官写个字符串要我求有多少个“bigsai“，我懵了
  4. java 简单的计算器程序,Java 简易计算器程序
  5. php+ajax+jquery分页并显示数据
  6. redis——实战关注
  7. 支配树（洛谷-P5180）
  8. 了解计算机中的信息编码教案,五年级下册信息技术《奇妙的编码》教学设计
  9. C++ 递归算法解析（演示语言：c++/c#/python/lua）（用博主会的所有语言来演示一波）
  10. Linux应用编程基础01：Linux应用编程绪论
  11. 练习-CSS3 多栏(Multi-column)
  12. python利用gzip压缩解压缩StringIO
  13. powershell 模拟IE行为
  14. 通讯录(结尾附全部代码)
  15. 端口扫描 -- Masscan-Gui
  16. IKBC poker 2更换WIN键与ALT键（option键与command键）
  17. 说一下浏览器垃圾回收机制？
  18. RK3588 CPU GPU DDR NPU定频和性能模式设置
  19. 【雷达与对抗】【2017.06】空中目标的无源雷达探测
  20. 向量范数和矩阵范数的理解

热门文章

  1. 基于layuiCMS2.0开发后台管理系统，实现自定义分页并动态加载数据表格的示例...
  2. Mac下使用Wine安装PowerDesigner15
  3. android google map研究
  4. libvirt-virsh命令
  5. Android学习笔记19-ImageView实现图片适屏与裁剪
  6. (转)C++中extern “C”含义深层探索
  7. 问题 A: 百钱买百鸡问题
  8. 安徽省2018计算机一级9月报名,2018年9月份全国计算机等级考试安徽财经大学考点报名通知...
  9. java vector内存结构_4. Java集合知识测试
  10. Python中用户管理（用户的登陆、用户的增删改查）