开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Yuv2rgb.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：10k
源码类别：

多媒体编程

开发平台：

Visual C++

Yuv2rgb.c：源码内容
  2. #include <memory.h>
  4. #include "portab.h"
  5. #include "yuv2rgb.h"
  7. /**
  8.  *
  9. **/
  12. void (*convert_yuv)(unsigned char *puc_y, int stride_y,
  13. unsigned char *puc_u, unsigned char *puc_v, int stride_uv,
  14. unsigned char *bmp, int width_y, int height_y,
  15. unsigned int stride_out);
  17. /**
  18.  *
  19. **/
  23. #define _S(a) (a)>255 ? 255 : (a)<0 ? 0 : (a)
  25. #define _R(y,u,v) (0x2568*(y)          + 0x3343*(u)) /0x2000
  26. #define _G(y,u,v) (0x2568*(y) - 0x0c92*(v) - 0x1a1e*(u)) /0x2000
  27. #define _B(y,u,v) (0x2568*(y) + 0x40cf*(v))      /0x2000
  29. struct lookuptable
  30. {
  31.     int32_t m_plY[256];
  32.     int32_t m_plRV[256];
  33.     int32_t m_plGV[256];
  34.     int32_t m_plGU[256];
  35.     int32_t m_plBU[256];
  36. };
  37. static struct lookuptable lut;
  38. void init_yuv2rgb()
  39. {
  40.     int i;
  41.     for(i=0; i<256; i++)
  42.     {
  43. if(i>=16)
  44.     if(i>240)
  45. lut.m_plY[i]=lut.m_plY[240];
  46.     else
  47. lut.m_plY[i]=298*(i-16);
  48. else
  49.     lut.m_plY[i]=0;
  50. if((i>=16) && (i<=240))
  51. {
  52.     lut.m_plRV[i]=408*(i-128);
  53.     lut.m_plGV[i]=-208*(i-128);
  54.     lut.m_plGU[i]=-100*(i-128);
  55.     lut.m_plBU[i]=517*(i-128);
  56. }
  57. else if(i<16)
  58. {
  59.     lut.m_plRV[i]=408*(16-128);
  60.     lut.m_plGV[i]=-208*(16-128);
  61.     lut.m_plGU[i]=-100*(16-128);
  62.     lut.m_plBU[i]=517*(16-128);
  63. }
  64. else
  65. {
  66.     lut.m_plRV[i]=lut.m_plRV[240];
  67.     lut.m_plGV[i]=lut.m_plGV[240];
  68.     lut.m_plGU[i]=lut.m_plGU[240];
  69.     lut.m_plBU[i]=lut.m_plBU[240];
  70. }
  71.     }
  72. }
  76. void yuv2rgb_32(uint8_t *puc_y, int stride_y, 
  77.                 uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  78.                 uint8_t *puc_out, int width_y, int height_y,
  79. unsigned int _stride_out) 
  80. {
  82. int x, y;
  83. int stride_diff = 4 * (_stride_out - width_y);
  85. if (height_y < 0) {
  87. height_y  = -height_y;
  88. puc_y     += (height_y   - 1) * stride_y ;
  89. puc_u     += (height_y/2 - 1) * stride_uv;
  90. puc_v     += (height_y/2 - 1) * stride_uv;
  91. stride_y  = -stride_y;
  92. stride_uv = -stride_uv;
  93. }
  95. for (y=0; y<height_y; y++) 
  96. {
  97. for (x=0; x<width_y; x++)
  98. {
  99. signed int _r,_g,_b; 
  100. signed int r, g, b;
  101. signed int y, u, v;
  103. y = puc_y[x] - 16;
  104. u = puc_u[x>>1] - 128;
  105. v = puc_v[x>>1] - 128;
  107. _r = _R(y,u,v);
  108. _g = _G(y,u,v);
  109. _b = _B(y,u,v);
  111. r = _S(_r);
  112. g = _S(_g);
  113. b = _S(_b);
  115. puc_out[0] = r;
  116. puc_out[1] = g;
  117. puc_out[2] = b;
  118. puc_out[3] = 0;
  120. puc_out+=4;
  121. }
  123. puc_y   += stride_y;
  124. if (y%2) {
  125. puc_u   += stride_uv;
  126. puc_v   += stride_uv;
  127. }
  128. puc_out += stride_diff;
  129. }
  130. }
  133. void yuv2rgb_24(uint8_t *puc_y, int stride_y, 
  134.                 uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  135.                 uint8_t *puc_out, int width_y, int height_y,
  136. unsigned int _stride_out) 
  137. {
  139. int x, y;
  140. int stride_diff = 6*_stride_out - 3*width_y;
  142. if (height_y < 0) {
  144. height_y  = -height_y;
  145. puc_y     += (height_y   - 1) * stride_y ;
  146. puc_u     += (height_y/2 - 1) * stride_uv;
  147. puc_v     += (height_y/2 - 1) * stride_uv;
  148. stride_y  = -stride_y;
  149. stride_uv = -stride_uv;
  150. }
  152. for (y=0; y<height_y; y+=2) 
  153. {
  154. uint8_t* pY=puc_y;
  155. uint8_t* pY1=puc_y+stride_y;
  156. uint8_t* pU=puc_u;
  157. uint8_t* pV=puc_v;
  158. uint8_t* pOut2=puc_out+3*_stride_out;
  159. for (x=0; x<width_y; x+=2)
  160. {
  161. int R, G, B;
  162. int Y;
  163. unsigned int tmp;
  164. R=lut.m_plRV[*pU];
  165. G=lut.m_plGV[*pU];
  166. pU++;
  167. G+=lut.m_plGU[*pV];
  168. B=lut.m_plBU[*pV];
  169. pV++;
  170. #define PUT_COMPONENT(p,v,i) 
  171.     tmp=(unsigned int)(v); 
  172.     if(tmp < 0x10000) 
  173. p[i]=tmp>>8; 
  174.     else
  175. p[i]=(tmp >> 24) ^ 0xff; 
  176. Y=lut.m_plY[*pY];
  177. pY++;
  178. PUT_COMPONENT(puc_out, R+Y, 0);
  179. PUT_COMPONENT(puc_out, G+Y, 1);
  180. PUT_COMPONENT(puc_out, B+Y, 2);
  181. Y=lut.m_plY[*pY];
  182. pY++;
  183. PUT_COMPONENT(puc_out, R+Y, 3);
  184. PUT_COMPONENT(puc_out, G+Y, 4);
  185. PUT_COMPONENT(puc_out, B+Y, 5);
  186. Y=lut.m_plY[*pY1];
  187. pY1++;
  188. PUT_COMPONENT(pOut2, R+Y, 0);
  189. PUT_COMPONENT(pOut2, G+Y, 1);
  190. PUT_COMPONENT(pOut2, B+Y, 2);
  191. Y=lut.m_plY[*pY1];
  192. pY1++;
  193. PUT_COMPONENT(pOut2, R+Y, 3);
  194. PUT_COMPONENT(pOut2, G+Y, 4);
  195. PUT_COMPONENT(pOut2, B+Y, 5);
  196. puc_out+=6;
  197. pOut2+=6;
  198. }
  200. puc_y   += 2*stride_y;
  201. puc_u   += stride_uv;
  202. puc_v   += stride_uv;
  203. puc_out += stride_diff;
  204. }
  205. }
  207. /***/
  209. #define _S(a) (a)>255 ? 255 : (a)<0 ? 0 : (a)
  211. #define _R(y,u,v) (0x2568*(y)          + 0x3343*(u)) /0x2000
  212. #define _G(y,u,v) (0x2568*(y) - 0x0c92*(v) - 0x1a1e*(u)) /0x2000
  213. #define _B(y,u,v) (0x2568*(y) + 0x40cf*(v))      /0x2000
  215. #define _mR 0x7c00
  216. #define _mG 0x03e0
  217. #define _mB 0x001f
  219. #define _Ps555(r,g,b) (((r) << 7) & _mR) | (((g) << 2) & _mG) | (((b) >> 3) & _mB)
  221. #define _Ps565(r,g,b) ( ((r & 0xF8) >> 3) | (((g & 0xF8) << 3)) | (((b & 0xF8) << 8)) )
  223. void yuv2rgb_555(uint8_t *puc_y, int stride_y, 
  224.                 uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  225.                 uint8_t *puc_out, int width_y, int height_y,
  226. unsigned int _stride_out) 
  227. {
  229. int x, y;
  230. unsigned short *pus_out;
  231. int stride_diff = _stride_out - width_y; 
  233. if (height_y < 0) {
  235. height_y  = -height_y;
  236. puc_y     += (height_y   - 1) * stride_y ;
  237. puc_u     += (height_y/2 - 1) * stride_uv;
  238. puc_v     += (height_y/2 - 1) * stride_uv;
  239. stride_y  = -stride_y;
  240. stride_uv = -stride_uv;
  241. }
  243. pus_out = (unsigned short *) puc_out;
  245. for (y=0; y<height_y; y++) 
  246. {
  247. for (x=0; x<width_y; x++)
  248. {
  249. signed int _r,_g,_b; 
  250. signed int r, g, b;
  251. signed int y, u, v;
  253. y = puc_y[x] - 16;
  254. u = puc_u[x>>1] - 128;
  255. v = puc_v[x>>1] - 128;
  257. _r = _R(y,u,v);
  258. _g = _G(y,u,v);
  259. _b = _B(y,u,v);
  261. r = _S(_r);
  262. g = _S(_g);
  263. b = _S(_b);
  265. pus_out[0] = _Ps555(b,g,r);
  267. pus_out++;
  268. }
  270. puc_y   += stride_y;
  271. if (y%2) {
  272. puc_u   += stride_uv;
  273. puc_v   += stride_uv;
  274. }
  275. pus_out += stride_diff;
  276. }
  277. }
  279. /***/
  281. void yuv2rgb_565(uint8_t *puc_y, int stride_y, 
  282.                 uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  283.                 uint8_t *puc_out, int width_y, int height_y,
  284. unsigned int _stride_out) 
  285. {
  287. int x, y;
  288. unsigned short *pus_out;
  289. int stride_diff = _stride_out - width_y; 
  291. if (height_y < 0) {
  293. height_y  = -height_y;
  294. puc_y     += (height_y   - 1) * stride_y ;
  295. puc_u     += (height_y/2 - 1) * stride_uv;
  296. puc_v     += (height_y/2 - 1) * stride_uv;
  297. stride_y  = -stride_y;
  298. stride_uv = -stride_uv;
  299. }
  300. pus_out = (unsigned short *) puc_out;
  302. for (y=0; y<height_y; y++) 
  303. {
  304. for (x=0; x<width_y; x++)
  305. {
  306. signed int _r,_g,_b; 
  307. signed int r, g, b;
  308. signed int y, u, v;
  310. y = puc_y[x] - 16;
  311. u = puc_u[x>>1] - 128;
  312. v = puc_v[x>>1] - 128;
  314. _r = _R(y,u,v);
  315. _g = _G(y,u,v);
  316. _b = _B(y,u,v);
  318. r = _S(_r);
  319. g = _S(_g);
  320. b = _S(_b);
  322. pus_out[0] = (unsigned short) _Ps565(r,g,b);
  324. pus_out++;
  325. }
  327. puc_y   += stride_y;
  328. if (y%2) {
  329. puc_u   += stride_uv;
  330. puc_v   += stride_uv;
  331. }
  332. pus_out += stride_diff;
  333. }
  334. }
  337. void yuy2_out(uint8_t *puc_y, int stride_y, 
  338.   uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  339.   uint8_t *puc_out, int width_y, int height_y,
  340. unsigned int stride_out) 
  341. { 
  342. int y;
  343. uint8_t* puc_out2;
  344. unsigned int stride_diff = 4 * stride_out - 2 * width_y; 
  345. if (height_y < 0) {
  347. height_y  = -height_y;
  348. puc_y     += (height_y   - 1) * stride_y ;
  349. puc_u     += (height_y/2 - 1) * stride_uv;
  350. puc_v     += (height_y/2 - 1) * stride_uv;
  351. stride_y  = -stride_y;
  352. stride_uv = -stride_uv;
  353. }
  354. puc_out2 = puc_out + 2 * stride_out;
  355. for (y=height_y/2; y; y--) {
  356. register uint8_t *py, *py2, *pu, *pv;
  357. register int x;
  358. uint32_t tmp;
  360. py = puc_y;
  361. py2 = puc_y + stride_y;
  362. pu = puc_u;
  363. pv = puc_v;
  364. for (x=width_y/2; x; x--) {
  365. tmp = *(py++);
  366. tmp |= *(pu++) << 8;
  367. tmp |= *(py++) << 16;
  368. tmp |= *(pv++) << 24;
  369. *(uint32_t*)puc_out=tmp;
  370. puc_out += 4;
  372. tmp &= 0xFF00FF00;
  373. tmp |= *(py2++);
  374. tmp |= *(py2++) << 16;
  375. *(uint32_t*)puc_out2=tmp;
  376. puc_out2 += 4;
  377. }
  379. puc_y += 2*stride_y;
  380. puc_u += stride_uv;
  381. puc_v += stride_uv;
  383. puc_out += stride_diff;
  384. puc_out2 += stride_diff;
  385. }
  387. }
  390. void uyvy_out(uint8_t *puc_y, int stride_y, 
  391.   uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  392.   uint8_t *puc_out, int width_y, int height_y,
  393. unsigned int stride_out) 
  394. { 
  395. int y;
  396. uint8_t* puc_out2;
  397. unsigned int stride_diff = 4 * stride_out - 2 * width_y; 
  399. if (height_y < 0) {
  401. height_y  = -height_y;
  402. puc_y     += (height_y   - 1) * stride_y ;
  403. puc_u     += (height_y/2 - 1) * stride_uv;
  404. puc_v     += (height_y/2 - 1) * stride_uv;
  405. stride_y  = -stride_y;
  406. stride_uv = -stride_uv;
  407. }
  408. puc_out2 = puc_out + 2 * stride_out;
  409. for (y=height_y/2; y; y--) {
  410. register uint8_t *py, *py2, *pu, *pv;
  411. register int x;
  412. uint32_t tmp;
  414. py = puc_y;
  415. py2 = puc_y + stride_y;
  416. pu = puc_u;
  417. pv = puc_v;
  418. for (x=width_y/2; x; x--) {
  419. tmp = *(pu++);
  420. tmp |= *(py++) << 8;
  421. tmp |= *(pv++) << 16;
  422. tmp |= *(py++) << 24;
  423. *(uint32_t*)puc_out=tmp;
  424. puc_out += 4;
  426. tmp &= 0x00FF00FF;
  427. tmp |= *(py2++) << 8;
  428. tmp |= *(py2++) << 24;
  429. *(uint32_t*)puc_out2=tmp;
  430. puc_out2 += 4;
  431. }
  433. puc_y += 2*stride_y;
  434. puc_u += stride_uv;
  435. puc_v += stride_uv;
  437. puc_out += stride_diff;
  438. puc_out2 += stride_diff;
  439. }
  441. }
  446. void yuv12_out(uint8_t *puc_y, int stride_y, 
  447.   uint8_t *puc_u, uint8_t *puc_v, int stride_uv, 
  448.   uint8_t *puc_out, int width_y, int height_y,
  449. unsigned int stride_out) 
  450. { 
  451. int i;
  453. unsigned char * pauc_out[3];
  455. if (height_y < 0) {
  456. height_y = -height_y;
  457. puc_y     += (height_y   - 1) * stride_y ;
  458. puc_u     += (height_y/2 - 1) * stride_uv;
  459. puc_v     += (height_y/2 - 1) * stride_uv;
  460. stride_y  = -stride_y;
  461. stride_uv = -stride_uv;
  462. }
  464. pauc_out[0] = puc_out;
  465. pauc_out[1] = puc_out + stride_out * height_y;
  466. pauc_out[2] = puc_out + stride_out * height_y * 5 / 4;
  468. for (i=0; i<height_y; i++) {
  470. memcpy(pauc_out[0], puc_y, width_y);
  472. pauc_out[0] += stride_out;
  473. puc_y += stride_y;
  474. }
  476. for (i=0; i<height_y/2; i++) {
  478. memcpy(pauc_out[2], puc_u, width_y/2); 
  479. memcpy(pauc_out[1], puc_v, width_y/2);
  481. pauc_out[1] += stride_out/2;
  482. pauc_out[2] += stride_out/2;
  483. puc_u += stride_uv;
  484. puc_v += stride_uv;
  485. }
  486. }