Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (C) 2001-2012 Michael Niedermayer <michaelni@gmx.at>
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #include <math.h>
  22. #include <stdint.h>
  23. #include <stdio.h>
  24. #include <string.h>
  25.  
  26. #include "libavutil/avutil.h"
  27. #include "libavutil/bswap.h"
  28. #include "libavutil/cpu.h"
  29. #include "libavutil/intreadwrite.h"
  30. #include "libavutil/mathematics.h"
  31. #include "libavutil/pixdesc.h"
  32. #include "libavutil/avassert.h"
  33. #include "config.h"
  34. #include "rgb2rgb.h"
  35. #include "swscale.h"
  36. #include "swscale_internal.h"
  37.  
  38. #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
  39.  
  40. #define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? b_r : r_b)
  41. #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? r_b : b_r)
  42.  
  43. static av_always_inline void
  44. rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
  45.                     enum AVPixelFormat origin, int32_t *rgb2yuv)
  46. {
  47.     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
  48.     int i;
  49.     for (i = 0; i < width; i++) {
  50.         unsigned int r_b = input_pixel(&src[i*4+0]);
  51.         unsigned int   g = input_pixel(&src[i*4+1]);
  52.         unsigned int b_r = input_pixel(&src[i*4+2]);
  53.  
  54.         dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
  55.     }
  56. }
  57.  
  58. static av_always_inline void
  59. rgb64ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
  60.                     const uint16_t *src1, const uint16_t *src2,
  61.                     int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
  62. {
  63.     int i;
  64.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  65.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  66.     av_assert1(src1==src2);
  67.     for (i = 0; i < width; i++) {
  68.         int r_b = input_pixel(&src1[i*4+0]);
  69.         int   g = input_pixel(&src1[i*4+1]);
  70.         int b_r = input_pixel(&src1[i*4+2]);
  71.  
  72.         dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
  73.         dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
  74.     }
  75. }
  76.  
  77. static av_always_inline void
  78. rgb64ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
  79.                           const uint16_t *src1, const uint16_t *src2,
  80.                           int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
  81. {
  82.     int i;
  83.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  84.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  85.     av_assert1(src1==src2);
  86.     for (i = 0; i < width; i++) {
  87.         int r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
  88.         int   g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
  89.         int b_r = (input_pixel(&src1[8 * i + 2]) + input_pixel(&src1[8 * i + 6]) + 1) >> 1;
  90.  
  91.         dstU[i]= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
  92.         dstV[i]= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
  93.     }
  94. }
  95.  
  96. #define rgb64funcs(pattern, BE_LE, origin) \
  97. static void pattern ## 64 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, const uint8_t *unused1,\
  98.                                     int width, uint32_t *rgb2yuv) \
  99. { \
  100.     const uint16_t *src = (const uint16_t *) _src; \
  101.     uint16_t *dst = (uint16_t *) _dst; \
  102.     rgb64ToY_c_template(dst, src, width, origin, rgb2yuv); \
  103. } \
  104.  \
  105. static void pattern ## 64 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
  106.                                     const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
  107.                                     int width, uint32_t *rgb2yuv) \
  108. { \
  109.     const uint16_t *src1 = (const uint16_t *) _src1, \
  110.                    *src2 = (const uint16_t *) _src2; \
  111.     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
  112.     rgb64ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
  113. } \
  114.  \
  115. static void pattern ## 64 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
  116.                                     const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
  117.                                     int width, uint32_t *rgb2yuv) \
  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.     rgb64ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
  123. }
  124.  
  125. rgb64funcs(rgb, LE, AV_PIX_FMT_RGBA64LE)
  126. rgb64funcs(rgb, BE, AV_PIX_FMT_RGBA64BE)
  127.  
  128. static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
  129.                                                  const uint16_t *src, int width,
  130.                                                  enum AVPixelFormat origin,
  131.                                                  int32_t *rgb2yuv)
  132. {
  133.     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
  134.     int i;
  135.     for (i = 0; i < width; i++) {
  136.         unsigned int r_b = input_pixel(&src[i * 3 + 0]);
  137.         unsigned int g   = input_pixel(&src[i * 3 + 1]);
  138.         unsigned int b_r = input_pixel(&src[i * 3 + 2]);
  139.  
  140.         dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
  141.     }
  142. }
  143.  
  144. static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
  145.                                                   uint16_t *dstV,
  146.                                                   const uint16_t *src1,
  147.                                                   const uint16_t *src2,
  148.                                                   int width,
  149.                                                   enum AVPixelFormat origin,
  150.                                                   int32_t *rgb2yuv)
  151. {
  152.     int i;
  153.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  154.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  155.     av_assert1(src1 == src2);
  156.     for (i = 0; i < width; i++) {
  157.         int r_b = input_pixel(&src1[i * 3 + 0]);
  158.         int g   = input_pixel(&src1[i * 3 + 1]);
  159.         int b_r = input_pixel(&src1[i * 3 + 2]);
  160.  
  161.         dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
  162.         dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
  163.     }
  164. }
  165.  
  166. static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
  167.                                                        uint16_t *dstV,
  168.                                                        const uint16_t *src1,
  169.                                                        const uint16_t *src2,
  170.                                                        int width,
  171.                                                        enum AVPixelFormat origin,
  172.                                                        int32_t *rgb2yuv)
  173. {
  174.     int i;
  175.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  176.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  177.     av_assert1(src1 == src2);
  178.     for (i = 0; i < width; i++) {
  179.         int r_b = (input_pixel(&src1[6 * i + 0]) +
  180.                    input_pixel(&src1[6 * i + 3]) + 1) >> 1;
  181.         int g   = (input_pixel(&src1[6 * i + 1]) +
  182.                    input_pixel(&src1[6 * i + 4]) + 1) >> 1;
  183.         int b_r = (input_pixel(&src1[6 * i + 2]) +
  184.                    input_pixel(&src1[6 * i + 5]) + 1) >> 1;
  185.  
  186.         dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
  187.         dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
  188.     }
  189. }
  190.  
  191. #undef r
  192. #undef b
  193. #undef input_pixel
  194.  
  195. #define rgb48funcs(pattern, BE_LE, origin)                              \
  196. static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst,              \
  197.                                             const uint8_t *_src,        \
  198.                                             const uint8_t *unused0, const uint8_t *unused1,\
  199.                                             int width,                  \
  200.                                             uint32_t *rgb2yuv)          \
  201. {                                                                       \
  202.     const uint16_t *src = (const uint16_t *)_src;                       \
  203.     uint16_t *dst       = (uint16_t *)_dst;                             \
  204.     rgb48ToY_c_template(dst, src, width, origin, rgb2yuv);              \
  205. }                                                                       \
  206.                                                                         \
  207. static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU,            \
  208.                                              uint8_t *_dstV,            \
  209.                                              const uint8_t *unused0,    \
  210.                                              const uint8_t *_src1,      \
  211.                                              const uint8_t *_src2,      \
  212.                                              int width,                 \
  213.                                              uint32_t *rgb2yuv)         \
  214. {                                                                       \
  215.     const uint16_t *src1 = (const uint16_t *)_src1,                     \
  216.                    *src2 = (const uint16_t *)_src2;                     \
  217.     uint16_t *dstU = (uint16_t *)_dstU,                                 \
  218.              *dstV = (uint16_t *)_dstV;                                 \
  219.     rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);        \
  220. }                                                                       \
  221.                                                                         \
  222. static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU,       \
  223.                                                   uint8_t *_dstV,       \
  224.                                                   const uint8_t *unused0,    \
  225.                                                   const uint8_t *_src1, \
  226.                                                   const uint8_t *_src2, \
  227.                                                   int width,            \
  228.                                                   uint32_t *rgb2yuv)    \
  229. {                                                                       \
  230.     const uint16_t *src1 = (const uint16_t *)_src1,                     \
  231.                    *src2 = (const uint16_t *)_src2;                     \
  232.     uint16_t *dstU = (uint16_t *)_dstU,                                 \
  233.              *dstV = (uint16_t *)_dstV;                                 \
  234.     rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);   \
  235. }
  236.  
  237. rgb48funcs(rgb, LE, AV_PIX_FMT_RGB48LE)
  238. rgb48funcs(rgb, BE, AV_PIX_FMT_RGB48BE)
  239. rgb48funcs(bgr, LE, AV_PIX_FMT_BGR48LE)
  240. rgb48funcs(bgr, BE, AV_PIX_FMT_BGR48BE)
  241.  
  242. #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA ||                      \
  243.                          origin == AV_PIX_FMT_BGRA ||                      \
  244.                          origin == AV_PIX_FMT_ARGB ||                      \
  245.                          origin == AV_PIX_FMT_ABGR)                        \
  246.                         ? AV_RN32A(&src[(i) * 4])                       \
  247.                         : (isBE(origin) ? AV_RB16(&src[(i) * 2])        \
  248.                                         : AV_RL16(&src[(i) * 2])))
  249.  
  250. static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
  251.                                                     const uint8_t *src,
  252.                                                     int width,
  253.                                                     enum AVPixelFormat origin,
  254.                                                     int shr, int shg,
  255.                                                     int shb, int shp,
  256.                                                     int maskr, int maskg,
  257.                                                     int maskb, int rsh,
  258.                                                     int gsh, int bsh, int S,
  259.                                                     int32_t *rgb2yuv)
  260. {
  261.     const int ry       = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
  262.     const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
  263.     int i;
  264.  
  265.     for (i = 0; i < width; i++) {
  266.         int px = input_pixel(i) >> shp;
  267.         int b  = (px & maskb) >> shb;
  268.         int g  = (px & maskg) >> shg;
  269.         int r  = (px & maskr) >> shr;
  270.  
  271.         dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
  272.     }
  273. }
  274.  
  275. static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
  276.                                                      int16_t *dstV,
  277.                                                      const uint8_t *src,
  278.                                                      int width,
  279.                                                      enum AVPixelFormat origin,
  280.                                                      int shr, int shg,
  281.                                                      int shb, int shp,
  282.                                                      int maskr, int maskg,
  283.                                                      int maskb, int rsh,
  284.                                                      int gsh, int bsh, int S,
  285.                                                      int32_t *rgb2yuv)
  286. {
  287.     const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
  288.               rv       = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh;
  289.     const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
  290.     int i;
  291.  
  292.     for (i = 0; i < width; i++) {
  293.         int px = input_pixel(i) >> shp;
  294.         int b  = (px & maskb)   >> shb;
  295.         int g  = (px & maskg)   >> shg;
  296.         int r  = (px & maskr)   >> shr;
  297.  
  298.         dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
  299.         dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
  300.     }
  301. }
  302.  
  303. static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
  304.                                                           int16_t *dstV,
  305.                                                           const uint8_t *src,
  306.                                                           int width,
  307.                                                           enum AVPixelFormat origin,
  308.                                                           int shr, int shg,
  309.                                                           int shb, int shp,
  310.                                                           int maskr, int maskg,
  311.                                                           int maskb, int rsh,
  312.                                                           int gsh, int bsh, int S,
  313.                                                           int32_t *rgb2yuv)
  314. {
  315.     const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
  316.               rv       = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh,
  317.               maskgx   = ~(maskr | maskb);
  318.     const unsigned rnd = (256U<<(S)) + (1<<(S-6));
  319.     int i;
  320.  
  321.     maskr |= maskr << 1;
  322.     maskb |= maskb << 1;
  323.     maskg |= maskg << 1;
  324.     for (i = 0; i < width; i++) {
  325.         int px0 = input_pixel(2 * i + 0) >> shp;
  326.         int px1 = input_pixel(2 * i + 1) >> shp;
  327.         int b, r, g = (px0 & maskgx) + (px1 & maskgx);
  328.         int rb = px0 + px1 - g;
  329.  
  330.         b = (rb & maskb) >> shb;
  331.         if (shp ||
  332.             origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
  333.             origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
  334.             g >>= shg;
  335.         } else {
  336.             g = (g & maskg) >> shg;
  337.         }
  338.         r = (rb & maskr) >> shr;
  339.  
  340.         dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
  341.         dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
  342.     }
  343. }
  344.  
  345. #undef input_pixel
  346.  
  347. #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr,          \
  348.                          maskg, maskb, rsh, gsh, bsh, S)                \
  349. static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,            \
  350.                           int width, uint32_t *tab)                     \
  351. {                                                                       \
  352.     rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp,    \
  353.                            maskr, maskg, maskb, rsh, gsh, bsh, S, tab); \
  354. }                                                                       \
  355.                                                                         \
  356. static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV,                \
  357.                            const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy,    \
  358.                            int width, uint32_t *tab)                    \
  359. {                                                                       \
  360.     rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt,                \
  361.                             shr, shg, shb, shp,                         \
  362.                             maskr, maskg, maskb, rsh, gsh, bsh, S, tab);\
  363. }                                                                       \
  364.                                                                         \
  365. static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV,           \
  366.                                 const uint8_t *unused0, const uint8_t *src,                     \
  367.                                 const uint8_t *dummy,                   \
  368.                                 int width, uint32_t *tab)               \
  369. {                                                                       \
  370.     rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt,           \
  371.                                  shr, shg, shb, shp,                    \
  372.                                  maskr, maskg, maskb,                   \
  373.                                  rsh, gsh, bsh, S, tab);                \
  374. }
  375.  
  376. rgb16_32_wrapper(AV_PIX_FMT_BGR32,    bgr32,  16, 0,  0, 0, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
  377. rgb16_32_wrapper(AV_PIX_FMT_BGR32_1,  bgr321, 16, 0,  0, 8, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
  378. rgb16_32_wrapper(AV_PIX_FMT_RGB32,    rgb32,   0, 0, 16, 0,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
  379. rgb16_32_wrapper(AV_PIX_FMT_RGB32_1,  rgb321,  0, 0, 16, 8,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
  380. rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
  381. rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
  382. rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
  383. rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
  384. rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
  385. rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
  386. rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
  387. rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
  388. rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
  389. rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
  390. rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
  391. rgb16_32_wrapper(AV_PIX_FMT_RGB444BE, rgb12be, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
  392.  
  393. static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
  394.                          const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
  395.                          int width, uint32_t *rgb2yuv)
  396. {
  397.     uint16_t *dstU = (uint16_t *)_dstU;
  398.     uint16_t *dstV = (uint16_t *)_dstV;
  399.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  400.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  401.  
  402.     int i;
  403.     for (i = 0; i < width; i++) {
  404.         unsigned int g   = gsrc[2*i] + gsrc[2*i+1];
  405.         unsigned int b   = bsrc[2*i] + bsrc[2*i+1];
  406.         unsigned int r   = rsrc[2*i] + rsrc[2*i+1];
  407.  
  408.         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
  409.         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
  410.     }
  411. }
  412.  
  413. static void rgba64ToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
  414.                         const uint8_t *unused2, int width, uint32_t *unused)
  415. {
  416.     int16_t *dst = (int16_t *)_dst;
  417.     const uint16_t *src = (const uint16_t *)_src;
  418.     int i;
  419.     for (i = 0; i < width; i++)
  420.         dst[i] = src[4 * i + 3];
  421. }
  422.  
  423. static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
  424. {
  425.     int16_t *dst = (int16_t *)_dst;
  426.     int i;
  427.     for (i=0; i<width; i++) {
  428.         dst[i]= src[4*i]<<6;
  429.     }
  430. }
  431.  
  432. static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
  433. {
  434.     int16_t *dst = (int16_t *)_dst;
  435.     int i;
  436.     for (i=0; i<width; i++) {
  437.         dst[i]= src[4*i+3]<<6;
  438.     }
  439. }
  440.  
  441. static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
  442. {
  443.     int16_t *dst = (int16_t *)_dst;
  444.     int i;
  445.     for (i=0; i<width; i++) {
  446.         int d= src[i];
  447.  
  448.         dst[i]= (pal[d] >> 24)<<6;
  449.     }
  450. }
  451.  
  452. static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
  453. {
  454.     int16_t *dst = (int16_t *)_dst;
  455.     int i;
  456.     for (i = 0; i < width; i++) {
  457.         int d = src[i];
  458.  
  459.         dst[i] = (pal[d] & 0xFF)<<6;
  460.     }
  461. }
  462.  
  463. static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
  464.                            const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
  465.                       int width, uint32_t *pal)
  466. {
  467.     uint16_t *dstU = (uint16_t *)_dstU;
  468.     int16_t *dstV = (int16_t *)_dstV;
  469.     int i;
  470.     av_assert1(src1 == src2);
  471.     for (i = 0; i < width; i++) {
  472.         int p = pal[src1[i]];
  473.  
  474.         dstU[i] = (uint8_t)(p>> 8)<<6;
  475.         dstV[i] = (uint8_t)(p>>16)<<6;
  476.     }
  477. }
  478.  
  479. static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
  480. {
  481.     int16_t *dst = (int16_t *)_dst;
  482.     int i, j;
  483.     width = (width + 7) >> 3;
  484.     for (i = 0; i < width; i++) {
  485.         int d = ~src[i];
  486.         for (j = 0; j < 8; j++)
  487.             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
  488.     }
  489.     if(width&7){
  490.         int d= ~src[i];
  491.         for (j = 0; j < (width&7); j++)
  492.             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
  493.     }
  494. }
  495.  
  496. static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
  497. {
  498.     int16_t *dst = (int16_t *)_dst;
  499.     int i, j;
  500.     width = (width + 7) >> 3;
  501.     for (i = 0; i < width; i++) {
  502.         int d = src[i];
  503.         for (j = 0; j < 8; j++)
  504.             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
  505.     }
  506.     if(width&7){
  507.         int d = src[i];
  508.         for (j = 0; j < (width&7); j++)
  509.             dst[8*i+j] = ((d>>(7-j))&1) * 16383;
  510.     }
  511. }
  512.  
  513. static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
  514.                       uint32_t *unused)
  515. {
  516.     int i;
  517.     for (i = 0; i < width; i++)
  518.         dst[i] = src[2 * i];
  519. }
  520.  
  521. static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
  522.                        const uint8_t *src2, int width, uint32_t *unused)
  523. {
  524.     int i;
  525.     for (i = 0; i < width; i++) {
  526.         dstU[i] = src1[4 * i + 1];
  527.         dstV[i] = src1[4 * i + 3];
  528.     }
  529.     av_assert1(src1 == src2);
  530. }
  531.  
  532. static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2,  int width,
  533.                        uint32_t *unused)
  534. {
  535.     int i;
  536.     const uint16_t *src = (const uint16_t *)_src;
  537.     uint16_t *dst       = (uint16_t *)_dst;
  538.     for (i = 0; i < width; i++)
  539.         dst[i] = av_bswap16(src[i]);
  540. }
  541.  
  542. static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
  543.                         const uint8_t *_src2, int width, uint32_t *unused)
  544. {
  545.     int i;
  546.     const uint16_t *src1 = (const uint16_t *)_src1,
  547.     *src2                = (const uint16_t *)_src2;
  548.     uint16_t *dstU       = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
  549.     for (i = 0; i < width; i++) {
  550.         dstU[i] = av_bswap16(src1[i]);
  551.         dstV[i] = av_bswap16(src2[i]);
  552.     }
  553. }
  554.  
  555. /* This is almost identical to the previous, end exists only because
  556.  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
  557. static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
  558.                       uint32_t *unused)
  559. {
  560.     int i;
  561.     for (i = 0; i < width; i++)
  562.         dst[i] = src[2 * i + 1];
  563. }
  564.  
  565. static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
  566.                        const uint8_t *src2, int width, uint32_t *unused)
  567. {
  568.     int i;
  569.     for (i = 0; i < width; i++) {
  570.         dstU[i] = src1[4 * i + 0];
  571.         dstV[i] = src1[4 * i + 2];
  572.     }
  573.     av_assert1(src1 == src2);
  574. }
  575.  
  576. static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
  577.                                         const uint8_t *src, int width)
  578. {
  579.     int i;
  580.     for (i = 0; i < width; i++) {
  581.         dst1[i] = src[2 * i + 0];
  582.         dst2[i] = src[2 * i + 1];
  583.     }
  584. }
  585.  
  586. static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
  587.                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
  588.                        int width, uint32_t *unused)
  589. {
  590.     nvXXtoUV_c(dstU, dstV, src1, width);
  591. }
  592.  
  593. static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
  594.                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
  595.                        int width, uint32_t *unused)
  596. {
  597.     nvXXtoUV_c(dstV, dstU, src1, width);
  598. }
  599.  
  600. #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
  601.  
  602. static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
  603.                        int width, uint32_t *rgb2yuv)
  604. {
  605.     int16_t *dst = (int16_t *)_dst;
  606.     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
  607.     int i;
  608.     for (i = 0; i < width; i++) {
  609.         int b = src[i * 3 + 0];
  610.         int g = src[i * 3 + 1];
  611.         int r = src[i * 3 + 2];
  612.  
  613.         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
  614.     }
  615. }
  616.  
  617. static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
  618.                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
  619. {
  620.     int16_t *dstU = (int16_t *)_dstU;
  621.     int16_t *dstV = (int16_t *)_dstV;
  622.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  623.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  624.     int i;
  625.     for (i = 0; i < width; i++) {
  626.         int b = src1[3 * i + 0];
  627.         int g = src1[3 * i + 1];
  628.         int r = src1[3 * i + 2];
  629.  
  630.         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
  631.         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
  632.     }
  633.     av_assert1(src1 == src2);
  634. }
  635.  
  636. static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
  637.                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
  638. {
  639.     int16_t *dstU = (int16_t *)_dstU;
  640.     int16_t *dstV = (int16_t *)_dstV;
  641.     int i;
  642.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  643.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  644.     for (i = 0; i < width; i++) {
  645.         int b = src1[6 * i + 0] + src1[6 * i + 3];
  646.         int g = src1[6 * i + 1] + src1[6 * i + 4];
  647.         int r = src1[6 * i + 2] + src1[6 * i + 5];
  648.  
  649.         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
  650.         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
  651.     }
  652.     av_assert1(src1 == src2);
  653. }
  654.  
  655. static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
  656.                        uint32_t *rgb2yuv)
  657. {
  658.     int16_t *dst = (int16_t *)_dst;
  659.     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
  660.     int i;
  661.     for (i = 0; i < width; i++) {
  662.         int r = src[i * 3 + 0];
  663.         int g = src[i * 3 + 1];
  664.         int b = src[i * 3 + 2];
  665.  
  666.         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
  667.     }
  668. }
  669.  
  670. static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
  671.                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
  672. {
  673.     int16_t *dstU = (int16_t *)_dstU;
  674.     int16_t *dstV = (int16_t *)_dstV;
  675.     int i;
  676.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  677.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  678.     av_assert1(src1 == src2);
  679.     for (i = 0; i < width; i++) {
  680.         int r = src1[3 * i + 0];
  681.         int g = src1[3 * i + 1];
  682.         int b = src1[3 * i + 2];
  683.  
  684.         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
  685.         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
  686.     }
  687. }
  688.  
  689. static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
  690.                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
  691. {
  692.     int16_t *dstU = (int16_t *)_dstU;
  693.     int16_t *dstV = (int16_t *)_dstV;
  694.     int i;
  695.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  696.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  697.     av_assert1(src1 == src2);
  698.     for (i = 0; i < width; i++) {
  699.         int r = src1[6 * i + 0] + src1[6 * i + 3];
  700.         int g = src1[6 * i + 1] + src1[6 * i + 4];
  701.         int b = src1[6 * i + 2] + src1[6 * i + 5];
  702.  
  703.         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
  704.         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
  705.     }
  706. }
  707.  
  708. static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
  709. {
  710.     uint16_t *dst = (uint16_t *)_dst;
  711.     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
  712.     int i;
  713.     for (i = 0; i < width; i++) {
  714.         int g = src[0][i];
  715.         int b = src[1][i];
  716.         int r = src[2][i];
  717.  
  718.         dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
  719.     }
  720. }
  721.  
  722. static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
  723. {
  724.     uint16_t *dst = (uint16_t *)_dst;
  725.     int i;
  726.     for (i = 0; i < width; i++)
  727.         dst[i] = src[3][i] << 6;
  728. }
  729.  
  730. static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
  731. {
  732.     uint16_t *dstU = (uint16_t *)_dstU;
  733.     uint16_t *dstV = (uint16_t *)_dstV;
  734.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  735.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  736.     int i;
  737.     for (i = 0; i < width; i++) {
  738.         int g = src[0][i];
  739.         int b = src[1][i];
  740.         int r = src[2][i];
  741.  
  742.         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
  743.         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
  744.     }
  745. }
  746.  
  747. #define rdpx(src) \
  748.     is_be ? AV_RB16(src) : AV_RL16(src)
  749. static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
  750.                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
  751. {
  752.     int i;
  753.     const uint16_t **src = (const uint16_t **)_src;
  754.     uint16_t *dst        = (uint16_t *)_dst;
  755.     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
  756.     int shift = bpc < 16 ? bpc : 14;
  757.     for (i = 0; i < width; i++) {
  758.         int g = rdpx(src[0] + i);
  759.         int b = rdpx(src[1] + i);
  760.         int r = rdpx(src[2] + i);
  761.  
  762.         dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
  763.     }
  764. }
  765.  
  766. static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
  767.                                                 const uint8_t *_src[4], int width,
  768.                                                 int bpc, int is_be, int32_t *rgb2yuv)
  769. {
  770.     int i;
  771.     const uint16_t **src = (const uint16_t **)_src;
  772.     uint16_t *dstU       = (uint16_t *)_dstU;
  773.     uint16_t *dstV       = (uint16_t *)_dstV;
  774.     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
  775.     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
  776.     int shift = bpc < 16 ? bpc : 14;
  777.     for (i = 0; i < width; i++) {
  778.         int g = rdpx(src[0] + i);
  779.         int b = rdpx(src[1] + i);
  780.         int r = rdpx(src[2] + i);
  781.  
  782.         dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
  783.         dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
  784.     }
  785. }
  786. #undef rdpx
  787.  
  788. #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian)                                    \
  789. static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4],              \
  790.                                                   int w, int32_t *rgb2yuv)                          \
  791. {                                                                                                   \
  792.     planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
  793. }                                                                                                   \
  794. static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
  795.                                                    const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
  796. {                                                                                                   \
  797.     planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
  798. }                                                                                                   \
  799.  
  800. #define rgb9plus_planar_funcs(nbits)            \
  801.     rgb9plus_planar_funcs_endian(nbits, le, 0)  \
  802.     rgb9plus_planar_funcs_endian(nbits, be, 1)
  803.  
  804. rgb9plus_planar_funcs(9)
  805. rgb9plus_planar_funcs(10)
  806. rgb9plus_planar_funcs(12)
  807. rgb9plus_planar_funcs(14)
  808. rgb9plus_planar_funcs(16)
  809.  
  810. av_cold void ff_sws_init_input_funcs(SwsContext *c)
  811. {
  812.     enum AVPixelFormat srcFormat = c->srcFormat;
  813.  
  814.     c->chrToYV12 = NULL;
  815.     switch (srcFormat) {
  816.     case AV_PIX_FMT_YUYV422:
  817.         c->chrToYV12 = yuy2ToUV_c;
  818.         break;
  819.     case AV_PIX_FMT_UYVY422:
  820.         c->chrToYV12 = uyvyToUV_c;
  821.         break;
  822.     case AV_PIX_FMT_NV12:
  823.         c->chrToYV12 = nv12ToUV_c;
  824.         break;
  825.     case AV_PIX_FMT_NV21:
  826.         c->chrToYV12 = nv21ToUV_c;
  827.         break;
  828.     case AV_PIX_FMT_RGB8:
  829.     case AV_PIX_FMT_BGR8:
  830.     case AV_PIX_FMT_PAL8:
  831.     case AV_PIX_FMT_BGR4_BYTE:
  832.     case AV_PIX_FMT_RGB4_BYTE:
  833.         c->chrToYV12 = palToUV_c;
  834.         break;
  835.     case AV_PIX_FMT_GBRP9LE:
  836.         c->readChrPlanar = planar_rgb9le_to_uv;
  837.         break;
  838.     case AV_PIX_FMT_GBRP10LE:
  839.         c->readChrPlanar = planar_rgb10le_to_uv;
  840.         break;
  841.     case AV_PIX_FMT_GBRP12LE:
  842.         c->readChrPlanar = planar_rgb12le_to_uv;
  843.         break;
  844.     case AV_PIX_FMT_GBRP14LE:
  845.         c->readChrPlanar = planar_rgb14le_to_uv;
  846.         break;
  847.     case AV_PIX_FMT_GBRAP16LE:
  848.     case AV_PIX_FMT_GBRP16LE:
  849.         c->readChrPlanar = planar_rgb16le_to_uv;
  850.         break;
  851.     case AV_PIX_FMT_GBRP9BE:
  852.         c->readChrPlanar = planar_rgb9be_to_uv;
  853.         break;
  854.     case AV_PIX_FMT_GBRP10BE:
  855.         c->readChrPlanar = planar_rgb10be_to_uv;
  856.         break;
  857.     case AV_PIX_FMT_GBRP12BE:
  858.         c->readChrPlanar = planar_rgb12be_to_uv;
  859.         break;
  860.     case AV_PIX_FMT_GBRP14BE:
  861.         c->readChrPlanar = planar_rgb14be_to_uv;
  862.         break;
  863.     case AV_PIX_FMT_GBRAP16BE:
  864.     case AV_PIX_FMT_GBRP16BE:
  865.         c->readChrPlanar = planar_rgb16be_to_uv;
  866.         break;
  867.     case AV_PIX_FMT_GBRAP:
  868.     case AV_PIX_FMT_GBRP:
  869.         c->readChrPlanar = planar_rgb_to_uv;
  870.         break;
  871. #if HAVE_BIGENDIAN
  872.     case AV_PIX_FMT_YUV444P9LE:
  873.     case AV_PIX_FMT_YUV422P9LE:
  874.     case AV_PIX_FMT_YUV420P9LE:
  875.     case AV_PIX_FMT_YUV422P10LE:
  876.     case AV_PIX_FMT_YUV444P10LE:
  877.     case AV_PIX_FMT_YUV420P10LE:
  878.     case AV_PIX_FMT_YUV422P12LE:
  879.     case AV_PIX_FMT_YUV444P12LE:
  880.     case AV_PIX_FMT_YUV420P12LE:
  881.     case AV_PIX_FMT_YUV422P14LE:
  882.     case AV_PIX_FMT_YUV444P14LE:
  883.     case AV_PIX_FMT_YUV420P14LE:
  884.     case AV_PIX_FMT_YUV420P16LE:
  885.     case AV_PIX_FMT_YUV422P16LE:
  886.     case AV_PIX_FMT_YUV444P16LE:
  887.  
  888.     case AV_PIX_FMT_YUVA444P9LE:
  889.     case AV_PIX_FMT_YUVA422P9LE:
  890.     case AV_PIX_FMT_YUVA420P9LE:
  891.     case AV_PIX_FMT_YUVA444P10LE:
  892.     case AV_PIX_FMT_YUVA422P10LE:
  893.     case AV_PIX_FMT_YUVA420P10LE:
  894.     case AV_PIX_FMT_YUVA420P16LE:
  895.     case AV_PIX_FMT_YUVA422P16LE:
  896.     case AV_PIX_FMT_YUVA444P16LE:
  897.         c->chrToYV12 = bswap16UV_c;
  898.         break;
  899. #else
  900.     case AV_PIX_FMT_YUV444P9BE:
  901.     case AV_PIX_FMT_YUV422P9BE:
  902.     case AV_PIX_FMT_YUV420P9BE:
  903.     case AV_PIX_FMT_YUV444P10BE:
  904.     case AV_PIX_FMT_YUV422P10BE:
  905.     case AV_PIX_FMT_YUV420P10BE:
  906.     case AV_PIX_FMT_YUV444P12BE:
  907.     case AV_PIX_FMT_YUV422P12BE:
  908.     case AV_PIX_FMT_YUV420P12BE:
  909.     case AV_PIX_FMT_YUV444P14BE:
  910.     case AV_PIX_FMT_YUV422P14BE:
  911.     case AV_PIX_FMT_YUV420P14BE:
  912.     case AV_PIX_FMT_YUV420P16BE:
  913.     case AV_PIX_FMT_YUV422P16BE:
  914.     case AV_PIX_FMT_YUV444P16BE:
  915.  
  916.     case AV_PIX_FMT_YUVA444P9BE:
  917.     case AV_PIX_FMT_YUVA422P9BE:
  918.     case AV_PIX_FMT_YUVA420P9BE:
  919.     case AV_PIX_FMT_YUVA444P10BE:
  920.     case AV_PIX_FMT_YUVA422P10BE:
  921.     case AV_PIX_FMT_YUVA420P10BE:
  922.     case AV_PIX_FMT_YUVA420P16BE:
  923.     case AV_PIX_FMT_YUVA422P16BE:
  924.     case AV_PIX_FMT_YUVA444P16BE:
  925.         c->chrToYV12 = bswap16UV_c;
  926.         break;
  927. #endif
  928.     }
  929.     if (c->chrSrcHSubSample) {
  930.         switch (srcFormat) {
  931.         case AV_PIX_FMT_RGBA64BE:
  932.             c->chrToYV12 = rgb64BEToUV_half_c;
  933.             break;
  934.         case AV_PIX_FMT_RGBA64LE:
  935.             c->chrToYV12 = rgb64LEToUV_half_c;
  936.             break;
  937.         case AV_PIX_FMT_RGB48BE:
  938.             c->chrToYV12 = rgb48BEToUV_half_c;
  939.             break;
  940.         case AV_PIX_FMT_RGB48LE:
  941.             c->chrToYV12 = rgb48LEToUV_half_c;
  942.             break;
  943.         case AV_PIX_FMT_BGR48BE:
  944.             c->chrToYV12 = bgr48BEToUV_half_c;
  945.             break;
  946.         case AV_PIX_FMT_BGR48LE:
  947.             c->chrToYV12 = bgr48LEToUV_half_c;
  948.             break;
  949.         case AV_PIX_FMT_RGB32:
  950.             c->chrToYV12 = bgr32ToUV_half_c;
  951.             break;
  952.         case AV_PIX_FMT_RGB32_1:
  953.             c->chrToYV12 = bgr321ToUV_half_c;
  954.             break;
  955.         case AV_PIX_FMT_BGR24:
  956.             c->chrToYV12 = bgr24ToUV_half_c;
  957.             break;
  958.         case AV_PIX_FMT_BGR565LE:
  959.             c->chrToYV12 = bgr16leToUV_half_c;
  960.             break;
  961.         case AV_PIX_FMT_BGR565BE:
  962.             c->chrToYV12 = bgr16beToUV_half_c;
  963.             break;
  964.         case AV_PIX_FMT_BGR555LE:
  965.             c->chrToYV12 = bgr15leToUV_half_c;
  966.             break;
  967.         case AV_PIX_FMT_BGR555BE:
  968.             c->chrToYV12 = bgr15beToUV_half_c;
  969.             break;
  970.         case AV_PIX_FMT_GBRAP:
  971.         case AV_PIX_FMT_GBRP:
  972.             c->chrToYV12 = gbr24pToUV_half_c;
  973.             break;
  974.         case AV_PIX_FMT_BGR444LE:
  975.             c->chrToYV12 = bgr12leToUV_half_c;
  976.             break;
  977.         case AV_PIX_FMT_BGR444BE:
  978.             c->chrToYV12 = bgr12beToUV_half_c;
  979.             break;
  980.         case AV_PIX_FMT_BGR32:
  981.             c->chrToYV12 = rgb32ToUV_half_c;
  982.             break;
  983.         case AV_PIX_FMT_BGR32_1:
  984.             c->chrToYV12 = rgb321ToUV_half_c;
  985.             break;
  986.         case AV_PIX_FMT_RGB24:
  987.             c->chrToYV12 = rgb24ToUV_half_c;
  988.             break;
  989.         case AV_PIX_FMT_RGB565LE:
  990.             c->chrToYV12 = rgb16leToUV_half_c;
  991.             break;
  992.         case AV_PIX_FMT_RGB565BE:
  993.             c->chrToYV12 = rgb16beToUV_half_c;
  994.             break;
  995.         case AV_PIX_FMT_RGB555LE:
  996.             c->chrToYV12 = rgb15leToUV_half_c;
  997.             break;
  998.         case AV_PIX_FMT_RGB555BE:
  999.             c->chrToYV12 = rgb15beToUV_half_c;
  1000.             break;
  1001.         case AV_PIX_FMT_RGB444LE:
  1002.             c->chrToYV12 = rgb12leToUV_half_c;
  1003.             break;
  1004.         case AV_PIX_FMT_RGB444BE:
  1005.             c->chrToYV12 = rgb12beToUV_half_c;
  1006.             break;
  1007.         }
  1008.     } else {
  1009.         switch (srcFormat) {
  1010.         case AV_PIX_FMT_RGBA64BE:
  1011.             c->chrToYV12 = rgb64BEToUV_c;
  1012.             break;
  1013.         case AV_PIX_FMT_RGBA64LE:
  1014.             c->chrToYV12 = rgb64LEToUV_c;
  1015.             break;
  1016.         case AV_PIX_FMT_RGB48BE:
  1017.             c->chrToYV12 = rgb48BEToUV_c;
  1018.             break;
  1019.         case AV_PIX_FMT_RGB48LE:
  1020.             c->chrToYV12 = rgb48LEToUV_c;
  1021.             break;
  1022.         case AV_PIX_FMT_BGR48BE:
  1023.             c->chrToYV12 = bgr48BEToUV_c;
  1024.             break;
  1025.         case AV_PIX_FMT_BGR48LE:
  1026.             c->chrToYV12 = bgr48LEToUV_c;
  1027.             break;
  1028.         case AV_PIX_FMT_RGB32:
  1029.             c->chrToYV12 = bgr32ToUV_c;
  1030.             break;
  1031.         case AV_PIX_FMT_RGB32_1:
  1032.             c->chrToYV12 = bgr321ToUV_c;
  1033.             break;
  1034.         case AV_PIX_FMT_BGR24:
  1035.             c->chrToYV12 = bgr24ToUV_c;
  1036.             break;
  1037.         case AV_PIX_FMT_BGR565LE:
  1038.             c->chrToYV12 = bgr16leToUV_c;
  1039.             break;
  1040.         case AV_PIX_FMT_BGR565BE:
  1041.             c->chrToYV12 = bgr16beToUV_c;
  1042.             break;
  1043.         case AV_PIX_FMT_BGR555LE:
  1044.             c->chrToYV12 = bgr15leToUV_c;
  1045.             break;
  1046.         case AV_PIX_FMT_BGR555BE:
  1047.             c->chrToYV12 = bgr15beToUV_c;
  1048.             break;
  1049.         case AV_PIX_FMT_BGR444LE:
  1050.             c->chrToYV12 = bgr12leToUV_c;
  1051.             break;
  1052.         case AV_PIX_FMT_BGR444BE:
  1053.             c->chrToYV12 = bgr12beToUV_c;
  1054.             break;
  1055.         case AV_PIX_FMT_BGR32:
  1056.             c->chrToYV12 = rgb32ToUV_c;
  1057.             break;
  1058.         case AV_PIX_FMT_BGR32_1:
  1059.             c->chrToYV12 = rgb321ToUV_c;
  1060.             break;
  1061.         case AV_PIX_FMT_RGB24:
  1062.             c->chrToYV12 = rgb24ToUV_c;
  1063.             break;
  1064.         case AV_PIX_FMT_RGB565LE:
  1065.             c->chrToYV12 = rgb16leToUV_c;
  1066.             break;
  1067.         case AV_PIX_FMT_RGB565BE:
  1068.             c->chrToYV12 = rgb16beToUV_c;
  1069.             break;
  1070.         case AV_PIX_FMT_RGB555LE:
  1071.             c->chrToYV12 = rgb15leToUV_c;
  1072.             break;
  1073.         case AV_PIX_FMT_RGB555BE:
  1074.             c->chrToYV12 = rgb15beToUV_c;
  1075.             break;
  1076.         case AV_PIX_FMT_RGB444LE:
  1077.             c->chrToYV12 = rgb12leToUV_c;
  1078.             break;
  1079.         case AV_PIX_FMT_RGB444BE:
  1080.             c->chrToYV12 = rgb12beToUV_c;
  1081.             break;
  1082.         }
  1083.     }
  1084.  
  1085.     c->lumToYV12 = NULL;
  1086.     c->alpToYV12 = NULL;
  1087.     switch (srcFormat) {
  1088.     case AV_PIX_FMT_GBRP9LE:
  1089.         c->readLumPlanar = planar_rgb9le_to_y;
  1090.         break;
  1091.     case AV_PIX_FMT_GBRP10LE:
  1092.         c->readLumPlanar = planar_rgb10le_to_y;
  1093.         break;
  1094.     case AV_PIX_FMT_GBRP12LE:
  1095.         c->readLumPlanar = planar_rgb12le_to_y;
  1096.         break;
  1097.     case AV_PIX_FMT_GBRP14LE:
  1098.         c->readLumPlanar = planar_rgb14le_to_y;
  1099.         break;
  1100.     case AV_PIX_FMT_GBRAP16LE:
  1101.     case AV_PIX_FMT_GBRP16LE:
  1102.         c->readLumPlanar = planar_rgb16le_to_y;
  1103.         break;
  1104.     case AV_PIX_FMT_GBRP9BE:
  1105.         c->readLumPlanar = planar_rgb9be_to_y;
  1106.         break;
  1107.     case AV_PIX_FMT_GBRP10BE:
  1108.         c->readLumPlanar = planar_rgb10be_to_y;
  1109.         break;
  1110.     case AV_PIX_FMT_GBRP12BE:
  1111.         c->readLumPlanar = planar_rgb12be_to_y;
  1112.         break;
  1113.     case AV_PIX_FMT_GBRP14BE:
  1114.         c->readLumPlanar = planar_rgb14be_to_y;
  1115.         break;
  1116.     case AV_PIX_FMT_GBRAP16BE:
  1117.     case AV_PIX_FMT_GBRP16BE:
  1118.         c->readLumPlanar = planar_rgb16be_to_y;
  1119.         break;
  1120.     case AV_PIX_FMT_GBRAP:
  1121.         c->readAlpPlanar = planar_rgb_to_a;
  1122.     case AV_PIX_FMT_GBRP:
  1123.         c->readLumPlanar = planar_rgb_to_y;
  1124.         break;
  1125. #if HAVE_BIGENDIAN
  1126.     case AV_PIX_FMT_YUV444P9LE:
  1127.     case AV_PIX_FMT_YUV422P9LE:
  1128.     case AV_PIX_FMT_YUV420P9LE:
  1129.     case AV_PIX_FMT_YUV444P10LE:
  1130.     case AV_PIX_FMT_YUV422P10LE:
  1131.     case AV_PIX_FMT_YUV420P10LE:
  1132.     case AV_PIX_FMT_YUV444P12LE:
  1133.     case AV_PIX_FMT_YUV422P12LE:
  1134.     case AV_PIX_FMT_YUV420P12LE:
  1135.     case AV_PIX_FMT_YUV444P14LE:
  1136.     case AV_PIX_FMT_YUV422P14LE:
  1137.     case AV_PIX_FMT_YUV420P14LE:
  1138.     case AV_PIX_FMT_YUV420P16LE:
  1139.     case AV_PIX_FMT_YUV422P16LE:
  1140.     case AV_PIX_FMT_YUV444P16LE:
  1141.  
  1142.     case AV_PIX_FMT_GRAY16LE:
  1143.         c->lumToYV12 = bswap16Y_c;
  1144.         break;
  1145.     case AV_PIX_FMT_YUVA444P9LE:
  1146.     case AV_PIX_FMT_YUVA422P9LE:
  1147.     case AV_PIX_FMT_YUVA420P9LE:
  1148.     case AV_PIX_FMT_YUVA444P10LE:
  1149.     case AV_PIX_FMT_YUVA422P10LE:
  1150.     case AV_PIX_FMT_YUVA420P10LE:
  1151.     case AV_PIX_FMT_YUVA420P16LE:
  1152.     case AV_PIX_FMT_YUVA422P16LE:
  1153.     case AV_PIX_FMT_YUVA444P16LE:
  1154.         c->lumToYV12 = bswap16Y_c;
  1155.         c->alpToYV12 = bswap16Y_c;
  1156.         break;
  1157. #else
  1158.     case AV_PIX_FMT_YUV444P9BE:
  1159.     case AV_PIX_FMT_YUV422P9BE:
  1160.     case AV_PIX_FMT_YUV420P9BE:
  1161.     case AV_PIX_FMT_YUV444P10BE:
  1162.     case AV_PIX_FMT_YUV422P10BE:
  1163.     case AV_PIX_FMT_YUV420P10BE:
  1164.     case AV_PIX_FMT_YUV444P12BE:
  1165.     case AV_PIX_FMT_YUV422P12BE:
  1166.     case AV_PIX_FMT_YUV420P12BE:
  1167.     case AV_PIX_FMT_YUV444P14BE:
  1168.     case AV_PIX_FMT_YUV422P14BE:
  1169.     case AV_PIX_FMT_YUV420P14BE:
  1170.     case AV_PIX_FMT_YUV420P16BE:
  1171.     case AV_PIX_FMT_YUV422P16BE:
  1172.     case AV_PIX_FMT_YUV444P16BE:
  1173.  
  1174.     case AV_PIX_FMT_GRAY16BE:
  1175.         c->lumToYV12 = bswap16Y_c;
  1176.         break;
  1177.     case AV_PIX_FMT_YUVA444P9BE:
  1178.     case AV_PIX_FMT_YUVA422P9BE:
  1179.     case AV_PIX_FMT_YUVA420P9BE:
  1180.     case AV_PIX_FMT_YUVA444P10BE:
  1181.     case AV_PIX_FMT_YUVA422P10BE:
  1182.     case AV_PIX_FMT_YUVA420P10BE:
  1183.     case AV_PIX_FMT_YUVA420P16BE:
  1184.     case AV_PIX_FMT_YUVA422P16BE:
  1185.     case AV_PIX_FMT_YUVA444P16BE:
  1186.         c->lumToYV12 = bswap16Y_c;
  1187.         c->alpToYV12 = bswap16Y_c;
  1188.         break;
  1189. #endif
  1190.     case AV_PIX_FMT_YUYV422:
  1191.     case AV_PIX_FMT_Y400A:
  1192.         c->lumToYV12 = yuy2ToY_c;
  1193.         break;
  1194.     case AV_PIX_FMT_UYVY422:
  1195.         c->lumToYV12 = uyvyToY_c;
  1196.         break;
  1197.     case AV_PIX_FMT_BGR24:
  1198.         c->lumToYV12 = bgr24ToY_c;
  1199.         break;
  1200.     case AV_PIX_FMT_BGR565LE:
  1201.         c->lumToYV12 = bgr16leToY_c;
  1202.         break;
  1203.     case AV_PIX_FMT_BGR565BE:
  1204.         c->lumToYV12 = bgr16beToY_c;
  1205.         break;
  1206.     case AV_PIX_FMT_BGR555LE:
  1207.         c->lumToYV12 = bgr15leToY_c;
  1208.         break;
  1209.     case AV_PIX_FMT_BGR555BE:
  1210.         c->lumToYV12 = bgr15beToY_c;
  1211.         break;
  1212.     case AV_PIX_FMT_BGR444LE:
  1213.         c->lumToYV12 = bgr12leToY_c;
  1214.         break;
  1215.     case AV_PIX_FMT_BGR444BE:
  1216.         c->lumToYV12 = bgr12beToY_c;
  1217.         break;
  1218.     case AV_PIX_FMT_RGB24:
  1219.         c->lumToYV12 = rgb24ToY_c;
  1220.         break;
  1221.     case AV_PIX_FMT_RGB565LE:
  1222.         c->lumToYV12 = rgb16leToY_c;
  1223.         break;
  1224.     case AV_PIX_FMT_RGB565BE:
  1225.         c->lumToYV12 = rgb16beToY_c;
  1226.         break;
  1227.     case AV_PIX_FMT_RGB555LE:
  1228.         c->lumToYV12 = rgb15leToY_c;
  1229.         break;
  1230.     case AV_PIX_FMT_RGB555BE:
  1231.         c->lumToYV12 = rgb15beToY_c;
  1232.         break;
  1233.     case AV_PIX_FMT_RGB444LE:
  1234.         c->lumToYV12 = rgb12leToY_c;
  1235.         break;
  1236.     case AV_PIX_FMT_RGB444BE:
  1237.         c->lumToYV12 = rgb12beToY_c;
  1238.         break;
  1239.     case AV_PIX_FMT_RGB8:
  1240.     case AV_PIX_FMT_BGR8:
  1241.     case AV_PIX_FMT_PAL8:
  1242.     case AV_PIX_FMT_BGR4_BYTE:
  1243.     case AV_PIX_FMT_RGB4_BYTE:
  1244.         c->lumToYV12 = palToY_c;
  1245.         break;
  1246.     case AV_PIX_FMT_MONOBLACK:
  1247.         c->lumToYV12 = monoblack2Y_c;
  1248.         break;
  1249.     case AV_PIX_FMT_MONOWHITE:
  1250.         c->lumToYV12 = monowhite2Y_c;
  1251.         break;
  1252.     case AV_PIX_FMT_RGB32:
  1253.         c->lumToYV12 = bgr32ToY_c;
  1254.         break;
  1255.     case AV_PIX_FMT_RGB32_1:
  1256.         c->lumToYV12 = bgr321ToY_c;
  1257.         break;
  1258.     case AV_PIX_FMT_BGR32:
  1259.         c->lumToYV12 = rgb32ToY_c;
  1260.         break;
  1261.     case AV_PIX_FMT_BGR32_1:
  1262.         c->lumToYV12 = rgb321ToY_c;
  1263.         break;
  1264.     case AV_PIX_FMT_RGB48BE:
  1265.         c->lumToYV12 = rgb48BEToY_c;
  1266.         break;
  1267.     case AV_PIX_FMT_RGB48LE:
  1268.         c->lumToYV12 = rgb48LEToY_c;
  1269.         break;
  1270.     case AV_PIX_FMT_BGR48BE:
  1271.         c->lumToYV12 = bgr48BEToY_c;
  1272.         break;
  1273.     case AV_PIX_FMT_BGR48LE:
  1274.         c->lumToYV12 = bgr48LEToY_c;
  1275.         break;
  1276.     case AV_PIX_FMT_RGBA64BE:
  1277.         c->lumToYV12 = rgb64BEToY_c;
  1278.         break;
  1279.     case AV_PIX_FMT_RGBA64LE:
  1280.         c->lumToYV12 = rgb64LEToY_c;
  1281.         break;
  1282.     }
  1283.     if (c->alpPixBuf) {
  1284.         if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
  1285.             if (HAVE_BIGENDIAN == !isBE(srcFormat))
  1286.                 c->alpToYV12 = bswap16Y_c;
  1287.         }
  1288.         switch (srcFormat) {
  1289.         case AV_PIX_FMT_RGBA64LE:
  1290.         case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64ToA_c; break;
  1291.         case AV_PIX_FMT_BGRA:
  1292.         case AV_PIX_FMT_RGBA:
  1293.             c->alpToYV12 = rgbaToA_c;
  1294.             break;
  1295.         case AV_PIX_FMT_ABGR:
  1296.         case AV_PIX_FMT_ARGB:
  1297.             c->alpToYV12 = abgrToA_c;
  1298.             break;
  1299.         case AV_PIX_FMT_Y400A:
  1300.             c->alpToYV12 = uyvyToY_c;
  1301.             break;
  1302.         case AV_PIX_FMT_PAL8 :
  1303.             c->alpToYV12 = palToA_c;
  1304.             break;
  1305.         }
  1306.     }
  1307. }
  1308.