git.sesse.net Git - ffmpeg/blob - libswscale/input.c

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