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.
32462 Commits
32 Branches
434MB
Tree: ada4e362b9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ada4e362b9'
${ noResults }
FFmpeg/libswscale/input.c

762 lines
28KB
Raw Blame History 

  1. /*

  2.  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>

  3.  *

  4.  * This file is part of Libav.

  5.  *

  6.  * Libav is free software; you can redistribute it and/or

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

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

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

  10.  *

  11.  * Libav is distributed in the hope that it will be useful,

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

  17.  * License along with Libav; if not, write to the Free Software

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

  19.  */

  20. 

  21. #include <assert.h>

  22. #include <math.h>

  23. #include <stdint.h>

  24. #include <stdio.h>

  25. #include <string.h>

  26. 

  27. #include "libavutil/avutil.h"

  28. #include "libavutil/bswap.h"

  29. #include "libavutil/cpu.h"

  30. #include "libavutil/intreadwrite.h"

  31. #include "libavutil/mathematics.h"

  32. #include "libavutil/pixdesc.h"

  33. #include "config.h"

  34. #include "rgb2rgb.h"

  35. #include "swscale.h"

  36. #include "swscale_internal.h"

  37. 

  38. #define RGB2YUV_SHIFT 15

  39. #define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))

  40. #define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))

  41. #define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))

  42. #define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))

  43. #define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))

  44. #define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))

  45. #define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))

  46. #define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))

  47. #define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))

  48. 

  49. #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))

  50. 

  51. #define r ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? b_r : r_b)

  52. #define b ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? r_b : b_r)

  53. 

  54. static av_always_inline void

  55. rgb48ToY_c_template(uint16_t *dst, const uint16_t *src, int width,

  56.                     enum PixelFormat origin)

  57. {

  58.     int i;

  59.     for (i = 0; i < width; i++) {

  60.         unsigned int r_b = input_pixel(&src[i*3+0]);

  61.         unsigned int   g = input_pixel(&src[i*3+1]);

  62.         unsigned int b_r = input_pixel(&src[i*3+2]);

  63. 

  64.         dst[i] = (RY*r + GY*g + BY*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;

  65.     }

  66. }

  67. 

  68. static av_always_inline void

  69. rgb48ToUV_c_template(uint16_t *dstU, uint16_t *dstV,

  70.                     const uint16_t *src1, const uint16_t *src2,

  71.                     int width, enum PixelFormat origin)

  72. {

  73.     int i;

  74.     assert(src1==src2);

  75.     for (i = 0; i < width; i++) {

  76.         int r_b = input_pixel(&src1[i*3+0]);

  77.         int   g = input_pixel(&src1[i*3+1]);

  78.         int b_r = input_pixel(&src1[i*3+2]);

  79. 

  80.         dstU[i] = (RU*r + GU*g + BU*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;

  81.         dstV[i] = (RV*r + GV*g + BV*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;

  82.     }

  83. }

  84. 

  85. static av_always_inline void

  86. rgb48ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,

  87.                           const uint16_t *src1, const uint16_t *src2,

  88.                           int width, enum PixelFormat origin)

  89. {

  90.     int i;

  91.     assert(src1==src2);

  92.     for (i = 0; i < width; i++) {

  93.         int r_b = (input_pixel(&src1[6 * i + 0]) + input_pixel(&src1[6 * i + 3]) + 1) >> 1;

  94.         int   g = (input_pixel(&src1[6 * i + 1]) + input_pixel(&src1[6 * i + 4]) + 1) >> 1;

  95.         int b_r = (input_pixel(&src1[6 * i + 2]) + input_pixel(&src1[6 * i + 5]) + 1) >> 1;

  96. 

  97.         dstU[i]= (RU*r + GU*g + BU*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;

  98.         dstV[i]= (RV*r + GV*g + BV*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;

  99.     }

  100. }

  101. 

  102. #undef r

  103. #undef b

  104. #undef input_pixel

  105. 

  106. #define rgb48funcs(pattern, BE_LE, origin) \

  107. static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, \

  108.                                     int width, uint32_t *unused) \

  109. { \

  110.     const uint16_t *src = (const uint16_t *) _src; \

  111.     uint16_t *dst = (uint16_t *) _dst; \

  112.     rgb48ToY_c_template(dst, src, width, origin); \

  113. } \

  114.  \

  115. static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \

  116.                                     const uint8_t *_src1, const uint8_t *_src2, \

  117.                                     int width, uint32_t *unused) \

  118. { \

  119.     const uint16_t *src1 = (const uint16_t *) _src1, \

  120.                    *src2 = (const uint16_t *) _src2; \

  121.     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \

  122.     rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin); \

  123. } \

  124.  \

  125. static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \

  126.                                     const uint8_t *_src1, const uint8_t *_src2, \

  127.                                     int width, uint32_t *unused) \

  128. { \

  129.     const uint16_t *src1 = (const uint16_t *) _src1, \

  130.                    *src2 = (const uint16_t *) _src2; \

  131.     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \

  132.     rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin); \

  133. }

  134. 

  135. rgb48funcs(rgb, LE, PIX_FMT_RGB48LE)

  136. rgb48funcs(rgb, BE, PIX_FMT_RGB48BE)

  137. rgb48funcs(bgr, LE, PIX_FMT_BGR48LE)

  138. rgb48funcs(bgr, BE, PIX_FMT_BGR48BE)

  139. 

  140. #define input_pixel(i) ((origin == PIX_FMT_RGBA || origin == PIX_FMT_BGRA || \

  141.                          origin == PIX_FMT_ARGB || origin == PIX_FMT_ABGR) ? AV_RN32A(&src[(i)*4]) : \

  142.                         (isBE(origin) ? AV_RB16(&src[(i)*2]) : AV_RL16(&src[(i)*2])))

  143. 

  144. static av_always_inline void

  145. rgb16_32ToY_c_template(uint8_t *dst, const uint8_t *src,

  146.                        int width, enum PixelFormat origin,

  147.                        int shr,   int shg,   int shb, int shp,

  148.                        int maskr, int maskg, int maskb,

  149.                        int rsh,   int gsh,   int bsh, int S)

  150. {

  151.     const int ry = RY << rsh, gy = GY << gsh, by = BY << bsh;

  152.     const unsigned rnd = 33u << (S - 1);

  153.     int i;

  154. 

  155.     for (i = 0; i < width; i++) {

  156.         int px = input_pixel(i) >> shp;

  157.         int b = (px & maskb) >> shb;

  158.         int g = (px & maskg) >> shg;

  159.         int r = (px & maskr) >> shr;

  160. 

  161.         dst[i] = (ry * r + gy * g + by * b + rnd) >> S;

  162.     }

  163. }

  164. 

  165. static av_always_inline void

  166. rgb16_32ToUV_c_template(uint8_t *dstU, uint8_t *dstV,

  167.                         const uint8_t *src, int width,

  168.                         enum PixelFormat origin,

  169.                         int shr,   int shg,   int shb, int shp,

  170.                         int maskr, int maskg, int maskb,

  171.                         int rsh,   int gsh,   int bsh, int S)

  172. {

  173.     const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh,

  174.               rv = RV << rsh, gv = GV << gsh, bv = BV << bsh;

  175.     const unsigned rnd = 257u << (S - 1);

  176.     int i;

  177. 

  178.     for (i = 0; i < width; i++) {

  179.         int px = input_pixel(i) >> shp;

  180.         int b = (px & maskb) >> shb;

  181.         int g = (px & maskg) >> shg;

  182.         int r = (px & maskr) >> shr;

  183. 

  184.         dstU[i] = (ru * r + gu * g + bu * b + rnd) >> S;

  185.         dstV[i] = (rv * r + gv * g + bv * b + rnd) >> S;

  186.     }

  187. }

  188. 

  189. static av_always_inline void

  190. rgb16_32ToUV_half_c_template(uint8_t *dstU, uint8_t *dstV,

  191.                              const uint8_t *src, int width,

  192.                              enum PixelFormat origin,

  193.                              int shr,   int shg,   int shb, int shp,

  194.                              int maskr, int maskg, int maskb,

  195.                              int rsh,   int gsh,   int bsh, int S)

  196. {

  197.     const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh,

  198.               rv = RV << rsh, gv = GV << gsh, bv = BV << bsh,

  199.               maskgx = ~(maskr | maskb);

  200.     const unsigned rnd = 257u << S;

  201.     int i;

  202. 

  203.     maskr |= maskr << 1; maskb |= maskb << 1; maskg |= maskg << 1;

  204.     for (i = 0; i < width; i++) {

  205.         int px0 = input_pixel(2 * i + 0) >> shp;

  206.         int px1 = input_pixel(2 * i + 1) >> shp;

  207.         int b, r, g = (px0 & maskgx) + (px1 & maskgx);

  208.         int rb = px0 + px1 - g;

  209. 

  210.         b = (rb & maskb) >> shb;

  211.         if (shp || origin == PIX_FMT_BGR565LE || origin == PIX_FMT_BGR565BE ||

  212.             origin == PIX_FMT_RGB565LE || origin == PIX_FMT_RGB565BE) {

  213.             g >>= shg;

  214.         } else {

  215.             g = (g  & maskg) >> shg;

  216.         }

  217.         r = (rb & maskr) >> shr;

  218. 

  219.         dstU[i] = (ru * r + gu * g + bu * b + rnd) >> (S + 1);

  220.         dstV[i] = (rv * r + gv * g + bv * b + rnd) >> (S + 1);

  221.     }

  222. }

  223. 

  224. #undef input_pixel

  225. 

  226. #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr, \

  227.                          maskg, maskb, rsh, gsh, bsh, S) \

  228. static void name ## ToY_c(uint8_t *dst, const uint8_t *src, \

  229.                           int width, uint32_t *unused) \

  230. { \

  231.     rgb16_32ToY_c_template(dst, src, width, fmt, shr, shg, shb, shp, \

  232.                            maskr, maskg, maskb, rsh, gsh, bsh, S); \

  233. } \

  234.  \

  235. static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \

  236.                            const uint8_t *src, const uint8_t *dummy, \

  237.                            int width, uint32_t *unused) \

  238. { \

  239.     rgb16_32ToUV_c_template(dstU, dstV, src, width, fmt, shr, shg, shb, shp, \

  240.                             maskr, maskg, maskb, rsh, gsh, bsh, S); \

  241. } \

  242.  \

  243. static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \

  244.                                 const uint8_t *src, const uint8_t *dummy, \

  245.                                 int width, uint32_t *unused) \

  246. { \

  247.     rgb16_32ToUV_half_c_template(dstU, dstV, src, width, fmt, shr, shg, shb, shp, \

  248.                                  maskr, maskg, maskb, rsh, gsh, bsh, S); \

  249. }

  250. 

  251. rgb16_32_wrapper(PIX_FMT_BGR32,    bgr32,  16, 0,  0, 0, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT+8)

  252. rgb16_32_wrapper(PIX_FMT_BGR32_1,  bgr321, 16, 0,  0, 8, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT+8)

  253. rgb16_32_wrapper(PIX_FMT_RGB32,    rgb32,   0, 0, 16, 0,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT+8)

  254. rgb16_32_wrapper(PIX_FMT_RGB32_1,  rgb321,  0, 0, 16, 8,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT+8)

  255. rgb16_32_wrapper(PIX_FMT_BGR565LE, bgr16le, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT+8)

  256. rgb16_32_wrapper(PIX_FMT_BGR555LE, bgr15le, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT+7)

  257. rgb16_32_wrapper(PIX_FMT_BGR444LE, bgr12le, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT+4)

  258. rgb16_32_wrapper(PIX_FMT_RGB565LE, rgb16le, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT+8)

  259. rgb16_32_wrapper(PIX_FMT_RGB555LE, rgb15le, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT+7)

  260. rgb16_32_wrapper(PIX_FMT_RGB444LE, rgb12le, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT+4)

  261. rgb16_32_wrapper(PIX_FMT_BGR565BE, bgr16be, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT+8)

  262. rgb16_32_wrapper(PIX_FMT_BGR555BE, bgr15be, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT+7)

  263. rgb16_32_wrapper(PIX_FMT_BGR444BE, bgr12be, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT+4)

  264. rgb16_32_wrapper(PIX_FMT_RGB565BE, rgb16be, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT+8)

  265. rgb16_32_wrapper(PIX_FMT_RGB555BE, rgb15be, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT+7)

  266. rgb16_32_wrapper(PIX_FMT_RGB444BE, rgb12be, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT+4)

  267. 

  268. static void abgrToA_c(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)

  269. {

  270.     int i;

  271.     for (i=0; i<width; i++) {

  272.         dst[i]= src[4*i];

  273.     }

  274. }

  275. 

  276. static void rgbaToA_c(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)

  277. {

  278.     int i;

  279.     for (i=0; i<width; i++) {

  280.         dst[i]= src[4*i+3];

  281.     }

  282. }

  283. 

  284. static void palToY_c(uint8_t *dst, const uint8_t *src, int width, uint32_t *pal)

  285. {

  286.     int i;

  287.     for (i=0; i<width; i++) {

  288.         int d= src[i];

  289. 

  290.         dst[i]= pal[d] & 0xFF;

  291.     }

  292. }

  293. 

  294. static void palToUV_c(uint8_t *dstU, uint8_t *dstV,

  295.                       const uint8_t *src1, const uint8_t *src2,

  296.                       int width, uint32_t *pal)

  297. {

  298.     int i;

  299.     assert(src1 == src2);

  300.     for (i=0; i<width; i++) {

  301.         int p= pal[src1[i]];

  302. 

  303.         dstU[i]= p>>8;

  304.         dstV[i]= p>>16;

  305.     }

  306. }

  307. 

  308. static void monowhite2Y_c(uint8_t *dst, const uint8_t *src,

  309.                           int width, uint32_t *unused)

  310. {

  311.     int i, j;

  312.     for (i=0; i<width/8; i++) {

  313.         int d= ~src[i];

  314.         for(j=0; j<8; j++)

  315.             dst[8*i+j]= ((d>>(7-j))&1)*255;

  316.     }

  317. }

  318. 

  319. static void monoblack2Y_c(uint8_t *dst, const uint8_t *src,

  320.                           int width, uint32_t *unused)

  321. {

  322.     int i, j;

  323.     for (i=0; i<width/8; i++) {

  324.         int d= src[i];

  325.         for(j=0; j<8; j++)

  326.             dst[8*i+j]= ((d>>(7-j))&1)*255;

  327.     }

  328. }

  329. 

  330. static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, int width,

  331.                       uint32_t *unused)

  332. {

  333.     int i;

  334.     for (i=0; i<width; i++)

  335.         dst[i]= src[2*i];

  336. }

  337. 

  338. static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  339.                        const uint8_t *src2, int width, uint32_t *unused)

  340. {

  341.     int i;

  342.     for (i=0; i<width; i++) {

  343.         dstU[i]= src1[4*i + 1];

  344.         dstV[i]= src1[4*i + 3];

  345.     }

  346.     assert(src1 == src2);

  347. }

  348. 

  349. static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, int width, uint32_t *unused)

  350. {

  351.     int i;

  352.     const uint16_t *src = (const uint16_t *) _src;

  353.     uint16_t *dst = (uint16_t *) _dst;

  354.     for (i=0; i<width; i++) {

  355.         dst[i] = av_bswap16(src[i]);

  356.     }

  357. }

  358. 

  359. static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src1,

  360.                         const uint8_t *_src2, int width, uint32_t *unused)

  361. {

  362.     int i;

  363.     const uint16_t *src1 = (const uint16_t *) _src1,

  364.                    *src2 = (const uint16_t *) _src2;

  365.     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV;

  366.     for (i=0; i<width; i++) {

  367.         dstU[i] = av_bswap16(src1[i]);

  368.         dstV[i] = av_bswap16(src2[i]);

  369.     }

  370. }

  371. 

  372. /* This is almost identical to the previous, end exists only because

  373.  * yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */

  374. static void uyvyToY_c(uint8_t *dst, const uint8_t *src, int width,

  375.                       uint32_t *unused)

  376. {

  377.     int i;

  378.     for (i=0; i<width; i++)

  379.         dst[i]= src[2*i+1];

  380. }

  381. 

  382. static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  383.                        const uint8_t *src2, int width, uint32_t *unused)

  384. {

  385.     int i;

  386.     for (i=0; i<width; i++) {

  387.         dstU[i]= src1[4*i + 0];

  388.         dstV[i]= src1[4*i + 2];

  389.     }

  390.     assert(src1 == src2);

  391. }

  392. 

  393. static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,

  394.                                         const uint8_t *src, int width)

  395. {

  396.     int i;

  397.     for (i = 0; i < width; i++) {

  398.         dst1[i] = src[2*i+0];

  399.         dst2[i] = src[2*i+1];

  400.     }

  401. }

  402. 

  403. static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,

  404.                        const uint8_t *src1, const uint8_t *src2,

  405.                        int width, uint32_t *unused)

  406. {

  407.     nvXXtoUV_c(dstU, dstV, src1, width);

  408. }

  409. 

  410. static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,

  411.                        const uint8_t *src1, const uint8_t *src2,

  412.                        int width, uint32_t *unused)

  413. {

  414.     nvXXtoUV_c(dstV, dstU, src1, width);

  415. }

  416. 

  417. #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))

  418. 

  419. static void bgr24ToY_c(uint8_t *dst, const uint8_t *src,

  420.                        int width, uint32_t *unused)

  421. {

  422.     int i;

  423.     for (i=0; i<width; i++) {

  424.         int b= src[i*3+0];

  425.         int g= src[i*3+1];

  426.         int r= src[i*3+2];

  427. 

  428.         dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);

  429.     }

  430. }

  431. 

  432. static void bgr24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  433.                         const uint8_t *src2, int width, uint32_t *unused)

  434. {

  435.     int i;

  436.     for (i=0; i<width; i++) {

  437.         int b= src1[3*i + 0];

  438.         int g= src1[3*i + 1];

  439.         int r= src1[3*i + 2];

  440. 

  441.         dstU[i]= (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  442.         dstV[i]= (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  443.     }

  444.     assert(src1 == src2);

  445. }

  446. 

  447. static void bgr24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  448.                              const uint8_t *src2, int width, uint32_t *unused)

  449. {

  450.     int i;

  451.     for (i=0; i<width; i++) {

  452.         int b= src1[6*i + 0] + src1[6*i + 3];

  453.         int g= src1[6*i + 1] + src1[6*i + 4];

  454.         int r= src1[6*i + 2] + src1[6*i + 5];

  455. 

  456.         dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  457.         dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  458.     }

  459.     assert(src1 == src2);

  460. }

  461. 

  462. static void rgb24ToY_c(uint8_t *dst, const uint8_t *src, int width,

  463.                        uint32_t *unused)

  464. {

  465.     int i;

  466.     for (i=0; i<width; i++) {

  467.         int r= src[i*3+0];

  468.         int g= src[i*3+1];

  469.         int b= src[i*3+2];

  470. 

  471.         dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);

  472.     }

  473. }

  474. 

  475. static void rgb24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  476.                         const uint8_t *src2, int width, uint32_t *unused)

  477. {

  478.     int i;

  479.     assert(src1==src2);

  480.     for (i=0; i<width; i++) {

  481.         int r= src1[3*i + 0];

  482.         int g= src1[3*i + 1];

  483.         int b= src1[3*i + 2];

  484. 

  485.         dstU[i]= (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  486.         dstV[i]= (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;

  487.     }

  488. }

  489. 

  490. static void rgb24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,

  491.                              const uint8_t *src2, int width, uint32_t *unused)

  492. {

  493.     int i;

  494.     assert(src1==src2);

  495.     for (i=0; i<width; i++) {

  496.         int r= src1[6*i + 0] + src1[6*i + 3];

  497.         int g= src1[6*i + 1] + src1[6*i + 4];

  498.         int b= src1[6*i + 2] + src1[6*i + 5];

  499. 

  500.         dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  501.         dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

  502.     }

  503. }

  504. 

  505. static void planar_rgb_to_y(uint8_t *dst, const uint8_t *src[4], int width)

  506. {

  507.     int i;

  508.     for (i = 0; i < width; i++) {

  509.         int g = src[0][i];

  510.         int b = src[1][i];

  511.         int r = src[2][i];

  512. 

  513.         dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);

  514.     }

  515. }

  516. 

  517. static void planar_rgb16le_to_y(uint8_t *_dst, const uint8_t *_src[4], int width)

  518. {

  519.     int i;

  520.     const uint16_t **src = (const uint16_t **) _src;

  521.     uint16_t *dst = (uint16_t *) _dst;

  522.     for (i = 0; i < width; i++) {

  523.         int g = AV_RL16(src[0] + i);

  524.         int b = AV_RL16(src[1] + i);

  525.         int r = AV_RL16(src[2] + i);

  526. 

  527.         dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);

  528.     }

  529. }

  530. 

  531. static void planar_rgb16be_to_y(uint8_t *_dst, const uint8_t *_src[4], int width)

  532. {

  533.     int i;

  534.     const uint16_t **src = (const uint16_t **) _src;

  535.     uint16_t *dst = (uint16_t *) _dst;

  536.     for (i = 0; i < width; i++) {

  537.         int g = AV_RB16(src[0] + i);

  538.         int b = AV_RB16(src[1] + i);

  539.         int r = AV_RB16(src[2] + i);

  540. 

  541.         dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);

  542.     }

  543. }

  544. 

  545. static void planar_rgb_to_uv(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width)

  546. {

  547.     int i;

  548.     for (i = 0; i < width; i++) {

  549.         int g = src[0][i];

  550.         int b = src[1][i];

  551.         int r = src[2][i];

  552. 

  553.         dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);

  554.         dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);

  555.     }

  556. }

  557. 

  558. static void planar_rgb16le_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src[4], int width)

  559. {

  560.     int i;

  561.     const uint16_t **src = (const uint16_t **) _src;

  562.     uint16_t *dstU = (uint16_t *) _dstU;

  563.     uint16_t *dstV = (uint16_t *) _dstV;

  564.     for (i = 0; i < width; i++) {

  565.         int g = AV_RL16(src[0] + i);

  566.         int b = AV_RL16(src[1] + i);

  567.         int r = AV_RL16(src[2] + i);

  568. 

  569.         dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);

  570.         dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);

  571.     }

  572. }

  573. 

  574. static void planar_rgb16be_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src[4], int width)

  575. {

  576.     int i;

  577.     const uint16_t **src = (const uint16_t **) _src;

  578.     uint16_t *dstU = (uint16_t *) _dstU;

  579.     uint16_t *dstV = (uint16_t *) _dstV;

  580.     for (i = 0; i < width; i++) {

  581.         int g = AV_RB16(src[0] + i);

  582.         int b = AV_RB16(src[1] + i);

  583.         int r = AV_RB16(src[2] + i);

  584. 

  585.         dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);

  586.         dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);

  587.     }

  588. }

  589. 

  590. av_cold void ff_sws_init_input_funcs(SwsContext *c)

  591. {

  592.     enum PixelFormat srcFormat = c->srcFormat;

  593. 

  594.     c->chrToYV12 = NULL;

  595.     switch(srcFormat) {

  596.         case PIX_FMT_YUYV422  : c->chrToYV12 = yuy2ToUV_c; break;

  597.         case PIX_FMT_UYVY422  : c->chrToYV12 = uyvyToUV_c; break;

  598.         case PIX_FMT_NV12     : c->chrToYV12 = nv12ToUV_c; break;

  599.         case PIX_FMT_NV21     : c->chrToYV12 = nv21ToUV_c; break;

  600.         case PIX_FMT_RGB8     :

  601.         case PIX_FMT_BGR8     :

  602.         case PIX_FMT_PAL8     :

  603.         case PIX_FMT_BGR4_BYTE:

  604.         case PIX_FMT_RGB4_BYTE: c->chrToYV12 = palToUV_c; break;

  605.         case PIX_FMT_GBRP9LE:

  606.         case PIX_FMT_GBRP10LE:

  607.         case PIX_FMT_GBRP16LE:  c->readChrPlanar = planar_rgb16le_to_uv; break;

  608.         case PIX_FMT_GBRP9BE:

  609.         case PIX_FMT_GBRP10BE:

  610.         case PIX_FMT_GBRP16BE:  c->readChrPlanar = planar_rgb16be_to_uv; break;

  611.         case PIX_FMT_GBRP:      c->readChrPlanar = planar_rgb_to_uv; break;

  612. #if HAVE_BIGENDIAN

  613.         case PIX_FMT_YUV444P9LE:

  614.         case PIX_FMT_YUV422P9LE:

  615.         case PIX_FMT_YUV420P9LE:

  616.         case PIX_FMT_YUV422P10LE:

  617.         case PIX_FMT_YUV444P10LE:

  618.         case PIX_FMT_YUV420P10LE:

  619.         case PIX_FMT_YUV420P16LE:

  620.         case PIX_FMT_YUV422P16LE:

  621.         case PIX_FMT_YUV444P16LE: c->chrToYV12 = bswap16UV_c; break;

  622. #else

  623.         case PIX_FMT_YUV444P9BE:

  624.         case PIX_FMT_YUV422P9BE:

  625.         case PIX_FMT_YUV420P9BE:

  626.         case PIX_FMT_YUV444P10BE:

  627.         case PIX_FMT_YUV422P10BE:

  628.         case PIX_FMT_YUV420P10BE:

  629.         case PIX_FMT_YUV420P16BE:

  630.         case PIX_FMT_YUV422P16BE:

  631.         case PIX_FMT_YUV444P16BE: c->chrToYV12 = bswap16UV_c; break;

  632. #endif

  633.     }

  634.     if (c->chrSrcHSubSample) {

  635.         switch(srcFormat) {

  636.         case PIX_FMT_RGB48BE : c->chrToYV12 = rgb48BEToUV_half_c; break;

  637.         case PIX_FMT_RGB48LE : c->chrToYV12 = rgb48LEToUV_half_c; break;

  638.         case PIX_FMT_BGR48BE : c->chrToYV12 = bgr48BEToUV_half_c; break;

  639.         case PIX_FMT_BGR48LE : c->chrToYV12 = bgr48LEToUV_half_c; break;

  640.         case PIX_FMT_RGB32   : c->chrToYV12 = bgr32ToUV_half_c;   break;

  641.         case PIX_FMT_RGB32_1 : c->chrToYV12 = bgr321ToUV_half_c;  break;

  642.         case PIX_FMT_BGR24   : c->chrToYV12 = bgr24ToUV_half_c;   break;

  643.         case PIX_FMT_BGR565LE: c->chrToYV12 = bgr16leToUV_half_c; break;

  644.         case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_half_c; break;

  645.         case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_half_c; break;

  646.         case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_half_c; break;

  647.         case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_half_c; break;

  648.         case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_half_c; break;

  649.         case PIX_FMT_BGR32   : c->chrToYV12 = rgb32ToUV_half_c;   break;

  650.         case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_half_c;  break;

  651.         case PIX_FMT_RGB24   : c->chrToYV12 = rgb24ToUV_half_c;   break;

  652.         case PIX_FMT_RGB565LE: c->chrToYV12 = rgb16leToUV_half_c; break;

  653.         case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_half_c; break;

  654.         case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_half_c; break;

  655.         case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_half_c; break;

  656.         case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_half_c; break;

  657.         case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_half_c; break;

  658.         }

  659.     } else {

  660.         switch(srcFormat) {

  661.         case PIX_FMT_RGB48BE : c->chrToYV12 = rgb48BEToUV_c; break;

  662.         case PIX_FMT_RGB48LE : c->chrToYV12 = rgb48LEToUV_c; break;

  663.         case PIX_FMT_BGR48BE : c->chrToYV12 = bgr48BEToUV_c; break;

  664.         case PIX_FMT_BGR48LE : c->chrToYV12 = bgr48LEToUV_c; break;

  665.         case PIX_FMT_RGB32   : c->chrToYV12 = bgr32ToUV_c;   break;

  666.         case PIX_FMT_RGB32_1 : c->chrToYV12 = bgr321ToUV_c;  break;

  667.         case PIX_FMT_BGR24   : c->chrToYV12 = bgr24ToUV_c;   break;

  668.         case PIX_FMT_BGR565LE: c->chrToYV12 = bgr16leToUV_c; break;

  669.         case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_c; break;

  670.         case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_c; break;

  671.         case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_c; break;

  672.         case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_c; break;

  673.         case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_c; break;

  674.         case PIX_FMT_BGR32   : c->chrToYV12 = rgb32ToUV_c;   break;

  675.         case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_c;  break;

  676.         case PIX_FMT_RGB24   : c->chrToYV12 = rgb24ToUV_c;   break;

  677.         case PIX_FMT_RGB565LE: c->chrToYV12 = rgb16leToUV_c; break;

  678.         case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_c; break;

  679.         case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_c; break;

  680.         case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_c; break;

  681.         case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_c; break;

  682.         case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_c; break;

  683.         }

  684.     }

  685. 

  686.     c->lumToYV12 = NULL;

  687.     c->alpToYV12 = NULL;

  688.     switch (srcFormat) {

  689.     case PIX_FMT_GBRP9LE:

  690.     case PIX_FMT_GBRP10LE:

  691.     case PIX_FMT_GBRP16LE: c->readLumPlanar = planar_rgb16le_to_y; break;

  692.     case PIX_FMT_GBRP9BE:

  693.     case PIX_FMT_GBRP10BE:

  694.     case PIX_FMT_GBRP16BE: c->readLumPlanar = planar_rgb16be_to_y; break;

  695.     case PIX_FMT_GBRP:     c->readLumPlanar = planar_rgb_to_y; break;

  696. #if HAVE_BIGENDIAN

  697.     case PIX_FMT_YUV444P9LE:

  698.     case PIX_FMT_YUV422P9LE:

  699.     case PIX_FMT_YUV420P9LE:

  700.     case PIX_FMT_YUV444P10LE:

  701.     case PIX_FMT_YUV422P10LE:

  702.     case PIX_FMT_YUV420P10LE:

  703.     case PIX_FMT_YUV420P16LE:

  704.     case PIX_FMT_YUV422P16LE:

  705.     case PIX_FMT_YUV444P16LE:

  706.     case PIX_FMT_GRAY16LE: c->lumToYV12 = bswap16Y_c; break;

  707. #else

  708.     case PIX_FMT_YUV444P9BE:

  709.     case PIX_FMT_YUV422P9BE:

  710.     case PIX_FMT_YUV420P9BE:

  711.     case PIX_FMT_YUV444P10BE:

  712.     case PIX_FMT_YUV422P10BE:

  713.     case PIX_FMT_YUV420P10BE:

  714.     case PIX_FMT_YUV420P16BE:

  715.     case PIX_FMT_YUV422P16BE:

  716.     case PIX_FMT_YUV444P16BE:

  717.     case PIX_FMT_GRAY16BE: c->lumToYV12 = bswap16Y_c; break;

  718. #endif

  719.     case PIX_FMT_YUYV422  :

  720.     case PIX_FMT_Y400A    : c->lumToYV12 = yuy2ToY_c; break;

  721.     case PIX_FMT_UYVY422  : c->lumToYV12 = uyvyToY_c;    break;

  722.     case PIX_FMT_BGR24    : c->lumToYV12 = bgr24ToY_c;   break;

  723.     case PIX_FMT_BGR565LE : c->lumToYV12 = bgr16leToY_c; break;

  724.     case PIX_FMT_BGR565BE : c->lumToYV12 = bgr16beToY_c; break;

  725.     case PIX_FMT_BGR555LE : c->lumToYV12 = bgr15leToY_c; break;

  726.     case PIX_FMT_BGR555BE : c->lumToYV12 = bgr15beToY_c; break;

  727.     case PIX_FMT_BGR444LE : c->lumToYV12 = bgr12leToY_c; break;

  728.     case PIX_FMT_BGR444BE : c->lumToYV12 = bgr12beToY_c; break;

  729.     case PIX_FMT_RGB24    : c->lumToYV12 = rgb24ToY_c;   break;

  730.     case PIX_FMT_RGB565LE : c->lumToYV12 = rgb16leToY_c; break;

  731.     case PIX_FMT_RGB565BE : c->lumToYV12 = rgb16beToY_c; break;

  732.     case PIX_FMT_RGB555LE : c->lumToYV12 = rgb15leToY_c; break;

  733.     case PIX_FMT_RGB555BE : c->lumToYV12 = rgb15beToY_c; break;

  734.     case PIX_FMT_RGB444LE : c->lumToYV12 = rgb12leToY_c; break;

  735.     case PIX_FMT_RGB444BE : c->lumToYV12 = rgb12beToY_c; break;

  736.     case PIX_FMT_RGB8     :

  737.     case PIX_FMT_BGR8     :

  738.     case PIX_FMT_PAL8     :

  739.     case PIX_FMT_BGR4_BYTE:

  740.     case PIX_FMT_RGB4_BYTE: c->lumToYV12 = palToY_c; break;

  741.     case PIX_FMT_MONOBLACK: c->lumToYV12 = monoblack2Y_c; break;

  742.     case PIX_FMT_MONOWHITE: c->lumToYV12 = monowhite2Y_c; break;

  743.     case PIX_FMT_RGB32  : c->lumToYV12 = bgr32ToY_c;  break;

  744.     case PIX_FMT_RGB32_1: c->lumToYV12 = bgr321ToY_c; break;

  745.     case PIX_FMT_BGR32  : c->lumToYV12 = rgb32ToY_c;  break;

  746.     case PIX_FMT_BGR32_1: c->lumToYV12 = rgb321ToY_c; break;

  747.     case PIX_FMT_RGB48BE: c->lumToYV12 = rgb48BEToY_c; break;

  748.     case PIX_FMT_RGB48LE: c->lumToYV12 = rgb48LEToY_c; break;

  749.     case PIX_FMT_BGR48BE: c->lumToYV12 = bgr48BEToY_c; break;

  750.     case PIX_FMT_BGR48LE: c->lumToYV12 = bgr48LEToY_c; break;

  751.     }

  752.     if (c->alpPixBuf) {

  753.         switch (srcFormat) {

  754.         case PIX_FMT_BGRA:

  755.         case PIX_FMT_RGBA:  c->alpToYV12 = rgbaToA_c; break;

  756.         case PIX_FMT_ABGR:

  757.         case PIX_FMT_ARGB:  c->alpToYV12 = abgrToA_c; break;

  758.         case PIX_FMT_Y400A: c->alpToYV12 = uyvyToY_c; break;

  759.         }

  760.     }

  761. }