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