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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
colorspace.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：27k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

colorspace.c：源码内容
  1. /**************************************************************************
  2.  *
  3.  * XVID MPEG-4 VIDEO CODEC
  4.  * colorspace conversions
  5.  *
  6.  * This program is an implementation of a part of one or more MPEG-4
  7.  * Video tools as specified in ISO/IEC 14496-2 standard.  Those intending
  8.  * to use this software module in hardware or software products are
  9.  * advised that its use may infringe existing patents or copyrights, and
  10.  * any such use would be at such party's own risk.  The original
  11.  * developer of this software module and his/her company, and subsequent
  12.  * editors and their companies, will have no liability for use of this
  13.  * software or modifications or derivatives thereof.
  14.  *
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2 of the License, or
  18.  * (at your option) any later version.
  19.  *
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU General Public License for more details.
  24.  *
  25.  * You should have received a copy of the GNU General Public License
  26.  * along with this program; if not, write to the Free Software
  27.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28.  *
  29.  *************************************************************************/
  31. /**************************************************************************
  32.  *
  33.  * History:
  34.  *
  35.  * 30.02.2002 out_yuv dst_stride2 fix
  36.  * 26.02.2002 rgb555, rgb565
  37.  * 24.11.2001 accuracy improvement to yuyv/vyuy conversion
  38.  * 28.10.2001 total rewrite <pross@cs.rmit.edu.au>
  39.  *
  40.  **************************************************************************/
  42. #include <string.h> // memcpy
  44. #include "colorspace.h"
  46. // function pointers
  48. /* input */
  49. color_inputFuncPtr rgb555_to_yv12;
  50. color_inputFuncPtr rgb565_to_yv12;
  51. color_inputFuncPtr rgb24_to_yv12;
  52. color_inputFuncPtr rgb32_to_yv12;
  53. color_inputFuncPtr yuv_to_yv12;
  54. color_inputFuncPtr yuyv_to_yv12;
  55. color_inputFuncPtr uyvy_to_yv12;
  57. /* output */
  58. color_outputFuncPtr yv12_to_rgb555;
  59. color_outputFuncPtr yv12_to_rgb565;
  60. color_outputFuncPtr yv12_to_rgb24;
  61. color_outputFuncPtr yv12_to_rgb32;
  62. color_outputFuncPtr yv12_to_yuv;
  63. color_outputFuncPtr yv12_to_yuyv;
  64. color_outputFuncPtr yv12_to_uyvy;
  66. #define MIN(A,B) ((A)<(B)?(A):(B))
  67. #define MAX(A,B) ((A)>(B)?(A):(B))
  69. /* rgb -> yuv def's
  71. this following constants are "official spec"
  72. Video Demystified" (ISBN 1-878707-09-4)
  74. rgb<->yuv _is_ lossy, since most programs do the conversion differently
  76. SCALEBITS/FIX taken from  ffmpeg
  77. */
  79. #define Y_R_IN 0.257
  80. #define Y_G_IN 0.504
  81. #define Y_B_IN 0.098
  82. #define Y_ADD_IN 16
  84. #define U_R_IN 0.148
  85. #define U_G_IN 0.291
  86. #define U_B_IN 0.439
  87. #define U_ADD_IN 128
  89. #define V_R_IN 0.439
  90. #define V_G_IN 0.368
  91. #define V_B_IN 0.071
  92. #define V_ADD_IN 128
  94. #define SCALEBITS_IN 8
  95. #define FIX_IN(x) ((uint16_t) ((x) * (1L<<SCALEBITS_IN) + 0.5))
  98. int32_t RGB_Y_tab[256];
  99. int32_t B_U_tab[256];
  100. int32_t G_U_tab[256];
  101. int32_t G_V_tab[256];
  102. int32_t R_V_tab[256];
  105. /* rgb555 -> yuv 4:2:0 planar */
  106. void rgb555_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  107. uint8_t *src, int width, int height, int y_stride)
  108. {
  109. int32_t src_stride = width * 2;
  110. uint32_t y_dif = y_stride - width;
  111. uint32_t uv_dif = (y_stride - width) / 2;
  112. uint32_t x, y;
  114. if (height < 0)
  115. {
  116. height = -height;
  117. src += (height - 1) * src_stride;
  118. src_stride = -src_stride;
  119. }
  122. for (y = height / 2; y; y--) 
  123. {
  124. // process one 2x2 block per iteration
  125. for (x = 0; x < (uint32_t)width; x += 2)
  126. {
  127. int rgb, r, g, b, r4, g4, b4;
  129. rgb = *(uint16_t*)(src+x*2);
  130. b4 = b = (rgb << 3) & 0xf8;
  131. g4 = g = (rgb >> 2) & 0xf8;
  132. r4 = r = (rgb >> 7) & 0xf8;
  133.             y_out[0] =(uint8_t)((
  134.   FIX_IN(Y_R_IN) * r 
  135. + FIX_IN(Y_G_IN) * g 
  136. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  138. rgb = *(uint16_t*)(src+x*2+src_stride);
  139. b4 += b = (rgb << 3) & 0xf8;
  140. g4 += g = (rgb >> 2) & 0xf8;
  141. r4 += r = (rgb >> 7) & 0xf8;
  142.             y_out[y_stride] =(uint8_t)((
  143.   FIX_IN(Y_R_IN) * r 
  144. + FIX_IN(Y_G_IN) * g 
  145. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  147. rgb = *(uint16_t*)(src+x*2+2);
  148. b4 += b = (rgb << 3) & 0xf8;
  149. g4 += g = (rgb >> 2) & 0xf8;
  150. r4 += r = (rgb >> 7) & 0xf8;
  151.             y_out[1] =(uint8_t)((
  152.   FIX_IN(Y_R_IN) * r 
  153. + FIX_IN(Y_G_IN) * g 
  154. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  156. rgb = *(uint16_t*)(src+x*2+src_stride+2);
  157. b4 += b = (rgb << 3) & 0xf8;
  158. g4 += g = (rgb >> 2) & 0xf8;
  159. r4 += r = (rgb >> 7) & 0xf8;
  160.             y_out[y_stride + 1] =(uint8_t)((
  161.   FIX_IN(Y_R_IN) * r 
  162. + FIX_IN(Y_G_IN) * g 
  163. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  165. *u_out++ = (uint8_t)((
  166. - FIX_IN(U_R_IN) * r4 
  167. - FIX_IN(U_G_IN) * g4
  168. + FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) + U_ADD_IN;
  171.             *v_out++ = (uint8_t)((
  172.   FIX_IN(V_R_IN) * r4
  173. - FIX_IN(V_G_IN) * g4
  174. - FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) + V_ADD_IN; 
  176. y_out += 2;
  177. }
  178. src += src_stride * 2;
  179. y_out += y_dif + y_stride;
  180. u_out += uv_dif;
  181. v_out += uv_dif;
  182. }
  183. }
  187. /* rgb565_to_yuv_c
  188. NOTE: identical to rgb555 except for shift/mask 
  189. not tested */
  191. void rgb565_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  192. uint8_t *src, int width, int height, int y_stride)
  193. {
  194. int32_t src_stride = width * 2;
  196. uint32_t y_dif = y_stride - width;
  197. uint32_t uv_dif = (y_stride - width) / 2;
  198. uint32_t x, y;
  200. if (height < 0)
  201. {
  202. height = -height;
  203. src += (height - 1) * src_stride;
  204. src_stride = -src_stride;
  205. }
  208. for (y = height / 2; y; y--) 
  209. {
  210. // process one 2x2 block per iteration
  211. for (x = 0; x < (uint32_t)width; x += 2)
  212. {
  213. int rgb, r, g, b, r4, g4, b4;
  215. rgb = *(uint16_t*)(src+x*2);
  216. b4 = b = (rgb << 3) & 0xf8;
  217. g4 = g = (rgb >> 3) & 0xfc;
  218. r4 = r = (rgb >> 8) & 0xf8;
  219.             y_out[0] =(uint8_t)((
  220.   FIX_IN(Y_R_IN) * r 
  221. + FIX_IN(Y_G_IN) * g 
  222. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  224. rgb = *(uint16_t*)(src+x*2+src_stride);
  225. b4 += b = (rgb << 3) & 0xf8;
  226. g4 += g = (rgb >> 3) & 0xfc;
  227. r4 += r = (rgb >> 8) & 0xf8;
  228.             y_out[y_stride] =(uint8_t)((
  229.   FIX_IN(Y_R_IN) * r 
  230. + FIX_IN(Y_G_IN) * g 
  231. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  233. rgb = *(uint16_t*)(src+x*2+2);
  234. b4 += b = (rgb << 3) & 0xf8;
  235. g4 += g = (rgb >> 3) & 0xfc;
  236. r4 += r = (rgb >> 8) & 0xf8;
  237.             y_out[1] =(uint8_t)((
  238.   FIX_IN(Y_R_IN) * r 
  239. + FIX_IN(Y_G_IN) * g 
  240. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  242. rgb = *(uint16_t*)(src+x*2+src_stride+2);
  243. b4 += b = (rgb << 3) & 0xf8;
  244. g4 += g = (rgb >> 3) & 0xfc;
  245. r4 += r = (rgb >> 8) & 0xf8;
  246.             y_out[y_stride + 1] =(uint8_t)((
  247.   FIX_IN(Y_R_IN) * r 
  248. + FIX_IN(Y_G_IN) * g 
  249. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  251. *u_out++ = (uint8_t)((
  252. - FIX_IN(U_R_IN) * r4 
  253. - FIX_IN(U_G_IN) * g4
  254. + FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) + U_ADD_IN;
  257.             *v_out++ = (uint8_t)((
  258.   FIX_IN(V_R_IN) * r4
  259. - FIX_IN(V_G_IN) * g4
  260. - FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) + V_ADD_IN; 
  262. y_out += 2;
  263. }
  264. src += src_stride * 2;
  265. y_out += y_dif + y_stride;
  266. u_out += uv_dif;
  267. v_out += uv_dif;
  268. }
  269. }
  274. /* rgb24 -> yuv 4:2:0 planar 
  276. NOTE: always flips.
  277. */
  279. void rgb24_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  280. uint8_t *src, int width, int height, int stride)
  281. {
  282.     uint32_t width3 = (width << 1) + width; /* width * 3 */
  283. uint32_t src_dif = (width << 3) + width; /* width3 * 3 */
  284. uint32_t y_dif = (stride << 1) - width;
  285. uint32_t uv_dif = (stride - width) >> 1;
  286.     uint32_t x, y;
  288. src += (height - 2) * width3;
  291.     for(y = height >> 1; y; y--) {
  292. for(x = width >> 1; x; x--) {
  293. uint32_t r, g, b, r4, g4, b4;
  295.             b4 = b = src[0];
  296.             g4 = g = src[1];
  297.             r4 = r = src[2];
  298.             y_out[stride + 0] =(uint8_t)((
  299.   FIX_IN(Y_R_IN) * r 
  300. + FIX_IN(Y_G_IN) * g 
  301. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN; 
  303.             b4 += (b = src[3]);
  304.             g4 += (g = src[4]);
  305.             r4 += (r = src[5]);
  306.             y_out[stride + 1] = (uint8_t)((
  307.   FIX_IN(Y_R_IN) * r 
  308. + FIX_IN(Y_G_IN) * g 
  309. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  311.             b4 += (b = src[width3 + 0]);
  312.             g4 += (g = src[width3 + 1]);
  313.             r4 += (r = src[width3 + 2]);
  314.             y_out[0] = (uint8_t)((
  315. FIX_IN(Y_R_IN) * r + 
  316. FIX_IN(Y_G_IN) * g + 
  317. FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  319.             b4 += (b = src[width3 + 3]);
  320.             g4 += (g = src[width3 + 4]);
  321.             r4 += (r = src[width3 + 5]);
  322.             y_out[1] = (uint8_t)((
  323.   FIX_IN(Y_R_IN) * r
  324. + FIX_IN(Y_G_IN) * g
  325. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  326.             
  327. *u_out++ = (uint8_t)((
  328. - FIX_IN(U_R_IN) * r4 
  329. - FIX_IN(U_G_IN) * g4
  330. + FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) + U_ADD_IN;
  333.             *v_out++ = (uint8_t)((
  334.   FIX_IN(V_R_IN) * r4
  335. - FIX_IN(V_G_IN) * g4
  336. - FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) + V_ADD_IN; 
  339. src += 6;
  340. y_out += 2;
  341. }
  342. src -= src_dif;
  343. y_out += y_dif;
  344. u_out += uv_dif;
  345. v_out += uv_dif;
  346.     }
  347. }
  350. /* rgb32 -> yuv 4:2:0 planar 
  352. NOTE: always flips
  353. */
  355. void rgb32_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  356. uint8_t *src, int width, int height, int stride)
  357. {
  358.     uint32_t width4 = (width << 2); /* width * 4 */
  359. uint32_t src_dif = 3 * width4;
  360. uint32_t y_dif = (stride << 1) - width;
  361. uint32_t uv_dif = (stride - width) >> 1;
  362.     uint32_t x, y;
  364. src += (height - 2) * width4;
  366.     for(y = height >> 1; y; y--) {
  367. for(x = width >> 1; x; x--) {
  368. uint32_t r, g, b, r4, g4, b4;
  370.             b4 = b = src[0];
  371.             g4 = g = src[1];
  372.             r4 = r = src[2];
  373.             y_out[stride + 0] =(uint8_t)((
  374.   FIX_IN(Y_R_IN) * r 
  375. + FIX_IN(Y_G_IN) * g 
  376. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  378.             b4 += (b = src[4]);
  379.             g4 += (g = src[5]);
  380.             r4 += (r = src[6]);
  381.             y_out[stride + 1] =(uint8_t)((
  382.   FIX_IN(Y_R_IN) * r 
  383. + FIX_IN(Y_G_IN) * g 
  384. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  386.             b4 += (b = src[width4 + 0]);
  387.             g4 += (g = src[width4 + 1]);
  388.             r4 += (r = src[width4 + 2]);
  390.             y_out[0] =(uint8_t)((
  391.   FIX_IN(Y_R_IN) * r 
  392. + FIX_IN(Y_G_IN) * g 
  393. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  394.             
  395.             b4 += (b = src[width4 + 4]);
  396.             g4 += (g = src[width4 + 5]);
  397.             r4 += (r = src[width4 + 6]);
  398.             y_out[1] =(uint8_t)((
  399.   FIX_IN(Y_R_IN) * r 
  400. + FIX_IN(Y_G_IN) * g 
  401. + FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;
  402.             
  403. *u_out++ = (uint8_t)((
  404. - FIX_IN(U_R_IN) * r4 
  405. - FIX_IN(U_G_IN) * g4
  406. + FIX_IN(U_B_IN) * b4) >> (SCALEBITS_IN + 2)) + U_ADD_IN;
  408.             *v_out++ = (uint8_t)((
  409.   FIX_IN(V_R_IN) * r4
  410. - FIX_IN(V_G_IN) * g4
  411. - FIX_IN(V_B_IN) * b4) >> (SCALEBITS_IN + 2)) + V_ADD_IN;
  413. src += 8;
  414. y_out += 2;
  415. }
  416. src -= src_dif;
  417. y_out += y_dif;
  418. u_out += uv_dif;
  419. v_out += uv_dif;
  420.     }
  421. }
  423. /* yuv planar -> yuv 4:2:0 planar
  424.    
  425. NOTE: does not flip */
  427. void yuv_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  428. uint8_t *src, int width, int height, int stride)
  429. {
  430. uint32_t stride2 = stride >> 1;
  431. uint32_t width2 = width >> 1;
  432.     uint32_t y;
  434. for (y = height; y; y--) {
  435.     memcpy(y_out, src, width);
  436.     src += width;
  437. y_out += stride;
  438. }
  440. for (y = height >> 1; y; y--) {
  441.     memcpy(u_out, src, width2);
  442. src += width2;
  443. u_out += stride2;
  444. }
  446. for (y = height >> 1; y; y--) {
  447.     memcpy(v_out, src, width2);
  448. src += width2;
  449. v_out+= stride2;
  450. }
  451. }
  453. #ifdef MPEG4IP
  454. void yuv_to_yv12_clip_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  455. uint8_t *src, int width, int height, int raw_height, int stride)
  456. {
  457. uint32_t stride2 = stride >> 1;
  458. uint32_t width2 = width >> 1;
  459.     uint32_t y;
  460. uint32_t yoffset = ((raw_height - height) / 2) * width;
  462. src += yoffset;
  464. for (y = height; y; y--) {
  465.     memcpy(y_out, src, width);
  466.     src += width;
  467. y_out += stride;
  468. }
  470. src += yoffset + (yoffset / 4);
  472. for (y = height >> 1; y; y--) {
  473.     memcpy(u_out, src, width2);
  474. src += width2;
  475. u_out += stride2;
  476. }
  478. src += yoffset / 2;
  480. for (y = height >> 1; y; y--) {
  481.     memcpy(v_out, src, width2);
  482. src += width2;
  483. v_out+= stride2;
  484. }
  485. }
  486. #endif
  489. /* yuyv (yuv2) packed -> yuv 4:2:0 planar
  490.    
  491.    NOTE: does not flip */
  493. void yuyv_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  494. uint8_t *src, int width, int height, int stride)
  495. {
  496. uint32_t width2 = width + width;
  497. uint32_t y_dif = stride - width;
  498. uint32_t uv_dif = y_dif >> 1;
  499. uint32_t x, y;
  501. for (y = height >> 1; y; y--) {
  502.         
  503. for (x = width >> 1; x; x--) {
  504.             *y_out++ = *src++;
  505. //*u_out++ = *src++;
  506. *u_out++ = (*(src+width2) + *src) >> 1; src++;
  507. *y_out++ = *src++;
  508. //*v_out++ = *src++;
  509. *v_out++ = (*(src+width2) + *src) >> 1; src++;
  511. }
  513. y_out += y_dif;
  514. u_out += uv_dif;
  515. v_out += uv_dif; 
  517. for (x = width >> 1; x; x--) {
  518. *y_out++ = *src++;
  519. src++;
  520. *y_out++ = *src++;
  521. src++;
  522. }
  524. y_out += y_dif;
  526.     }
  528. }
  532. /* uyvy packed -> yuv 4:2:0 planar
  533.    
  534.    NOTE: does not flip */
  537. void uyvy_to_yv12_c(uint8_t *y_out, uint8_t *u_out, uint8_t *v_out,
  538. uint8_t *src, int width, int height, int stride)
  539. {
  540. uint32_t width2 = width + width;
  541. uint32_t y_dif = stride - width;
  542. uint32_t uv_dif = y_dif >> 1;
  543.     uint32_t x, y;
  545. for (y = height >> 1; y; y--) {
  546.         
  547. for (x = width >> 1; x; x--) {
  548. *u_out++ = *src++;
  549.             // *u_out++ = (*(src+width2) + *src++) >> 1;
  550. *y_out++ = *src++;
  551. //*v_out++ = *src++;
  552. *v_out++ = (*(src+width2) + *src) >> 1; src++;
  553. *y_out++ = *src++;
  554.          }
  556. y_out += y_dif;
  557. u_out += uv_dif;;
  558. v_out += uv_dif;; 
  560. for (x = width >> 1; x; x--) {
  561. src++;
  562. *y_out++ = *src++;
  563. src++;
  564. *y_out++ = *src++;
  565. }
  567. y_out += y_dif;
  568.     }
  569. }
  572. /* yuv -> rgb def's */
  574. #define RGB_Y_OUT 1.164
  575. #define B_U_OUT 2.018
  576. #define Y_ADD_OUT 16
  578. #define G_U_OUT 0.391
  579. #define G_V_OUT 0.813
  580. #define U_ADD_OUT 128
  582. #define R_V_OUT 1.596
  583. #define V_ADD_OUT 128
  586. #define SCALEBITS_OUT 13
  587. #define FIX_OUT(x) ((uint16_t) ((x) * (1L<<SCALEBITS_OUT) + 0.5))
  590. /* initialize rgb lookup tables */
  592. void colorspace_init(void) {
  593. int32_t i;
  595.     for(i = 0; i < 256; i++) {
  596. RGB_Y_tab[i] = FIX_OUT(RGB_Y_OUT) * (i - Y_ADD_OUT);
  597. B_U_tab[i] = FIX_OUT(B_U_OUT) * (i - U_ADD_OUT);
  598. G_U_tab[i] = FIX_OUT(G_U_OUT) * (i - U_ADD_OUT);
  599. G_V_tab[i] = FIX_OUT(G_V_OUT) * (i - V_ADD_OUT);
  600. R_V_tab[i] = FIX_OUT(R_V_OUT) * (i - V_ADD_OUT);
  601. }
  602. }
  604. /* yuv 4:2:0 planar -> rgb555 + very simple error diffusion
  605. */
  607. #define MK_RGB555(R,G,B) ((MAX(0,MIN(255, R)) << 7) & 0x7c00) | 
  608. ((MAX(0,MIN(255, G)) << 2) & 0x03e0) | 
  609. ((MAX(0,MIN(255, B)) >> 3) & 0x001f)
  612. void yv12_to_rgb555_c(uint8_t *dst, int dst_stride,
  613.  uint8_t *y_src, uint8_t *u_src, uint8_t * v_src, 
  614.  int y_stride, int uv_stride,
  615.  int width, int height)
  616. {
  617. const uint32_t dst_dif = 4 * dst_stride - 2 * width;
  618. int32_t y_dif = 2 * y_stride - width;
  620. uint8_t *dst2 = dst + 2 * dst_stride;
  621. uint8_t *y_src2 = y_src + y_stride;
  622. uint32_t x, y;
  624. if (height < 0) {
  625. height = -height;
  626. y_src += (height - 1) * y_stride;
  627. y_src2 = y_src - y_stride;
  628. u_src += (height / 2 - 1) * uv_stride;
  629. v_src += (height / 2 - 1) * uv_stride;
  630. y_dif = -width - 2 * y_stride;
  631. uv_stride = -uv_stride;
  632. }
  634. for (y = height / 2; y; y--) 
  635. {
  636. int r, g, b;
  637. int r2, g2, b2;
  639. r = g = b = 0;
  640. r2 = g2 = b2 = 0;
  642. // process one 2x2 block per iteration
  643. for (x = 0; x < (uint32_t)width / 2; x++)
  644. {
  645. int u, v;
  646. int b_u, g_uv, r_v, rgb_y;
  648. u = u_src[x];
  649. v = v_src[x];
  651. b_u = B_U_tab[u];
  652. g_uv = G_U_tab[u] + G_V_tab[v];
  653. r_v = R_V_tab[v];
  655. rgb_y = RGB_Y_tab[*y_src];
  656. b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  657. g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  658. r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  659. *(uint16_t*)dst = MK_RGB555(r,g,b);
  661. y_src++;
  662. rgb_y = RGB_Y_tab[*y_src];
  663. b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  664. g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  665. r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  666. *(uint16_t*)(dst+2) = MK_RGB555(r,g,b);
  667. y_src++;
  669. rgb_y = RGB_Y_tab[*y_src2];
  670. b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  671. g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  672. r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  673. *(uint16_t*)(dst2) = MK_RGB555(r2,g2,b2);
  674. y_src2++;
  676. rgb_y = RGB_Y_tab[*y_src2];
  677. b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  678. g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  679. r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  680. *(uint16_t*)(dst2+2) = MK_RGB555(r2,g2,b2);
  681. y_src2++;
  683. dst += 4;
  684. dst2 += 4;
  685. }
  687. dst += dst_dif;
  688. dst2 += dst_dif;
  690. y_src += y_dif;
  691. y_src2 += y_dif;
  693. u_src += uv_stride;
  694. v_src += uv_stride;
  695. }
  696. }
  699. /* yuv 4:2:0 planar -> rgb565 + very simple error diffusion
  700. NOTE: identical to rgb555 except for shift/mask  */
  703. #define MK_RGB565(R,G,B) ((MAX(0,MIN(255, R)) << 8) & 0xf800) | 
  704. ((MAX(0,MIN(255, G)) << 3) & 0x07e0) | 
  705. ((MAX(0,MIN(255, B)) >> 3) & 0x001f)
  707. void yv12_to_rgb565_c(uint8_t *dst, int dst_stride,
  708.  uint8_t *y_src, uint8_t *u_src, uint8_t * v_src, 
  709.  int y_stride, int uv_stride,
  710.  int width, int height)
  711. {
  712. const uint32_t dst_dif = 4 * dst_stride - 2 * width;
  713. int32_t y_dif = 2 * y_stride - width;
  715. uint8_t *dst2 = dst + 2 * dst_stride;
  716. uint8_t *y_src2 = y_src + y_stride;
  717. uint32_t x, y;
  719. if (height < 0) { // flip image?
  720. height = -height;
  721. y_src += (height - 1) * y_stride;
  722. y_src2 = y_src - y_stride;
  723. u_src += (height / 2 - 1) * uv_stride;
  724. v_src += (height / 2 - 1) * uv_stride;
  725. y_dif = -width - 2 * y_stride;
  726. uv_stride = -uv_stride;
  727. }
  729. for (y = height / 2; y; y--) 
  730. {
  731. int r, g, b;
  732. int r2, g2, b2;
  734. r = g = b = 0;
  735. r2 = g2 = b2 = 0;
  737. // process one 2x2 block per iteration
  738. for (x = 0; x < (uint32_t)width / 2; x++)
  739. {
  740. int u, v;
  741. int b_u, g_uv, r_v, rgb_y;
  743. u = u_src[x];
  744. v = v_src[x];
  746. b_u = B_U_tab[u];
  747. g_uv = G_U_tab[u] + G_V_tab[v];
  748. r_v = R_V_tab[v];
  750. rgb_y = RGB_Y_tab[*y_src];
  751. b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  752. g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  753. r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  754. *(uint16_t*)dst = MK_RGB565(r,g,b);
  756. y_src++;
  757. rgb_y = RGB_Y_tab[*y_src];
  758. b = (b & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  759. g = (g & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  760. r = (r & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  761. *(uint16_t*)(dst+2) = MK_RGB565(r,g,b);
  762. y_src++;
  764. rgb_y = RGB_Y_tab[*y_src2];
  765. b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  766. g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  767. r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  768. *(uint16_t*)(dst2) = MK_RGB565(r2,g2,b2);
  769. y_src2++;
  771. rgb_y = RGB_Y_tab[*y_src2];
  772. b2 = (b2 & 0x7) + ((rgb_y + b_u) >> SCALEBITS_OUT);
  773. g2 = (g2 & 0x7) + ((rgb_y - g_uv) >> SCALEBITS_OUT);
  774. r2 = (r2 & 0x7) + ((rgb_y + r_v) >> SCALEBITS_OUT);
  775. *(uint16_t*)(dst2+2) = MK_RGB565(r2,g2,b2);
  776. y_src2++;
  778. dst += 4;
  779. dst2 += 4;
  780. }
  782. dst += dst_dif;
  783. dst2 += dst_dif;
  785. y_src += y_dif;
  786. y_src2 += y_dif;
  788. u_src += uv_stride;
  789. v_src += uv_stride;
  790. }
  791. }
  795. /* yuv 4:2:0 planar -> rgb24 */
  797. void yv12_to_rgb24_c(uint8_t *dst, int dst_stride,
  798.  uint8_t *y_src, uint8_t *u_src, uint8_t * v_src, 
  799.  int y_stride, int uv_stride,
  800.  int width, int height)
  801. {
  802. const uint32_t dst_dif = 6 * dst_stride - 3 * width;
  803. int32_t y_dif = 2 * y_stride - width;
  805. uint8_t *dst2 = dst + 3 * dst_stride;
  806. uint8_t *y_src2 = y_src + y_stride;
  807. uint32_t x, y;
  809. if (height < 0) { // flip image?
  810. height = -height;
  811. y_src += (height - 1) * y_stride;
  812. y_src2 = y_src - y_stride;
  813. u_src += (height / 2 - 1) * uv_stride;
  814. v_src += (height / 2 - 1) * uv_stride;
  815. y_dif = -width - 2 * y_stride;
  816. uv_stride = -uv_stride;
  817. }
  819. for (y = height / 2; y; y--) 
  820. {
  821. // process one 2x2 block per iteration
  822. for (x = 0; x < (uint32_t)width / 2; x++)
  823. {
  824. int u, v;
  825. int b_u, g_uv, r_v, rgb_y;
  826. int r, g, b;
  828. u = u_src[x];
  829. v = v_src[x];
  831. b_u = B_U_tab[u];
  832. g_uv = G_U_tab[u] + G_V_tab[v];
  833. r_v = R_V_tab[v];
  835. rgb_y = RGB_Y_tab[*y_src];
  836. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  837. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  838. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  839. dst[0] = MAX(0,MIN(255, b));
  840. dst[1] = MAX(0,MIN(255, g));
  841. dst[2] = MAX(0,MIN(255, r));
  843. y_src++;
  844. rgb_y = RGB_Y_tab[*y_src];
  845. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  846. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  847. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  848. dst[3] = MAX(0,MIN(255, b));
  849. dst[4] = MAX(0,MIN(255, g));
  850. dst[5] = MAX(0,MIN(255, r));
  851. y_src++;
  853. rgb_y = RGB_Y_tab[*y_src2];
  854. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  855. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  856. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  857. dst2[0] = MAX(0,MIN(255, b));
  858. dst2[1] = MAX(0,MIN(255, g));
  859. dst2[2] = MAX(0,MIN(255, r));
  860. y_src2++;
  862. rgb_y = RGB_Y_tab[*y_src2];
  863. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  864. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  865. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  866. dst2[3] = MAX(0,MIN(255, b));
  867. dst2[4] = MAX(0,MIN(255, g));
  868. dst2[5] = MAX(0,MIN(255, r));
  869. y_src2++;
  871. dst += 6;
  872. dst2 += 6;
  873. }
  875. dst += dst_dif;
  876. dst2 += dst_dif;
  878. y_src += y_dif;
  879. y_src2 += y_dif;
  881. u_src += uv_stride;
  882. v_src += uv_stride;
  883. }
  884. }
  888. /* yuv 4:2:0 planar -> rgb32 */
  890. void yv12_to_rgb32_c(uint8_t *dst, int dst_stride,
  891.  uint8_t *y_src, uint8_t *v_src, uint8_t * u_src,
  892.  int y_stride, int uv_stride,
  893.  int width, int height)
  894. {
  895. const uint32_t dst_dif = 8 * dst_stride - 4 * width;
  896. int32_t y_dif = 2 * y_stride - width;
  898. uint8_t *dst2 = dst + 4 * dst_stride;
  899. uint8_t *y_src2 = y_src + y_stride;
  900. uint32_t x, y;
  902. if (height < 0) { // flip image?
  903. height = -height;
  904. y_src += (height - 1) * y_stride;
  905. y_src2 = y_src - y_stride;
  906. u_src += (height / 2 - 1) * uv_stride;
  907. v_src += (height / 2 - 1) * uv_stride;
  908. y_dif = -width - 2 * y_stride;
  909. uv_stride = -uv_stride;
  910. }
  912. for (y = height / 2; y; y--) 
  913. {
  914. // process one 2x2 block per iteration
  915. for (x = 0; x < (uint32_t)width / 2; x++)
  916. {
  917. int u, v;
  918. int b_u, g_uv, r_v, rgb_y;
  919. int r, g, b;
  921. u = u_src[x];
  922. v = v_src[x];
  924. b_u = B_U_tab[u];
  925. g_uv = G_U_tab[u] + G_V_tab[v];
  926. r_v = R_V_tab[v];
  928. rgb_y = RGB_Y_tab[*y_src];
  929. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  930. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  931. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  932. dst[0] = MAX(0,MIN(255, r));
  933. dst[1] = MAX(0,MIN(255, g));
  934. dst[2] = MAX(0,MIN(255, b));
  935. dst[3] = 0;
  937. y_src++;
  938. rgb_y = RGB_Y_tab[*y_src];
  939. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  940. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  941. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  942. dst[4] = MAX(0,MIN(255, r));
  943. dst[5] = MAX(0,MIN(255, g));
  944. dst[6] = MAX(0,MIN(255, b));
  945. dst[7] = 0;
  946. y_src++;
  948. rgb_y = RGB_Y_tab[*y_src2];
  949. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  950. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  951. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  952. dst2[0] = MAX(0,MIN(255, r));
  953. dst2[1] = MAX(0,MIN(255, g));
  954. dst2[2] = MAX(0,MIN(255, b));
  955. dst2[3] = 0;
  956. y_src2++;
  958. rgb_y = RGB_Y_tab[*y_src2];
  959. b = (rgb_y + b_u) >> SCALEBITS_OUT;
  960. g = (rgb_y - g_uv) >> SCALEBITS_OUT;
  961. r = (rgb_y + r_v) >> SCALEBITS_OUT;
  962. dst2[4] = MAX(0,MIN(255, r));
  963. dst2[5] = MAX(0,MIN(255, g));
  964. dst2[6] = MAX(0,MIN(255, b));
  965. dst2[7] = 0;
  966. y_src2++;
  968. dst += 8;
  969. dst2 += 8;
  970. }
  972. dst += dst_dif;
  973. dst2 += dst_dif;
  975. y_src += y_dif;
  976. y_src2 += y_dif;
  978. u_src += uv_stride;
  979. v_src += uv_stride;
  980. }
  981. }
  985. /* yuv 4:2:0 planar -> yuv planar */
  987. void yv12_to_yuv_c(uint8_t *dst, int dst_stride,
  988.  uint8_t *y_src, uint8_t *u_src, uint8_t * v_src, 
  989.  int y_stride, int uv_stride,
  990.  int width, int height)
  991. {
  992. uint32_t dst_stride2 = dst_stride >> 1;
  993. uint32_t width2 = width >> 1;
  994.     uint32_t y;
  996. if (height < 0) {
  997. height = -height;
  998. y_src += (height - 1) * y_stride ;
  999. u_src += (height / 2 - 1) * uv_stride;
  1000. v_src += (height / 2 - 1) * uv_stride;
  1001. y_stride = -y_stride;
  1002. uv_stride = -uv_stride;
  1003. }
  1005. for (y = height; y; y--) {
  1006.     memcpy(dst, y_src, width);
  1007.     dst += dst_stride;
  1008. y_src += y_stride;
  1009. }
  1011. for (y = height >> 1; y; y--) {
  1012.     memcpy(dst, u_src, width2);
  1013. dst += dst_stride2;
  1014. u_src += uv_stride;
  1015. }
  1017. for (y = height >> 1; y; y--) {
  1018.     memcpy(dst, v_src, width2);
  1019. dst += dst_stride2;
  1020. v_src += uv_stride;
  1021. }
  1022. }
  1027. /* yuv 4:2:0 planar -> yuyv (yuv2) packed */
  1029. void yv12_to_yuyv_c(uint8_t *dst, int dst_stride,
  1030.  uint8_t *y_src, uint8_t *u_src, uint8_t * v_src, 
  1031.  int y_stride, int uv_stride,
  1032.  int width, int height)
  1033. {
  1034. const uint32_t dst_dif = 2*(dst_stride - width);
  1035. uint32_t x, y;
  1037. if (height < 0) {
  1038. height = -height;
  1039. y_src += (height   - 1) * y_stride ;
  1040. u_src += (height / 2 - 1) * uv_stride;
  1041. v_src += (height / 2 - 1) * uv_stride;
  1042. y_stride = -y_stride;
  1043. uv_stride = -uv_stride;
  1044. }
  1046. for (y = 0; y < (uint32_t)height; y++)
  1047. {
  1048. for (x = 0; x < (uint32_t)width / 2; x++)
  1049. {
  1050. dst[0] = y_src[2*x];
  1051. dst[1] = u_src[x];
  1052. dst[2] = y_src[2*x + 1];
  1053. dst[3] = v_src[x];
  1054. dst += 4;
  1055. }
  1056. dst += dst_dif;
  1057. y_src += y_stride;
  1058. if (y&1)
  1059. {
  1060. u_src += uv_stride;
  1061. v_src += uv_stride;
  1062. }
  1063. }
  1064. }
  1068. /* yuv 4:2:0 planar -> uyvy packed */
  1070. void yv12_to_uyvy_c(uint8_t *dst, int dst_stride,
  1071.  uint8_t *y_src, uint8_t *u_src, uint8_t * v_src, 
  1072.  int y_stride, int uv_stride,
  1073.  int width, int height)
  1074. {
  1075. const uint32_t dst_dif = 2*(dst_stride - width);
  1076. uint32_t x, y;
  1078. if (height < 0) {
  1079. height = -height;
  1080. y_src += (height   - 1) * y_stride ;
  1081. u_src += (height / 2 - 1) * uv_stride;
  1082. v_src += (height / 2 - 1) * uv_stride;
  1083. y_stride = -y_stride;
  1084. uv_stride = -uv_stride;
  1085. }
  1087. for (y = 0; y < (uint32_t)height; y++)
  1088. {
  1089. for (x = 0; x < (uint32_t)width / 2; x++)
  1090. {
  1091. dst[0] = u_src[x];
  1092. dst[1] = y_src[2*x];
  1093. dst[2] = v_src[x];
  1094. dst[3] = y_src[2*x + 1];
  1095. dst += 4;
  1096. }
  1097. dst += dst_dif;
  1098. y_src += y_stride;
  1099. if (y&1)
  1100. {
  1101. u_src += uv_stride;
  1102. v_src += uv_stride;
  1103. }
  1104. }
  1105. }