falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22948 Commits
32 Branches
1.0GB
Tree: 8ef4e65e94
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8ef4e65e94'
${ noResults }
FFmpeg/libswscale/yuv2rgb.c

761 lines
22KB
Raw Blame History 

  1. /*

  2.  * software YUV to RGB converter

  3.  *

  4.  * Copyright (C) 2009 Konstantin Shishkov

  5.  *

  6.  * 1,4,8bpp support and context / deglobalize stuff

  7.  * by Michael Niedermayer (michaelni@gmx.at)

  8.  *

  9.  * This file is part of FFmpeg.

  10.  *

  11.  * FFmpeg is free software; you can redistribute it and/or

  12.  * modify it under the terms of the GNU Lesser General Public

  13.  * License as published by the Free Software Foundation; either

  14.  * version 2.1 of the License, or (at your option) any later version.

  15.  *

  16.  * FFmpeg is distributed in the hope that it will be useful,

  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  19.  * Lesser General Public License for more details.

  20.  *

  21.  * You should have received a copy of the GNU Lesser General Public

  22.  * License along with FFmpeg; if not, write to the Free Software

  23.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  24.  */

  25. 

  26. #include <stdio.h>

  27. #include <stdlib.h>

  28. #include <inttypes.h>

  29. #include <assert.h>

  30. 

  31. #include "config.h"

  32. #include "rgb2rgb.h"

  33. #include "swscale.h"

  34. #include "swscale_internal.h"

  35. #include "libavutil/x86_cpu.h"

  36. 

  37. extern const uint8_t dither_8x8_32[8][8];

  38. extern const uint8_t dither_8x8_73[8][8];

  39. extern const uint8_t dither_8x8_220[8][8];

  40. 

  41. const int32_t ff_yuv2rgb_coeffs[8][4] = {

  42.     {117504, 138453, 13954, 34903}, /* no sequence_display_extension */

  43.     {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */

  44.     {104597, 132201, 25675, 53279}, /* unspecified */

  45.     {104597, 132201, 25675, 53279}, /* reserved */

  46.     {104448, 132798, 24759, 53109}, /* FCC */

  47.     {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */

  48.     {104597, 132201, 25675, 53279}, /* SMPTE 170M */

  49.     {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */

  50. };

  51. 

  52. const int * sws_getCoefficients(int colorspace)

  53. {

  54.     if (colorspace > 7 || colorspace < 0)

  55.         colorspace = SWS_CS_DEFAULT;

  56.     return ff_yuv2rgb_coeffs[colorspace];

  57. }

  58. 

  59. #define LOADCHROMA(i)                               \

  60.     U = pu[i];                                      \

  61.     V = pv[i];                                      \

  62.     r = (void *)c->table_rV[V];                     \

  63.     g = (void *)(c->table_gU[U] + c->table_gV[V]);  \

  64.     b = (void *)c->table_bU[U];

  65. 

  66. #define PUTRGB(dst,src,i)            \

  67.     Y = src[2*i];                    \

  68.     dst[2*i  ] = r[Y] + g[Y] + b[Y]; \

  69.     Y = src[2*i+1];                  \

  70.     dst[2*i+1] = r[Y] + g[Y] + b[Y];

  71. 

  72. #define PUTRGB24(dst,src,i)                                  \

  73.     Y = src[2*i];                                            \

  74.     dst[6*i+0] = r[Y]; dst[6*i+1] = g[Y]; dst[6*i+2] = b[Y]; \

  75.     Y = src[2*i+1];                                          \

  76.     dst[6*i+3] = r[Y]; dst[6*i+4] = g[Y]; dst[6*i+5] = b[Y];

  77. 

  78. #define PUTBGR24(dst,src,i)                                  \

  79.     Y = src[2*i];                                            \

  80.     dst[6*i+0] = b[Y]; dst[6*i+1] = g[Y]; dst[6*i+2] = r[Y]; \

  81.     Y = src[2*i+1];                                          \

  82.     dst[6*i+3] = b[Y]; dst[6*i+4] = g[Y]; dst[6*i+5] = r[Y];

  83. 

  84. #define PUTRGBA(dst,ysrc,asrc,i,s)                      \

  85.     Y = ysrc[2*i];                                      \

  86.     dst[2*i  ] = r[Y] + g[Y] + b[Y] + (asrc[2*i  ]<<s); \

  87.     Y = ysrc[2*i+1];                                    \

  88.     dst[2*i+1] = r[Y] + g[Y] + b[Y] + (asrc[2*i+1]<<s);

  89. 

  90. #define PUTRGB48(dst,src,i)             \

  91.     Y = src[2*i];                       \

  92.     dst[12*i+ 0] = dst[12*i+ 1] = r[Y]; \

  93.     dst[12*i+ 2] = dst[12*i+ 3] = g[Y]; \

  94.     dst[12*i+ 4] = dst[12*i+ 5] = b[Y]; \

  95.     Y = src[2*i+1];                     \

  96.     dst[12*i+ 6] = dst[12*i+ 7] = r[Y]; \

  97.     dst[12*i+ 8] = dst[12*i+ 9] = g[Y]; \

  98.     dst[12*i+10] = dst[12*i+11] = b[Y];

  99. 

  100. #define YUV2RGBFUNC(func_name, dst_type, alpha) \

  101. static int func_name(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY, \

  102.                      int srcSliceH, uint8_t* dst[], int dstStride[]) \

  103. {\

  104.     int y;\

  105. \

  106.     if (!alpha && c->srcFormat == PIX_FMT_YUV422P) {\

  107.         srcStride[1] *= 2;\

  108.         srcStride[2] *= 2;\

  109.     }\

  110.     for (y=0; y<srcSliceH; y+=2) {\

  111.         dst_type *dst_1 = (dst_type*)(dst[0] + (y+srcSliceY  )*dstStride[0]);\

  112.         dst_type *dst_2 = (dst_type*)(dst[0] + (y+srcSliceY+1)*dstStride[0]);\

  113.         dst_type av_unused *r, *b;\

  114.         dst_type *g;\

  115.         const uint8_t *py_1 = src[0] + y*srcStride[0];\

  116.         const uint8_t *py_2 = py_1 + srcStride[0];\

  117.         const uint8_t *pu = src[1] + (y>>1)*srcStride[1];\

  118.         const uint8_t *pv = src[2] + (y>>1)*srcStride[2];\

  119.         const uint8_t av_unused *pa_1, *pa_2;\

  120.         unsigned int h_size = c->dstW>>3;\

  121.         if (alpha) {\

  122.             pa_1 = src[3] + y*srcStride[3];\

  123.             pa_2 = pa_1 + srcStride[3];\

  124.         }\

  125.         while (h_size--) {\

  126.             int av_unused U, V;\

  127.             int Y;\

  128. 

  129. #define ENDYUV2RGBLINE(dst_delta)\

  130.             pu += 4;\

  131.             pv += 4;\

  132.             py_1 += 8;\

  133.             py_2 += 8;\

  134.             dst_1 += dst_delta;\

  135.             dst_2 += dst_delta;\

  136.         }\

  137.         if (c->dstW & 4) {\

  138.             int av_unused Y, U, V;\

  139. 

  140. #define ENDYUV2RGBFUNC()\

  141.         }\

  142.     }\

  143.     return srcSliceH;\

  144. }

  145. 

  146. #define CLOSEYUV2RGBFUNC(dst_delta)\

  147.     ENDYUV2RGBLINE(dst_delta)\

  148.     ENDYUV2RGBFUNC()

  149. 

  150. YUV2RGBFUNC(yuv2rgb_c_48, uint8_t, 0)

  151.     LOADCHROMA(0);

  152.     PUTRGB48(dst_1,py_1,0);

  153.     PUTRGB48(dst_2,py_2,0);

  154. 

  155.     LOADCHROMA(1);

  156.     PUTRGB48(dst_2,py_2,1);

  157.     PUTRGB48(dst_1,py_1,1);

  158. 

  159.     LOADCHROMA(2);

  160.     PUTRGB48(dst_1,py_1,2);

  161.     PUTRGB48(dst_2,py_2,2);

  162. 

  163.     LOADCHROMA(3);

  164.     PUTRGB48(dst_2,py_2,3);

  165.     PUTRGB48(dst_1,py_1,3);

  166. ENDYUV2RGBLINE(48)

  167.     LOADCHROMA(0);

  168.     PUTRGB48(dst_1,py_1,0);

  169.     PUTRGB48(dst_2,py_2,0);

  170. 

  171.     LOADCHROMA(1);

  172.     PUTRGB48(dst_2,py_2,1);

  173.     PUTRGB48(dst_1,py_1,1);

  174. ENDYUV2RGBFUNC()

  175. 

  176. YUV2RGBFUNC(yuv2rgb_c_32, uint32_t, 0)

  177.     LOADCHROMA(0);

  178.     PUTRGB(dst_1,py_1,0);

  179.     PUTRGB(dst_2,py_2,0);

  180. 

  181.     LOADCHROMA(1);

  182.     PUTRGB(dst_2,py_2,1);

  183.     PUTRGB(dst_1,py_1,1);

  184. 

  185.     LOADCHROMA(2);

  186.     PUTRGB(dst_1,py_1,2);

  187.     PUTRGB(dst_2,py_2,2);

  188. 

  189.     LOADCHROMA(3);

  190.     PUTRGB(dst_2,py_2,3);

  191.     PUTRGB(dst_1,py_1,3);

  192. ENDYUV2RGBLINE(8)

  193.     LOADCHROMA(0);

  194.     PUTRGB(dst_1,py_1,0);

  195.     PUTRGB(dst_2,py_2,0);

  196. 

  197.     LOADCHROMA(1);

  198.     PUTRGB(dst_2,py_2,1);

  199.     PUTRGB(dst_1,py_1,1);

  200. ENDYUV2RGBFUNC()

  201. 

  202. YUV2RGBFUNC(yuva2rgba_c, uint32_t, 1)

  203.     LOADCHROMA(0);

  204.     PUTRGBA(dst_1,py_1,pa_1,0,24);

  205.     PUTRGBA(dst_2,py_2,pa_2,0,24);

  206. 

  207.     LOADCHROMA(1);

  208.     PUTRGBA(dst_2,py_2,pa_1,1,24);

  209.     PUTRGBA(dst_1,py_1,pa_2,1,24);

  210. 

  211.     LOADCHROMA(2);

  212.     PUTRGBA(dst_1,py_1,pa_1,2,24);

  213.     PUTRGBA(dst_2,py_2,pa_2,2,24);

  214. 

  215.     LOADCHROMA(3);

  216.     PUTRGBA(dst_2,py_2,pa_1,3,24);

  217.     PUTRGBA(dst_1,py_1,pa_2,3,24);

  218.     pa_1 += 8;\

  219.     pa_2 += 8;\

  220. ENDYUV2RGBLINE(8)

  221.     LOADCHROMA(0);

  222.     PUTRGBA(dst_1,py_1,pa_1,0,24);

  223.     PUTRGBA(dst_2,py_2,pa_2,0,24);

  224. 

  225.     LOADCHROMA(1);

  226.     PUTRGBA(dst_2,py_2,pa_1,1,24);

  227.     PUTRGBA(dst_1,py_1,pa_2,1,24);

  228. ENDYUV2RGBFUNC()

  229. 

  230. YUV2RGBFUNC(yuva2argb_c, uint32_t, 1)

  231.     LOADCHROMA(0);

  232.     PUTRGBA(dst_1,py_1,pa_1,0,0);

  233.     PUTRGBA(dst_2,py_2,pa_2,0,0);

  234. 

  235.     LOADCHROMA(1);

  236.     PUTRGBA(dst_2,py_2,pa_2,1,0);

  237.     PUTRGBA(dst_1,py_1,pa_1,1,0);

  238. 

  239.     LOADCHROMA(2);

  240.     PUTRGBA(dst_1,py_1,pa_1,2,0);

  241.     PUTRGBA(dst_2,py_2,pa_2,2,0);

  242. 

  243.     LOADCHROMA(3);

  244.     PUTRGBA(dst_2,py_2,pa_2,3,0);

  245.     PUTRGBA(dst_1,py_1,pa_1,3,0);

  246.     pa_1 += 8;\

  247.     pa_2 += 8;\

  248. ENDYUV2RGBLINE(8)

  249.     LOADCHROMA(0);

  250.     PUTRGBA(dst_1,py_1,pa_1,0,0);

  251.     PUTRGBA(dst_2,py_2,pa_2,0,0);

  252. 

  253.     LOADCHROMA(1);

  254.     PUTRGBA(dst_2,py_2,pa_2,1,0);

  255.     PUTRGBA(dst_1,py_1,pa_1,1,0);

  256. ENDYUV2RGBFUNC()

  257. 

  258. YUV2RGBFUNC(yuv2rgb_c_24_rgb, uint8_t, 0)

  259.     LOADCHROMA(0);

  260.     PUTRGB24(dst_1,py_1,0);

  261.     PUTRGB24(dst_2,py_2,0);

  262. 

  263.     LOADCHROMA(1);

  264.     PUTRGB24(dst_2,py_2,1);

  265.     PUTRGB24(dst_1,py_1,1);

  266. 

  267.     LOADCHROMA(2);

  268.     PUTRGB24(dst_1,py_1,2);

  269.     PUTRGB24(dst_2,py_2,2);

  270. 

  271.     LOADCHROMA(3);

  272.     PUTRGB24(dst_2,py_2,3);

  273.     PUTRGB24(dst_1,py_1,3);

  274. ENDYUV2RGBLINE(24)

  275.     LOADCHROMA(0);

  276.     PUTRGB24(dst_1,py_1,0);

  277.     PUTRGB24(dst_2,py_2,0);

  278. 

  279.     LOADCHROMA(1);

  280.     PUTRGB24(dst_2,py_2,1);

  281.     PUTRGB24(dst_1,py_1,1);

  282. ENDYUV2RGBFUNC()

  283. 

  284. // only trivial mods from yuv2rgb_c_24_rgb

  285. YUV2RGBFUNC(yuv2rgb_c_24_bgr, uint8_t, 0)

  286.     LOADCHROMA(0);

  287.     PUTBGR24(dst_1,py_1,0);

  288.     PUTBGR24(dst_2,py_2,0);

  289. 

  290.     LOADCHROMA(1);

  291.     PUTBGR24(dst_2,py_2,1);

  292.     PUTBGR24(dst_1,py_1,1);

  293. 

  294.     LOADCHROMA(2);

  295.     PUTBGR24(dst_1,py_1,2);

  296.     PUTBGR24(dst_2,py_2,2);

  297. 

  298.     LOADCHROMA(3);

  299.     PUTBGR24(dst_2,py_2,3);

  300.     PUTBGR24(dst_1,py_1,3);

  301. ENDYUV2RGBLINE(24)

  302.     LOADCHROMA(0);

  303.     PUTBGR24(dst_1,py_1,0);

  304.     PUTBGR24(dst_2,py_2,0);

  305. 

  306.     LOADCHROMA(1);

  307.     PUTBGR24(dst_2,py_2,1);

  308.     PUTBGR24(dst_1,py_1,1);

  309. ENDYUV2RGBFUNC()

  310. 

  311. // This is exactly the same code as yuv2rgb_c_32 except for the types of

  312. // r, g, b, dst_1, dst_2

  313. YUV2RGBFUNC(yuv2rgb_c_16, uint16_t, 0)

  314.     LOADCHROMA(0);

  315.     PUTRGB(dst_1,py_1,0);

  316.     PUTRGB(dst_2,py_2,0);

  317. 

  318.     LOADCHROMA(1);

  319.     PUTRGB(dst_2,py_2,1);

  320.     PUTRGB(dst_1,py_1,1);

  321. 

  322.     LOADCHROMA(2);

  323.     PUTRGB(dst_1,py_1,2);

  324.     PUTRGB(dst_2,py_2,2);

  325. 

  326.     LOADCHROMA(3);

  327.     PUTRGB(dst_2,py_2,3);

  328.     PUTRGB(dst_1,py_1,3);

  329. CLOSEYUV2RGBFUNC(8)

  330. 

  331. #if 0 // Currently unused

  332. // This is exactly the same code as yuv2rgb_c_32 except for the types of

  333. // r, g, b, dst_1, dst_2

  334. YUV2RGBFUNC(yuv2rgb_c_8, uint8_t, 0)

  335.     LOADCHROMA(0);

  336.     PUTRGB(dst_1,py_1,0);

  337.     PUTRGB(dst_2,py_2,0);

  338. 

  339.     LOADCHROMA(1);

  340.     PUTRGB(dst_2,py_2,1);

  341.     PUTRGB(dst_1,py_1,1);

  342. 

  343.     LOADCHROMA(2);

  344.     PUTRGB(dst_1,py_1,2);

  345.     PUTRGB(dst_2,py_2,2);

  346. 

  347.     LOADCHROMA(3);

  348.     PUTRGB(dst_2,py_2,3);

  349.     PUTRGB(dst_1,py_1,3);

  350. CLOSEYUV2RGBFUNC(8)

  351. #endif

  352. 

  353. // r, g, b, dst_1, dst_2

  354. YUV2RGBFUNC(yuv2rgb_c_8_ordered_dither, uint8_t, 0)

  355.     const uint8_t *d32 = dither_8x8_32[y&7];

  356.     const uint8_t *d64 = dither_8x8_73[y&7];

  357. #define PUTRGB8(dst,src,i,o)                                    \

  358.     Y = src[2*i];                                               \

  359.     dst[2*i]   = r[Y+d32[0+o]] + g[Y+d32[0+o]] + b[Y+d64[0+o]]; \

  360.     Y = src[2*i+1];                                             \

  361.     dst[2*i+1] = r[Y+d32[1+o]] + g[Y+d32[1+o]] + b[Y+d64[1+o]];

  362. 

  363.     LOADCHROMA(0);

  364.     PUTRGB8(dst_1,py_1,0,0);

  365.     PUTRGB8(dst_2,py_2,0,0+8);

  366. 

  367.     LOADCHROMA(1);

  368.     PUTRGB8(dst_2,py_2,1,2+8);

  369.     PUTRGB8(dst_1,py_1,1,2);

  370. 

  371.     LOADCHROMA(2);

  372.     PUTRGB8(dst_1,py_1,2,4);

  373.     PUTRGB8(dst_2,py_2,2,4+8);

  374. 

  375.     LOADCHROMA(3);

  376.     PUTRGB8(dst_2,py_2,3,6+8);

  377.     PUTRGB8(dst_1,py_1,3,6);

  378. CLOSEYUV2RGBFUNC(8)

  379. 

  380. #if 0 // Currently unused

  381. // This is exactly the same code as yuv2rgb_c_32 except for the types of

  382. // r, g, b, dst_1, dst_2

  383. YUV2RGBFUNC(yuv2rgb_c_4, uint8_t, 0)

  384.     int acc;

  385. #define PUTRGB4(dst,src,i)          \

  386.     Y = src[2*i];                   \

  387.     acc = r[Y] + g[Y] + b[Y];       \

  388.     Y = src[2*i+1];                 \

  389.     acc |= (r[Y] + g[Y] + b[Y])<<4; \

  390.     dst[i] = acc;

  391. 

  392.     LOADCHROMA(0);

  393.     PUTRGB4(dst_1,py_1,0);

  394.     PUTRGB4(dst_2,py_2,0);

  395. 

  396.     LOADCHROMA(1);

  397.     PUTRGB4(dst_2,py_2,1);

  398.     PUTRGB4(dst_1,py_1,1);

  399. 

  400.     LOADCHROMA(2);

  401.     PUTRGB4(dst_1,py_1,2);

  402.     PUTRGB4(dst_2,py_2,2);

  403. 

  404.     LOADCHROMA(3);

  405.     PUTRGB4(dst_2,py_2,3);

  406.     PUTRGB4(dst_1,py_1,3);

  407. CLOSEYUV2RGBFUNC(4)

  408. #endif

  409. 

  410. YUV2RGBFUNC(yuv2rgb_c_4_ordered_dither, uint8_t, 0)

  411.     const uint8_t *d64 =  dither_8x8_73[y&7];

  412.     const uint8_t *d128 = dither_8x8_220[y&7];

  413.     int acc;

  414. 

  415. #define PUTRGB4D(dst,src,i,o)                                     \

  416.     Y = src[2*i];                                                 \

  417.     acc = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];        \

  418.     Y = src[2*i+1];                                               \

  419.     acc |= (r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]])<<4;  \

  420.     dst[i]= acc;

  421. 

  422.     LOADCHROMA(0);

  423.     PUTRGB4D(dst_1,py_1,0,0);

  424.     PUTRGB4D(dst_2,py_2,0,0+8);

  425. 

  426.     LOADCHROMA(1);

  427.     PUTRGB4D(dst_2,py_2,1,2+8);

  428.     PUTRGB4D(dst_1,py_1,1,2);

  429. 

  430.     LOADCHROMA(2);

  431.     PUTRGB4D(dst_1,py_1,2,4);

  432.     PUTRGB4D(dst_2,py_2,2,4+8);

  433. 

  434.     LOADCHROMA(3);

  435.     PUTRGB4D(dst_2,py_2,3,6+8);

  436.     PUTRGB4D(dst_1,py_1,3,6);

  437. CLOSEYUV2RGBFUNC(4)

  438. 

  439. #if 0 // Currently unused

  440. // This is exactly the same code as yuv2rgb_c_32 except for the types of

  441. // r, g, b, dst_1, dst_2

  442. YUV2RGBFUNC(yuv2rgb_c_4b, uint8_t, 0)

  443.     LOADCHROMA(0);

  444.     PUTRGB(dst_1,py_1,0);

  445.     PUTRGB(dst_2,py_2,0);

  446. 

  447.     LOADCHROMA(1);

  448.     PUTRGB(dst_2,py_2,1);

  449.     PUTRGB(dst_1,py_1,1);

  450. 

  451.     LOADCHROMA(2);

  452.     PUTRGB(dst_1,py_1,2);

  453.     PUTRGB(dst_2,py_2,2);

  454. 

  455.     LOADCHROMA(3);

  456.     PUTRGB(dst_2,py_2,3);

  457.     PUTRGB(dst_1,py_1,3);

  458. CLOSEYUV2RGBFUNC(8)

  459. #endif

  460. 

  461. YUV2RGBFUNC(yuv2rgb_c_4b_ordered_dither, uint8_t, 0)

  462.     const uint8_t *d64 =  dither_8x8_73[y&7];

  463.     const uint8_t *d128 = dither_8x8_220[y&7];

  464. 

  465. #define PUTRGB4DB(dst,src,i,o)                                    \

  466.     Y = src[2*i];                                                 \

  467.     dst[2*i]   = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]]; \

  468.     Y = src[2*i+1];                                               \

  469.     dst[2*i+1] = r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]];

  470. 

  471.     LOADCHROMA(0);

  472.     PUTRGB4DB(dst_1,py_1,0,0);

  473.     PUTRGB4DB(dst_2,py_2,0,0+8);

  474. 

  475.     LOADCHROMA(1);

  476.     PUTRGB4DB(dst_2,py_2,1,2+8);

  477.     PUTRGB4DB(dst_1,py_1,1,2);

  478. 

  479.     LOADCHROMA(2);

  480.     PUTRGB4DB(dst_1,py_1,2,4);

  481.     PUTRGB4DB(dst_2,py_2,2,4+8);

  482. 

  483.     LOADCHROMA(3);

  484.     PUTRGB4DB(dst_2,py_2,3,6+8);

  485.     PUTRGB4DB(dst_1,py_1,3,6);

  486. CLOSEYUV2RGBFUNC(8)

  487. 

  488. YUV2RGBFUNC(yuv2rgb_c_1_ordered_dither, uint8_t, 0)

  489.         const uint8_t *d128 = dither_8x8_220[y&7];

  490.         char out_1 = 0, out_2 = 0;

  491.         g= c->table_gU[128] + c->table_gV[128];

  492. 

  493. #define PUTRGB1(out,src,i,o)    \

  494.     Y = src[2*i];               \

  495.     out+= out + g[Y+d128[0+o]]; \

  496.     Y = src[2*i+1];             \

  497.     out+= out + g[Y+d128[1+o]];

  498. 

  499.     PUTRGB1(out_1,py_1,0,0);

  500.     PUTRGB1(out_2,py_2,0,0+8);

  501. 

  502.     PUTRGB1(out_2,py_2,1,2+8);

  503.     PUTRGB1(out_1,py_1,1,2);

  504. 

  505.     PUTRGB1(out_1,py_1,2,4);

  506.     PUTRGB1(out_2,py_2,2,4+8);

  507. 

  508.     PUTRGB1(out_2,py_2,3,6+8);

  509.     PUTRGB1(out_1,py_1,3,6);

  510. 

  511.     dst_1[0]= out_1;

  512.     dst_2[0]= out_2;

  513. CLOSEYUV2RGBFUNC(1)

  514. 

  515. SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)

  516. {

  517.     SwsFunc t = NULL;

  518. #if (HAVE_MMX2 || HAVE_MMX) && CONFIG_GPL

  519.      t = ff_yuv2rgb_init_mmx(c);

  520. #endif

  521. #if HAVE_VIS

  522.     t = ff_yuv2rgb_init_vis(c);

  523. #endif

  524. #if CONFIG_MLIB

  525.     t = ff_yuv2rgb_init_mlib(c);

  526. #endif

  527. #if HAVE_ALTIVEC

  528.     if (c->flags & SWS_CPU_CAPS_ALTIVEC)

  529.         t = ff_yuv2rgb_init_altivec(c);

  530. #endif

  531. 

  532. #if ARCH_BFIN

  533.     if (c->flags & SWS_CPU_CAPS_BFIN)

  534.         t = ff_yuv2rgb_get_func_ptr_bfin(c);

  535. #endif

  536. 

  537.     if (t)

  538.         return t;

  539. 

  540.     av_log(c, AV_LOG_WARNING, "No accelerated colorspace conversion found from %s to %s.\n", sws_format_name(c->srcFormat), sws_format_name(c->dstFormat));

  541. 

  542.     switch (c->dstFormat) {

  543.     case PIX_FMT_RGB48BE:

  544.     case PIX_FMT_RGB48LE:    return yuv2rgb_c_48;

  545.     case PIX_FMT_ARGB:

  546.     case PIX_FMT_ABGR:       if (CONFIG_SWSCALE_ALPHA && c->srcFormat == PIX_FMT_YUVA420P) return yuva2argb_c;

  547.     case PIX_FMT_RGBA:

  548.     case PIX_FMT_BGRA:       return (CONFIG_SWSCALE_ALPHA && c->srcFormat == PIX_FMT_YUVA420P) ? yuva2rgba_c : yuv2rgb_c_32;

  549.     case PIX_FMT_RGB24:      return yuv2rgb_c_24_rgb;

  550.     case PIX_FMT_BGR24:      return yuv2rgb_c_24_bgr;

  551.     case PIX_FMT_RGB565:

  552.     case PIX_FMT_BGR565:

  553.     case PIX_FMT_RGB555:

  554.     case PIX_FMT_BGR555:     return yuv2rgb_c_16;

  555.     case PIX_FMT_RGB8:

  556.     case PIX_FMT_BGR8:       return yuv2rgb_c_8_ordered_dither;

  557.     case PIX_FMT_RGB4:

  558.     case PIX_FMT_BGR4:       return yuv2rgb_c_4_ordered_dither;

  559.     case PIX_FMT_RGB4_BYTE:

  560.     case PIX_FMT_BGR4_BYTE:  return yuv2rgb_c_4b_ordered_dither;

  561.     case PIX_FMT_MONOBLACK:  return yuv2rgb_c_1_ordered_dither;

  562.     default:

  563.         assert(0);

  564.     }

  565.     return NULL;

  566. }

  567. 

  568. static void fill_table(uint8_t* table[256], const int elemsize, const int inc, uint8_t *y_table)

  569. {

  570.     int i;

  571.     int64_t cb = 0;

  572. 

  573.     y_table -= elemsize * (inc >> 9);

  574. 

  575.     for (i = 0; i < 256; i++) {

  576.         table[i] = y_table + elemsize * (cb >> 16);

  577.         cb += inc;

  578.     }

  579. }

  580. 

  581. static void fill_gv_table(int table[256], const int elemsize, const int inc)

  582. {

  583.     int i;

  584.     int64_t cb = 0;

  585.     int off = -(inc >> 9);

  586. 

  587.     for (i = 0; i < 256; i++) {

  588.         table[i] = elemsize * (off + (cb >> 16));

  589.         cb += inc;

  590.     }

  591. }

  592. 

  593. av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange,

  594.                                      int brightness, int contrast, int saturation)

  595. {

  596.     const int isRgb =      c->dstFormat==PIX_FMT_RGB32

  597.                         || c->dstFormat==PIX_FMT_RGB32_1

  598.                         || c->dstFormat==PIX_FMT_BGR24

  599.                         || c->dstFormat==PIX_FMT_RGB565

  600.                         || c->dstFormat==PIX_FMT_RGB555

  601.                         || c->dstFormat==PIX_FMT_RGB8

  602.                         || c->dstFormat==PIX_FMT_RGB4

  603.                         || c->dstFormat==PIX_FMT_RGB4_BYTE

  604.                         || c->dstFormat==PIX_FMT_MONOBLACK;

  605.     const int bpp = c->dstFormatBpp;

  606.     uint8_t *y_table;

  607.     uint16_t *y_table16;

  608.     uint32_t *y_table32;

  609.     int i, base, rbase, gbase, bbase, abase, needAlpha;

  610.     const int yoffs = fullRange ? 384 : 326;

  611. 

  612.     int64_t crv =  inv_table[0];

  613.     int64_t cbu =  inv_table[1];

  614.     int64_t cgu = -inv_table[2];

  615.     int64_t cgv = -inv_table[3];

  616.     int64_t cy  = 1<<16;

  617.     int64_t oy  = 0;

  618. 

  619.     int64_t yb = 0;

  620. 

  621.     if (!fullRange) {

  622.         cy = (cy*255) / 219;

  623.         oy = 16<<16;

  624.     } else {

  625.         crv = (crv*224) / 255;

  626.         cbu = (cbu*224) / 255;

  627.         cgu = (cgu*224) / 255;

  628.         cgv = (cgv*224) / 255;

  629.     }

  630. 

  631.     cy  = (cy *contrast             ) >> 16;

  632.     crv = (crv*contrast * saturation) >> 32;

  633.     cbu = (cbu*contrast * saturation) >> 32;

  634.     cgu = (cgu*contrast * saturation) >> 32;

  635.     cgv = (cgv*contrast * saturation) >> 32;

  636.     oy -= 256*brightness;

  637. 

  638.     //scale coefficients by cy

  639.     crv = ((crv << 16) + 0x8000) / cy;

  640.     cbu = ((cbu << 16) + 0x8000) / cy;

  641.     cgu = ((cgu << 16) + 0x8000) / cy;

  642.     cgv = ((cgv << 16) + 0x8000) / cy;

  643. 

  644.     av_free(c->yuvTable);

  645. 

  646.     switch (bpp) {

  647.     case 1:

  648.         c->yuvTable = av_malloc(1024);

  649.         y_table = c->yuvTable;

  650.         yb = -(384<<16) - oy;

  651.         for (i = 0; i < 1024-110; i++) {

  652.             y_table[i+110] = av_clip_uint8((yb + 0x8000) >> 16) >> 7;

  653.             yb += cy;

  654.         }

  655.         fill_table(c->table_gU, 1, cgu, y_table + yoffs);

  656.         fill_gv_table(c->table_gV, 1, cgv);

  657.         break;

  658.     case 4:

  659.     case 4|128:

  660.         rbase = isRgb ? 3 : 0;

  661.         gbase = 1;

  662.         bbase = isRgb ? 0 : 3;

  663.         c->yuvTable = av_malloc(1024*3);

  664.         y_table = c->yuvTable;

  665.         yb = -(384<<16) - oy;

  666.         for (i = 0; i < 1024-110; i++) {

  667.             int yval = av_clip_uint8((yb + 0x8000) >> 16);

  668.             y_table[i+110     ] =  (yval >> 7)       << rbase;

  669.             y_table[i+ 37+1024] = ((yval + 43) / 85) << gbase;

  670.             y_table[i+110+2048] =  (yval >> 7)       << bbase;

  671.             yb += cy;

  672.         }

  673.         fill_table(c->table_rV, 1, crv, y_table + yoffs);

  674.         fill_table(c->table_gU, 1, cgu, y_table + yoffs + 1024);

  675.         fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2048);

  676.         fill_gv_table(c->table_gV, 1, cgv);

  677.         break;

  678.     case 8:

  679.         rbase = isRgb ? 5 : 0;

  680.         gbase = isRgb ? 2 : 3;

  681.         bbase = isRgb ? 0 : 6;

  682.         c->yuvTable = av_malloc(1024*3);

  683.         y_table = c->yuvTable;

  684.         yb = -(384<<16) - oy;

  685.         for (i = 0; i < 1024-38; i++) {

  686.             int yval = av_clip_uint8((yb + 0x8000) >> 16);

  687.             y_table[i+16     ] = ((yval + 18) / 36) << rbase;

  688.             y_table[i+16+1024] = ((yval + 18) / 36) << gbase;

  689.             y_table[i+37+2048] = ((yval + 43) / 85) << bbase;

  690.             yb += cy;

  691.         }

  692.         fill_table(c->table_rV, 1, crv, y_table + yoffs);

  693.         fill_table(c->table_gU, 1, cgu, y_table + yoffs + 1024);

  694.         fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2048);

  695.         fill_gv_table(c->table_gV, 1, cgv);

  696.         break;

  697.     case 15:

  698.     case 16:

  699.         rbase = isRgb ? bpp - 5 : 0;

  700.         gbase = 5;

  701.         bbase = isRgb ? 0 : (bpp - 5);

  702.         c->yuvTable = av_malloc(1024*3*2);

  703.         y_table16 = c->yuvTable;

  704.         yb = -(384<<16) - oy;

  705.         for (i = 0; i < 1024; i++) {

  706.             uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);

  707.             y_table16[i     ] = (yval >> 3)          << rbase;

  708.             y_table16[i+1024] = (yval >> (18 - bpp)) << gbase;

  709.             y_table16[i+2048] = (yval >> 3)          << bbase;

  710.             yb += cy;

  711.         }

  712.         fill_table(c->table_rV, 2, crv, y_table16 + yoffs);

  713.         fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + 1024);

  714.         fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2048);

  715.         fill_gv_table(c->table_gV, 2, cgv);

  716.         break;

  717.     case 24:

  718.     case 48:

  719.         c->yuvTable = av_malloc(1024);

  720.         y_table = c->yuvTable;

  721.         yb = -(384<<16) - oy;

  722.         for (i = 0; i < 1024; i++) {

  723.             y_table[i] = av_clip_uint8((yb + 0x8000) >> 16);

  724.             yb += cy;

  725.         }

  726.         fill_table(c->table_rV, 1, crv, y_table + yoffs);

  727.         fill_table(c->table_gU, 1, cgu, y_table + yoffs);

  728.         fill_table(c->table_bU, 1, cbu, y_table + yoffs);

  729.         fill_gv_table(c->table_gV, 1, cgv);

  730.         break;

  731.     case 32:

  732.         base = (c->dstFormat == PIX_FMT_RGB32_1 || c->dstFormat == PIX_FMT_BGR32_1) ? 8 : 0;

  733.         rbase = base + (isRgb ? 16 : 0);

  734.         gbase = base + 8;

  735.         bbase = base + (isRgb ? 0 : 16);

  736.         needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat);

  737.         if (!needAlpha)

  738.             abase = (base + 24) & 31;

  739.         c->yuvTable = av_malloc(1024*3*4);

  740.         y_table32 = c->yuvTable;

  741.         yb = -(384<<16) - oy;

  742.         for (i = 0; i < 1024; i++) {

  743.             uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);

  744.             y_table32[i     ] = (yval << rbase) + (needAlpha ? 0 : (255 << abase));

  745.             y_table32[i+1024] = yval << gbase;

  746.             y_table32[i+2048] = yval << bbase;

  747.             yb += cy;

  748.         }

  749.         fill_table(c->table_rV, 4, crv, y_table32 + yoffs);

  750.         fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + 1024);

  751.         fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2048);

  752.         fill_gv_table(c->table_gV, 4, cgv);

  753.         break;

  754.     default:

  755.         c->yuvTable = NULL;

  756.         av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);

  757.         return -1;

  758.     }

  759.     return 0;

  760. }