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] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
 290               rv       = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << 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] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
 318               rv       = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << 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 | src[4*i]>>2;
 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 | src[4*i+3]>>2;
 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 | pal[d]>>26;
 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 y210le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
 556                         const uint8_t *unused1, int width, uint32_t *unused2)
 557 {
 558     int i;
 559     for (i = 0; i < width; i++) {
 560         AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 2) >> 6);
 561         AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6) >> 6);
 562     }
 563 }
 564
 565 static void y210le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0,
 566                        const uint8_t *unused1, int width, uint32_t *unused2)
 567 {
 568     int i;
 569     for (i = 0; i < width; i++)
 570         AV_WN16(dst + i * 2, AV_RL16(src + i * 4) >> 6);
 571 }
 572
 573 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
 574                        uint32_t *unused)
 575 {
 576     int i;
 577     const uint16_t *src = (const uint16_t *)_src;
 578     uint16_t *dst       = (uint16_t *)_dst;
 579     for (i = 0; i < width; i++)
 580         dst[i] = av_bswap16(src[i]);
 581 }
 582
 583 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
 584                         const uint8_t *_src2, int width, uint32_t *unused)
 585 {
 586     int i;
 587     const uint16_t *src1 = (const uint16_t *)_src1,
 588     *src2                = (const uint16_t *)_src2;
 589     uint16_t *dstU       = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
 590     for (i = 0; i < width; i++) {
 591         dstU[i] = av_bswap16(src1[i]);
 592         dstV[i] = av_bswap16(src2[i]);
 593     }
 594 }
 595
 596 static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
 597                                uint32_t *unused)
 598 {
 599     int i;
 600     for (i = 0; i < width; i++)
 601         AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
 602 }
 603
 604 static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
 605                                 uint32_t *unused)
 606 {
 607     int i;
 608     for (i = 0; i < width; i++)
 609         AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
 610 }
 611
 612 static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
 613                                uint32_t *unused)
 614 {
 615     int i;
 616     for (i = 0; i < width; i++)
 617         AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
 618 }
 619
 620 static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
 621                                 uint32_t *unused)
 622 {
 623     int i;
 624     for (i = 0; i < width; i++)
 625         AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
 626 }
 627
 628 static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
 629                                uint32_t *unused2)
 630 {
 631     int i;
 632     for (i = 0; i < width; i++)
 633         AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2));
 634 }
 635
 636
 637 static void read_ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
 638                                const uint8_t *unused1, int width, uint32_t *unused2)
 639 {
 640     int i;
 641     for (i = 0; i < width; i++) {
 642         AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 4));
 643         AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6));
 644     }
 645 }
 646
 647 static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
 648                                 uint32_t *unused2)
 649 {
 650     int i;
 651     for (i = 0; i < width; i++)
 652         AV_WN16(dst + i * 2, AV_RL16(src + i * 8));
 653 }
 654
 655 /* This is almost identical to the previous, end exists only because
 656  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
 657 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
 658                       uint32_t *unused)
 659 {
 660     int i;
 661     for (i = 0; i < width; i++)
 662         dst[i] = src[2 * i + 1];
 663 }
 664
 665 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
 666                        const uint8_t *src2, int width, uint32_t *unused)
 667 {
 668     int i;
 669     for (i = 0; i < width; i++) {
 670         dstU[i] = src1[4 * i + 0];
 671         dstV[i] = src1[4 * i + 2];
 672     }
 673     av_assert1(src1 == src2);
 674 }
 675
 676 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
 677                                         const uint8_t *src, int width)
 678 {
 679     int i;
 680     for (i = 0; i < width; i++) {
 681         dst1[i] = src[2 * i + 0];
 682         dst2[i] = src[2 * i + 1];
 683     }
 684 }
 685
 686 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
 687                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
 688                        int width, uint32_t *unused)
 689 {
 690     nvXXtoUV_c(dstU, dstV, src1, width);
 691 }
 692
 693 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
 694                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
 695                        int width, uint32_t *unused)
 696 {
 697     nvXXtoUV_c(dstV, dstU, src1, width);
 698 }
 699
 700 static void p010LEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
 701                         const uint8_t *unused2, int width, uint32_t *unused)
 702 {
 703     int i;
 704     for (i = 0; i < width; i++) {
 705         AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> 6);
 706     }
 707 }
 708
 709 static void p010BEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
 710                         const uint8_t *unused2, int width, uint32_t *unused)
 711 {
 712     int i;
 713     for (i = 0; i < width; i++) {
 714         AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> 6);
 715     }
 716 }
 717
 718 static void p010LEToUV_c(uint8_t *dstU, uint8_t *dstV,
 719                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
 720                        int width, uint32_t *unused)
 721 {
 722     int i;
 723     for (i = 0; i < width; i++) {
 724         AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0) >> 6);
 725         AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2) >> 6);
 726     }
 727 }
 728
 729 static void p010BEToUV_c(uint8_t *dstU, uint8_t *dstV,
 730                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
 731                        int width, uint32_t *unused)
 732 {
 733     int i;
 734     for (i = 0; i < width; i++) {
 735         AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0) >> 6);
 736         AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2) >> 6);
 737     }
 738 }
 739
 740 static void p016LEToUV_c(uint8_t *dstU, uint8_t *dstV,
 741                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
 742                        int width, uint32_t *unused)
 743 {
 744     int i;
 745     for (i = 0; i < width; i++) {
 746         AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0));
 747         AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2));
 748     }
 749 }
 750
 751 static void p016BEToUV_c(uint8_t *dstU, uint8_t *dstV,
 752                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
 753                        int width, uint32_t *unused)
 754 {
 755     int i;
 756     for (i = 0; i < width; i++) {
 757         AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0));
 758         AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2));
 759     }
 760 }
 761
 762 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
 763
 764 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
 765                        int width, uint32_t *rgb2yuv)
 766 {
 767     int16_t *dst = (int16_t *)_dst;
 768     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
 769     int i;
 770     for (i = 0; i < width; i++) {
 771         int b = src[i * 3 + 0];
 772         int g = src[i * 3 + 1];
 773         int r = src[i * 3 + 2];
 774
 775         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
 776     }
 777 }
 778
 779 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
 780                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
 781 {
 782     int16_t *dstU = (int16_t *)_dstU;
 783     int16_t *dstV = (int16_t *)_dstV;
 784     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
 785     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
 786     int i;
 787     for (i = 0; i < width; i++) {
 788         int b = src1[3 * i + 0];
 789         int g = src1[3 * i + 1];
 790         int r = src1[3 * i + 2];
 791
 792         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
 793         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
 794     }
 795     av_assert1(src1 == src2);
 796 }
 797
 798 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
 799                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
 800 {
 801     int16_t *dstU = (int16_t *)_dstU;
 802     int16_t *dstV = (int16_t *)_dstV;
 803     int i;
 804     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
 805     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
 806     for (i = 0; i < width; i++) {
 807         int b = src1[6 * i + 0] + src1[6 * i + 3];
 808         int g = src1[6 * i + 1] + src1[6 * i + 4];
 809         int r = src1[6 * i + 2] + src1[6 * i + 5];
 810
 811         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
 812         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
 813     }
 814     av_assert1(src1 == src2);
 815 }
 816
 817 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
 818                        uint32_t *rgb2yuv)
 819 {
 820     int16_t *dst = (int16_t *)_dst;
 821     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
 822     int i;
 823     for (i = 0; i < width; i++) {
 824         int r = src[i * 3 + 0];
 825         int g = src[i * 3 + 1];
 826         int b = src[i * 3 + 2];
 827
 828         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
 829     }
 830 }
 831
 832 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
 833                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
 834 {
 835     int16_t *dstU = (int16_t *)_dstU;
 836     int16_t *dstV = (int16_t *)_dstV;
 837     int i;
 838     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
 839     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
 840     av_assert1(src1 == src2);
 841     for (i = 0; i < width; i++) {
 842         int r = src1[3 * i + 0];
 843         int g = src1[3 * i + 1];
 844         int b = src1[3 * i + 2];
 845
 846         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
 847         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
 848     }
 849 }
 850
 851 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
 852                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
 853 {
 854     int16_t *dstU = (int16_t *)_dstU;
 855     int16_t *dstV = (int16_t *)_dstV;
 856     int i;
 857     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
 858     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
 859     av_assert1(src1 == src2);
 860     for (i = 0; i < width; i++) {
 861         int r = src1[6 * i + 0] + src1[6 * i + 3];
 862         int g = src1[6 * i + 1] + src1[6 * i + 4];
 863         int b = src1[6 * i + 2] + src1[6 * i + 5];
 864
 865         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
 866         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
 867     }
 868 }
 869
 870 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
 871 {
 872     uint16_t *dst = (uint16_t *)_dst;
 873     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
 874     int i;
 875     for (i = 0; i < width; i++) {
 876         int g = src[0][i];
 877         int b = src[1][i];
 878         int r = src[2][i];
 879
 880         dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
 881     }
 882 }
 883
 884 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
 885 {
 886     uint16_t *dst = (uint16_t *)_dst;
 887     int i;
 888     for (i = 0; i < width; i++)
 889         dst[i] = src[3][i] << 6;
 890 }
 891
 892 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
 893 {
 894     uint16_t *dstU = (uint16_t *)_dstU;
 895     uint16_t *dstV = (uint16_t *)_dstV;
 896     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
 897     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
 898     int i;
 899     for (i = 0; i < width; i++) {
 900         int g = src[0][i];
 901         int b = src[1][i];
 902         int r = src[2][i];
 903
 904         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
 905         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
 906     }
 907 }
 908
 909 #define rdpx(src) \
 910     is_be ? AV_RB16(src) : AV_RL16(src)
 911 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
 912                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
 913 {
 914     int i;
 915     const uint16_t **src = (const uint16_t **)_src;
 916     uint16_t *dst        = (uint16_t *)_dst;
 917     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
 918     int shift = bpc < 16 ? bpc : 14;
 919     for (i = 0; i < width; i++) {
 920         int g = rdpx(src[0] + i);
 921         int b = rdpx(src[1] + i);
 922         int r = rdpx(src[2] + i);
 923
 924         dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
 925     }
 926 }
 927
 928 static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
 929                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
 930 {
 931     int i;
 932     const uint16_t **src = (const uint16_t **)_src;
 933     uint16_t *dst        = (uint16_t *)_dst;
 934     int shift = bpc < 16 ? bpc : 14;
 935
 936     for (i = 0; i < width; i++) {
 937         dst[i] = rdpx(src[3] + i) << (14 - shift);
 938     }
 939 }
 940
 941 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
 942                                                 const uint8_t *_src[4], int width,
 943                                                 int bpc, int is_be, int32_t *rgb2yuv)
 944 {
 945     int i;
 946     const uint16_t **src = (const uint16_t **)_src;
 947     uint16_t *dstU       = (uint16_t *)_dstU;
 948     uint16_t *dstV       = (uint16_t *)_dstV;
 949     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
 950     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
 951     int shift = bpc < 16 ? bpc : 14;
 952     for (i = 0; i < width; i++) {
 953         int g = rdpx(src[0] + i);
 954         int b = rdpx(src[1] + i);
 955         int r = rdpx(src[2] + i);
 956
 957         dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
 958         dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
 959     }
 960 }
 961 #undef rdpx
 962
 963 static av_always_inline void grayf32ToY16_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
 964                                             const uint8_t *unused2, int width, uint32_t *unused)
 965 {
 966     int i;
 967     const float *src = (const float *)_src;
 968     uint16_t *dst    = (uint16_t *)_dst;
 969
 970     for (i = 0; i < width; ++i){
 971         dst[i] = av_clip_uint16(lrintf(65535.0f * src[i]));
 972     }
 973 }
 974
 975 static av_always_inline void grayf32ToY16_bswap_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
 976                                                   const uint8_t *unused2, int width, uint32_t *unused)
 977 {
 978     int i;
 979     const uint32_t *src = (const uint32_t *)_src;
 980     uint16_t *dst    = (uint16_t *)_dst;
 981
 982     for (i = 0; i < width; ++i){
 983         dst[i] = av_clip_uint16(lrintf(65535.0f * av_int2float(av_bswap32(src[i]))));
 984     }
 985 }
 986
 987 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian)                                    \
 988 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4],              \
 989                                                   int w, int32_t *rgb2yuv)                          \
 990 {                                                                                                   \
 991     planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
 992 }                                                                                                   \
 993 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
 994                                                    const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
 995 {                                                                                                   \
 996     planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
 997 }                                                                                                   \
 998
 999 #define rgb9plus_planar_transparency_funcs(nbits)                           \
1000 static void planar_rgb##nbits##le_to_a(uint8_t *dst, const uint8_t *src[4], \
1001                                        int w, int32_t *rgb2yuv)             \
1002 {                                                                           \
1003     planar_rgb16_to_a(dst, src, w, nbits, 0, rgb2yuv);                      \
1004 }                                                                           \
1005 static void planar_rgb##nbits##be_to_a(uint8_t *dst, const uint8_t *src[4], \
1006                                        int w, int32_t *rgb2yuv)             \
1007 {                                                                           \
1008     planar_rgb16_to_a(dst, src, w, nbits, 1, rgb2yuv);                      \
1009 }
1010
1011 #define rgb9plus_planar_funcs(nbits)            \
1012     rgb9plus_planar_funcs_endian(nbits, le, 0)  \
1013     rgb9plus_planar_funcs_endian(nbits, be, 1)
1014
1015 rgb9plus_planar_funcs(9)
1016 rgb9plus_planar_funcs(10)
1017 rgb9plus_planar_funcs(12)
1018 rgb9plus_planar_funcs(14)
1019 rgb9plus_planar_funcs(16)
1020
1021 rgb9plus_planar_transparency_funcs(10)
1022 rgb9plus_planar_transparency_funcs(12)
1023 rgb9plus_planar_transparency_funcs(16)
1024
1025 av_cold void ff_sws_init_input_funcs(SwsContext *c)
1026 {
1027     enum AVPixelFormat srcFormat = c->srcFormat;
1028
1029     c->chrToYV12 = NULL;
1030     switch (srcFormat) {
1031     case AV_PIX_FMT_YUYV422:
1032         c->chrToYV12 = yuy2ToUV_c;
1033         break;
1034     case AV_PIX_FMT_YVYU422:
1035         c->chrToYV12 = yvy2ToUV_c;
1036         break;
1037     case AV_PIX_FMT_UYVY422:
1038         c->chrToYV12 = uyvyToUV_c;
1039         break;
1040     case AV_PIX_FMT_NV12:
1041     case AV_PIX_FMT_NV24:
1042         c->chrToYV12 = nv12ToUV_c;
1043         break;
1044     case AV_PIX_FMT_NV21:
1045     case AV_PIX_FMT_NV42:
1046         c->chrToYV12 = nv21ToUV_c;
1047         break;
1048     case AV_PIX_FMT_RGB8:
1049     case AV_PIX_FMT_BGR8:
1050     case AV_PIX_FMT_PAL8:
1051     case AV_PIX_FMT_BGR4_BYTE:
1052     case AV_PIX_FMT_RGB4_BYTE:
1053         c->chrToYV12 = palToUV_c;
1054         break;
1055     case AV_PIX_FMT_GBRP9LE:
1056         c->readChrPlanar = planar_rgb9le_to_uv;
1057         break;
1058     case AV_PIX_FMT_GBRAP10LE:
1059     case AV_PIX_FMT_GBRP10LE:
1060         c->readChrPlanar = planar_rgb10le_to_uv;
1061         break;
1062     case AV_PIX_FMT_GBRAP12LE:
1063     case AV_PIX_FMT_GBRP12LE:
1064         c->readChrPlanar = planar_rgb12le_to_uv;
1065         break;
1066     case AV_PIX_FMT_GBRP14LE:
1067         c->readChrPlanar = planar_rgb14le_to_uv;
1068         break;
1069     case AV_PIX_FMT_GBRAP16LE:
1070     case AV_PIX_FMT_GBRP16LE:
1071         c->readChrPlanar = planar_rgb16le_to_uv;
1072         break;
1073     case AV_PIX_FMT_GBRP9BE:
1074         c->readChrPlanar = planar_rgb9be_to_uv;
1075         break;
1076     case AV_PIX_FMT_GBRAP10BE:
1077     case AV_PIX_FMT_GBRP10BE:
1078         c->readChrPlanar = planar_rgb10be_to_uv;
1079         break;
1080     case AV_PIX_FMT_GBRAP12BE:
1081     case AV_PIX_FMT_GBRP12BE:
1082         c->readChrPlanar = planar_rgb12be_to_uv;
1083         break;
1084     case AV_PIX_FMT_GBRP14BE:
1085         c->readChrPlanar = planar_rgb14be_to_uv;
1086         break;
1087     case AV_PIX_FMT_GBRAP16BE:
1088     case AV_PIX_FMT_GBRP16BE:
1089         c->readChrPlanar = planar_rgb16be_to_uv;
1090         break;
1091     case AV_PIX_FMT_GBRAP:
1092     case AV_PIX_FMT_GBRP:
1093         c->readChrPlanar = planar_rgb_to_uv;
1094         break;
1095 #if HAVE_BIGENDIAN
1096     case AV_PIX_FMT_YUV420P9LE:
1097     case AV_PIX_FMT_YUV422P9LE:
1098     case AV_PIX_FMT_YUV444P9LE:
1099     case AV_PIX_FMT_YUV420P10LE:
1100     case AV_PIX_FMT_YUV422P10LE:
1101     case AV_PIX_FMT_YUV440P10LE:
1102     case AV_PIX_FMT_YUV444P10LE:
1103     case AV_PIX_FMT_YUV420P12LE:
1104     case AV_PIX_FMT_YUV422P12LE:
1105     case AV_PIX_FMT_YUV440P12LE:
1106     case AV_PIX_FMT_YUV444P12LE:
1107     case AV_PIX_FMT_YUV420P14LE:
1108     case AV_PIX_FMT_YUV422P14LE:
1109     case AV_PIX_FMT_YUV444P14LE:
1110     case AV_PIX_FMT_YUV420P16LE:
1111     case AV_PIX_FMT_YUV422P16LE:
1112     case AV_PIX_FMT_YUV444P16LE:
1113
1114     case AV_PIX_FMT_YUVA420P9LE:
1115     case AV_PIX_FMT_YUVA422P9LE:
1116     case AV_PIX_FMT_YUVA444P9LE:
1117     case AV_PIX_FMT_YUVA420P10LE:
1118     case AV_PIX_FMT_YUVA422P10LE:
1119     case AV_PIX_FMT_YUVA444P10LE:
1120     case AV_PIX_FMT_YUVA422P12LE:
1121     case AV_PIX_FMT_YUVA444P12LE:
1122     case AV_PIX_FMT_YUVA420P16LE:
1123     case AV_PIX_FMT_YUVA422P16LE:
1124     case AV_PIX_FMT_YUVA444P16LE:
1125         c->chrToYV12 = bswap16UV_c;
1126         break;
1127 #else
1128     case AV_PIX_FMT_YUV420P9BE:
1129     case AV_PIX_FMT_YUV422P9BE:
1130     case AV_PIX_FMT_YUV444P9BE:
1131     case AV_PIX_FMT_YUV420P10BE:
1132     case AV_PIX_FMT_YUV422P10BE:
1133     case AV_PIX_FMT_YUV440P10BE:
1134     case AV_PIX_FMT_YUV444P10BE:
1135     case AV_PIX_FMT_YUV420P12BE:
1136     case AV_PIX_FMT_YUV422P12BE:
1137     case AV_PIX_FMT_YUV440P12BE:
1138     case AV_PIX_FMT_YUV444P12BE:
1139     case AV_PIX_FMT_YUV420P14BE:
1140     case AV_PIX_FMT_YUV422P14BE:
1141     case AV_PIX_FMT_YUV444P14BE:
1142     case AV_PIX_FMT_YUV420P16BE:
1143     case AV_PIX_FMT_YUV422P16BE:
1144     case AV_PIX_FMT_YUV444P16BE:
1145
1146     case AV_PIX_FMT_YUVA420P9BE:
1147     case AV_PIX_FMT_YUVA422P9BE:
1148     case AV_PIX_FMT_YUVA444P9BE:
1149     case AV_PIX_FMT_YUVA420P10BE:
1150     case AV_PIX_FMT_YUVA422P10BE:
1151     case AV_PIX_FMT_YUVA444P10BE:
1152     case AV_PIX_FMT_YUVA422P12BE:
1153     case AV_PIX_FMT_YUVA444P12BE:
1154     case AV_PIX_FMT_YUVA420P16BE:
1155     case AV_PIX_FMT_YUVA422P16BE:
1156     case AV_PIX_FMT_YUVA444P16BE:
1157         c->chrToYV12 = bswap16UV_c;
1158         break;
1159 #endif
1160     case AV_PIX_FMT_AYUV64LE:
1161         c->chrToYV12 = read_ayuv64le_UV_c;
1162         break;
1163     case AV_PIX_FMT_P010LE:
1164         c->chrToYV12 = p010LEToUV_c;
1165         break;
1166     case AV_PIX_FMT_P010BE:
1167         c->chrToYV12 = p010BEToUV_c;
1168         break;
1169     case AV_PIX_FMT_P016LE:
1170         c->chrToYV12 = p016LEToUV_c;
1171         break;
1172     case AV_PIX_FMT_P016BE:
1173         c->chrToYV12 = p016BEToUV_c;
1174         break;
1175     case AV_PIX_FMT_Y210LE:
1176         c->chrToYV12 = y210le_UV_c;
1177         break;
1178     }
1179     if (c->chrSrcHSubSample) {
1180         switch (srcFormat) {
1181         case AV_PIX_FMT_RGBA64BE:
1182             c->chrToYV12 = rgb64BEToUV_half_c;
1183             break;
1184         case AV_PIX_FMT_RGBA64LE:
1185             c->chrToYV12 = rgb64LEToUV_half_c;
1186             break;
1187         case AV_PIX_FMT_BGRA64BE:
1188             c->chrToYV12 = bgr64BEToUV_half_c;
1189             break;
1190         case AV_PIX_FMT_BGRA64LE:
1191             c->chrToYV12 = bgr64LEToUV_half_c;
1192             break;
1193         case AV_PIX_FMT_RGB48BE:
1194             c->chrToYV12 = rgb48BEToUV_half_c;
1195             break;
1196         case AV_PIX_FMT_RGB48LE:
1197             c->chrToYV12 = rgb48LEToUV_half_c;
1198             break;
1199         case AV_PIX_FMT_BGR48BE:
1200             c->chrToYV12 = bgr48BEToUV_half_c;
1201             break;
1202         case AV_PIX_FMT_BGR48LE:
1203             c->chrToYV12 = bgr48LEToUV_half_c;
1204             break;
1205         case AV_PIX_FMT_RGB32:
1206             c->chrToYV12 = bgr32ToUV_half_c;
1207             break;
1208         case AV_PIX_FMT_RGB32_1:
1209             c->chrToYV12 = bgr321ToUV_half_c;
1210             break;
1211         case AV_PIX_FMT_BGR24:
1212             c->chrToYV12 = bgr24ToUV_half_c;
1213             break;
1214         case AV_PIX_FMT_BGR565LE:
1215             c->chrToYV12 = bgr16leToUV_half_c;
1216             break;
1217         case AV_PIX_FMT_BGR565BE:
1218             c->chrToYV12 = bgr16beToUV_half_c;
1219             break;
1220         case AV_PIX_FMT_BGR555LE:
1221             c->chrToYV12 = bgr15leToUV_half_c;
1222             break;
1223         case AV_PIX_FMT_BGR555BE:
1224             c->chrToYV12 = bgr15beToUV_half_c;
1225             break;
1226         case AV_PIX_FMT_GBRAP:
1227         case AV_PIX_FMT_GBRP:
1228             c->chrToYV12 = gbr24pToUV_half_c;
1229             break;
1230         case AV_PIX_FMT_BGR444LE:
1231             c->chrToYV12 = bgr12leToUV_half_c;
1232             break;
1233         case AV_PIX_FMT_BGR444BE:
1234             c->chrToYV12 = bgr12beToUV_half_c;
1235             break;
1236         case AV_PIX_FMT_BGR32:
1237             c->chrToYV12 = rgb32ToUV_half_c;
1238             break;
1239         case AV_PIX_FMT_BGR32_1:
1240             c->chrToYV12 = rgb321ToUV_half_c;
1241             break;
1242         case AV_PIX_FMT_RGB24:
1243             c->chrToYV12 = rgb24ToUV_half_c;
1244             break;
1245         case AV_PIX_FMT_RGB565LE:
1246             c->chrToYV12 = rgb16leToUV_half_c;
1247             break;
1248         case AV_PIX_FMT_RGB565BE:
1249             c->chrToYV12 = rgb16beToUV_half_c;
1250             break;
1251         case AV_PIX_FMT_RGB555LE:
1252             c->chrToYV12 = rgb15leToUV_half_c;
1253             break;
1254         case AV_PIX_FMT_RGB555BE:
1255             c->chrToYV12 = rgb15beToUV_half_c;
1256             break;
1257         case AV_PIX_FMT_RGB444LE:
1258             c->chrToYV12 = rgb12leToUV_half_c;
1259             break;
1260         case AV_PIX_FMT_RGB444BE:
1261             c->chrToYV12 = rgb12beToUV_half_c;
1262             break;
1263         }
1264     } else {
1265         switch (srcFormat) {
1266         case AV_PIX_FMT_RGBA64BE:
1267             c->chrToYV12 = rgb64BEToUV_c;
1268             break;
1269         case AV_PIX_FMT_RGBA64LE:
1270             c->chrToYV12 = rgb64LEToUV_c;
1271             break;
1272         case AV_PIX_FMT_BGRA64BE:
1273             c->chrToYV12 = bgr64BEToUV_c;
1274             break;
1275         case AV_PIX_FMT_BGRA64LE:
1276             c->chrToYV12 = bgr64LEToUV_c;
1277             break;
1278         case AV_PIX_FMT_RGB48BE:
1279             c->chrToYV12 = rgb48BEToUV_c;
1280             break;
1281         case AV_PIX_FMT_RGB48LE:
1282             c->chrToYV12 = rgb48LEToUV_c;
1283             break;
1284         case AV_PIX_FMT_BGR48BE:
1285             c->chrToYV12 = bgr48BEToUV_c;
1286             break;
1287         case AV_PIX_FMT_BGR48LE:
1288             c->chrToYV12 = bgr48LEToUV_c;
1289             break;
1290         case AV_PIX_FMT_RGB32:
1291             c->chrToYV12 = bgr32ToUV_c;
1292             break;
1293         case AV_PIX_FMT_RGB32_1:
1294             c->chrToYV12 = bgr321ToUV_c;
1295             break;
1296         case AV_PIX_FMT_BGR24:
1297             c->chrToYV12 = bgr24ToUV_c;
1298             break;
1299         case AV_PIX_FMT_BGR565LE:
1300             c->chrToYV12 = bgr16leToUV_c;
1301             break;
1302         case AV_PIX_FMT_BGR565BE:
1303             c->chrToYV12 = bgr16beToUV_c;
1304             break;
1305         case AV_PIX_FMT_BGR555LE:
1306             c->chrToYV12 = bgr15leToUV_c;
1307             break;
1308         case AV_PIX_FMT_BGR555BE:
1309             c->chrToYV12 = bgr15beToUV_c;
1310             break;
1311         case AV_PIX_FMT_BGR444LE:
1312             c->chrToYV12 = bgr12leToUV_c;
1313             break;
1314         case AV_PIX_FMT_BGR444BE:
1315             c->chrToYV12 = bgr12beToUV_c;
1316             break;
1317         case AV_PIX_FMT_BGR32:
1318             c->chrToYV12 = rgb32ToUV_c;
1319             break;
1320         case AV_PIX_FMT_BGR32_1:
1321             c->chrToYV12 = rgb321ToUV_c;
1322             break;
1323         case AV_PIX_FMT_RGB24:
1324             c->chrToYV12 = rgb24ToUV_c;
1325             break;
1326         case AV_PIX_FMT_RGB565LE:
1327             c->chrToYV12 = rgb16leToUV_c;
1328             break;
1329         case AV_PIX_FMT_RGB565BE:
1330             c->chrToYV12 = rgb16beToUV_c;
1331             break;
1332         case AV_PIX_FMT_RGB555LE:
1333             c->chrToYV12 = rgb15leToUV_c;
1334             break;
1335         case AV_PIX_FMT_RGB555BE:
1336             c->chrToYV12 = rgb15beToUV_c;
1337             break;
1338         case AV_PIX_FMT_RGB444LE:
1339             c->chrToYV12 = rgb12leToUV_c;
1340             break;
1341         case AV_PIX_FMT_RGB444BE:
1342             c->chrToYV12 = rgb12beToUV_c;
1343             break;
1344         }
1345     }
1346
1347     c->lumToYV12 = NULL;
1348     c->alpToYV12 = NULL;
1349     switch (srcFormat) {
1350     case AV_PIX_FMT_GBRP9LE:
1351         c->readLumPlanar = planar_rgb9le_to_y;
1352         break;
1353     case AV_PIX_FMT_GBRAP10LE:
1354         c->readAlpPlanar = planar_rgb10le_to_a;
1355     case AV_PIX_FMT_GBRP10LE:
1356         c->readLumPlanar = planar_rgb10le_to_y;
1357         break;
1358     case AV_PIX_FMT_GBRAP12LE:
1359         c->readAlpPlanar = planar_rgb12le_to_a;
1360     case AV_PIX_FMT_GBRP12LE:
1361         c->readLumPlanar = planar_rgb12le_to_y;
1362         break;
1363     case AV_PIX_FMT_GBRP14LE:
1364         c->readLumPlanar = planar_rgb14le_to_y;
1365         break;
1366     case AV_PIX_FMT_GBRAP16LE:
1367         c->readAlpPlanar = planar_rgb16le_to_a;
1368     case AV_PIX_FMT_GBRP16LE:
1369         c->readLumPlanar = planar_rgb16le_to_y;
1370         break;
1371     case AV_PIX_FMT_GBRP9BE:
1372         c->readLumPlanar = planar_rgb9be_to_y;
1373         break;
1374     case AV_PIX_FMT_GBRAP10BE:
1375         c->readAlpPlanar = planar_rgb10be_to_a;
1376     case AV_PIX_FMT_GBRP10BE:
1377         c->readLumPlanar = planar_rgb10be_to_y;
1378         break;
1379     case AV_PIX_FMT_GBRAP12BE:
1380         c->readAlpPlanar = planar_rgb12be_to_a;
1381     case AV_PIX_FMT_GBRP12BE:
1382         c->readLumPlanar = planar_rgb12be_to_y;
1383         break;
1384     case AV_PIX_FMT_GBRP14BE:
1385         c->readLumPlanar = planar_rgb14be_to_y;
1386         break;
1387     case AV_PIX_FMT_GBRAP16BE:
1388         c->readAlpPlanar = planar_rgb16be_to_a;
1389     case AV_PIX_FMT_GBRP16BE:
1390         c->readLumPlanar = planar_rgb16be_to_y;
1391         break;
1392     case AV_PIX_FMT_GBRAP:
1393         c->readAlpPlanar = planar_rgb_to_a;
1394     case AV_PIX_FMT_GBRP:
1395         c->readLumPlanar = planar_rgb_to_y;
1396         break;
1397 #if HAVE_BIGENDIAN
1398     case AV_PIX_FMT_YUV420P9LE:
1399     case AV_PIX_FMT_YUV422P9LE:
1400     case AV_PIX_FMT_YUV444P9LE:
1401     case AV_PIX_FMT_YUV420P10LE:
1402     case AV_PIX_FMT_YUV422P10LE:
1403     case AV_PIX_FMT_YUV440P10LE:
1404     case AV_PIX_FMT_YUV444P10LE:
1405     case AV_PIX_FMT_YUV420P12LE:
1406     case AV_PIX_FMT_YUV422P12LE:
1407     case AV_PIX_FMT_YUV440P12LE:
1408     case AV_PIX_FMT_YUV444P12LE:
1409     case AV_PIX_FMT_YUV420P14LE:
1410     case AV_PIX_FMT_YUV422P14LE:
1411     case AV_PIX_FMT_YUV444P14LE:
1412     case AV_PIX_FMT_YUV420P16LE:
1413     case AV_PIX_FMT_YUV422P16LE:
1414     case AV_PIX_FMT_YUV444P16LE:
1415
1416     case AV_PIX_FMT_GRAY9LE:
1417     case AV_PIX_FMT_GRAY10LE:
1418     case AV_PIX_FMT_GRAY12LE:
1419     case AV_PIX_FMT_GRAY14LE:
1420     case AV_PIX_FMT_GRAY16LE:
1421
1422     case AV_PIX_FMT_P016LE:
1423         c->lumToYV12 = bswap16Y_c;
1424         break;
1425     case AV_PIX_FMT_YUVA420P9LE:
1426     case AV_PIX_FMT_YUVA422P9LE:
1427     case AV_PIX_FMT_YUVA444P9LE:
1428     case AV_PIX_FMT_YUVA420P10LE:
1429     case AV_PIX_FMT_YUVA422P10LE:
1430     case AV_PIX_FMT_YUVA444P10LE:
1431     case AV_PIX_FMT_YUVA422P12LE:
1432     case AV_PIX_FMT_YUVA444P12LE:
1433     case AV_PIX_FMT_YUVA420P16LE:
1434     case AV_PIX_FMT_YUVA422P16LE:
1435     case AV_PIX_FMT_YUVA444P16LE:
1436         c->lumToYV12 = bswap16Y_c;
1437         c->alpToYV12 = bswap16Y_c;
1438         break;
1439 #else
1440     case AV_PIX_FMT_YUV420P9BE:
1441     case AV_PIX_FMT_YUV422P9BE:
1442     case AV_PIX_FMT_YUV444P9BE:
1443     case AV_PIX_FMT_YUV420P10BE:
1444     case AV_PIX_FMT_YUV422P10BE:
1445     case AV_PIX_FMT_YUV440P10BE:
1446     case AV_PIX_FMT_YUV444P10BE:
1447     case AV_PIX_FMT_YUV420P12BE:
1448     case AV_PIX_FMT_YUV422P12BE:
1449     case AV_PIX_FMT_YUV440P12BE:
1450     case AV_PIX_FMT_YUV444P12BE:
1451     case AV_PIX_FMT_YUV420P14BE:
1452     case AV_PIX_FMT_YUV422P14BE:
1453     case AV_PIX_FMT_YUV444P14BE:
1454     case AV_PIX_FMT_YUV420P16BE:
1455     case AV_PIX_FMT_YUV422P16BE:
1456     case AV_PIX_FMT_YUV444P16BE:
1457
1458     case AV_PIX_FMT_GRAY9BE:
1459     case AV_PIX_FMT_GRAY10BE:
1460     case AV_PIX_FMT_GRAY12BE:
1461     case AV_PIX_FMT_GRAY14BE:
1462     case AV_PIX_FMT_GRAY16BE:
1463
1464     case AV_PIX_FMT_P016BE:
1465         c->lumToYV12 = bswap16Y_c;
1466         break;
1467     case AV_PIX_FMT_YUVA420P9BE:
1468     case AV_PIX_FMT_YUVA422P9BE:
1469     case AV_PIX_FMT_YUVA444P9BE:
1470     case AV_PIX_FMT_YUVA420P10BE:
1471     case AV_PIX_FMT_YUVA422P10BE:
1472     case AV_PIX_FMT_YUVA444P10BE:
1473     case AV_PIX_FMT_YUVA422P12BE:
1474     case AV_PIX_FMT_YUVA444P12BE:
1475     case AV_PIX_FMT_YUVA420P16BE:
1476     case AV_PIX_FMT_YUVA422P16BE:
1477     case AV_PIX_FMT_YUVA444P16BE:
1478         c->lumToYV12 = bswap16Y_c;
1479         c->alpToYV12 = bswap16Y_c;
1480         break;
1481 #endif
1482     case AV_PIX_FMT_YA16LE:
1483         c->lumToYV12 = read_ya16le_gray_c;
1484         break;
1485     case AV_PIX_FMT_YA16BE:
1486         c->lumToYV12 = read_ya16be_gray_c;
1487         break;
1488     case AV_PIX_FMT_AYUV64LE:
1489         c->lumToYV12 = read_ayuv64le_Y_c;
1490         break;
1491     case AV_PIX_FMT_YUYV422:
1492     case AV_PIX_FMT_YVYU422:
1493     case AV_PIX_FMT_YA8:
1494         c->lumToYV12 = yuy2ToY_c;
1495         break;
1496     case AV_PIX_FMT_UYVY422:
1497         c->lumToYV12 = uyvyToY_c;
1498         break;
1499     case AV_PIX_FMT_BGR24:
1500         c->lumToYV12 = bgr24ToY_c;
1501         break;
1502     case AV_PIX_FMT_BGR565LE:
1503         c->lumToYV12 = bgr16leToY_c;
1504         break;
1505     case AV_PIX_FMT_BGR565BE:
1506         c->lumToYV12 = bgr16beToY_c;
1507         break;
1508     case AV_PIX_FMT_BGR555LE:
1509         c->lumToYV12 = bgr15leToY_c;
1510         break;
1511     case AV_PIX_FMT_BGR555BE:
1512         c->lumToYV12 = bgr15beToY_c;
1513         break;
1514     case AV_PIX_FMT_BGR444LE:
1515         c->lumToYV12 = bgr12leToY_c;
1516         break;
1517     case AV_PIX_FMT_BGR444BE:
1518         c->lumToYV12 = bgr12beToY_c;
1519         break;
1520     case AV_PIX_FMT_RGB24:
1521         c->lumToYV12 = rgb24ToY_c;
1522         break;
1523     case AV_PIX_FMT_RGB565LE:
1524         c->lumToYV12 = rgb16leToY_c;
1525         break;
1526     case AV_PIX_FMT_RGB565BE:
1527         c->lumToYV12 = rgb16beToY_c;
1528         break;
1529     case AV_PIX_FMT_RGB555LE:
1530         c->lumToYV12 = rgb15leToY_c;
1531         break;
1532     case AV_PIX_FMT_RGB555BE:
1533         c->lumToYV12 = rgb15beToY_c;
1534         break;
1535     case AV_PIX_FMT_RGB444LE:
1536         c->lumToYV12 = rgb12leToY_c;
1537         break;
1538     case AV_PIX_FMT_RGB444BE:
1539         c->lumToYV12 = rgb12beToY_c;
1540         break;
1541     case AV_PIX_FMT_RGB8:
1542     case AV_PIX_FMT_BGR8:
1543     case AV_PIX_FMT_PAL8:
1544     case AV_PIX_FMT_BGR4_BYTE:
1545     case AV_PIX_FMT_RGB4_BYTE:
1546         c->lumToYV12 = palToY_c;
1547         break;
1548     case AV_PIX_FMT_MONOBLACK:
1549         c->lumToYV12 = monoblack2Y_c;
1550         break;
1551     case AV_PIX_FMT_MONOWHITE:
1552         c->lumToYV12 = monowhite2Y_c;
1553         break;
1554     case AV_PIX_FMT_RGB32:
1555         c->lumToYV12 = bgr32ToY_c;
1556         break;
1557     case AV_PIX_FMT_RGB32_1:
1558         c->lumToYV12 = bgr321ToY_c;
1559         break;
1560     case AV_PIX_FMT_BGR32:
1561         c->lumToYV12 = rgb32ToY_c;
1562         break;
1563     case AV_PIX_FMT_BGR32_1:
1564         c->lumToYV12 = rgb321ToY_c;
1565         break;
1566     case AV_PIX_FMT_RGB48BE:
1567         c->lumToYV12 = rgb48BEToY_c;
1568         break;
1569     case AV_PIX_FMT_RGB48LE:
1570         c->lumToYV12 = rgb48LEToY_c;
1571         break;
1572     case AV_PIX_FMT_BGR48BE:
1573         c->lumToYV12 = bgr48BEToY_c;
1574         break;
1575     case AV_PIX_FMT_BGR48LE:
1576         c->lumToYV12 = bgr48LEToY_c;
1577         break;
1578     case AV_PIX_FMT_RGBA64BE:
1579         c->lumToYV12 = rgb64BEToY_c;
1580         break;
1581     case AV_PIX_FMT_RGBA64LE:
1582         c->lumToYV12 = rgb64LEToY_c;
1583         break;
1584     case AV_PIX_FMT_BGRA64BE:
1585         c->lumToYV12 = bgr64BEToY_c;
1586         break;
1587     case AV_PIX_FMT_BGRA64LE:
1588         c->lumToYV12 = bgr64LEToY_c;
1589         break;
1590     case AV_PIX_FMT_P010LE:
1591         c->lumToYV12 = p010LEToY_c;
1592         break;
1593     case AV_PIX_FMT_P010BE:
1594         c->lumToYV12 = p010BEToY_c;
1595         break;
1596     case AV_PIX_FMT_GRAYF32LE:
1597 #if HAVE_BIGENDIAN
1598         c->lumToYV12 = grayf32ToY16_bswap_c;
1599 #else
1600         c->lumToYV12 = grayf32ToY16_c;
1601 #endif
1602         break;
1603     case AV_PIX_FMT_GRAYF32BE:
1604 #if HAVE_BIGENDIAN
1605         c->lumToYV12 = grayf32ToY16_c;
1606 #else
1607         c->lumToYV12 = grayf32ToY16_bswap_c;
1608 #endif
1609         break;
1610     case AV_PIX_FMT_Y210LE:
1611         c->lumToYV12 = y210le_Y_c;
1612         break;
1613     }
1614     if (c->needAlpha) {
1615         if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1616             if (HAVE_BIGENDIAN == !isBE(srcFormat) && !c->readAlpPlanar)
1617                 c->alpToYV12 = bswap16Y_c;
1618         }
1619         switch (srcFormat) {
1620         case AV_PIX_FMT_BGRA64LE:
1621         case AV_PIX_FMT_RGBA64LE:  c->alpToYV12 = rgba64leToA_c; break;
1622         case AV_PIX_FMT_BGRA64BE:
1623         case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64beToA_c; break;
1624         case AV_PIX_FMT_BGRA:
1625         case AV_PIX_FMT_RGBA:
1626             c->alpToYV12 = rgbaToA_c;
1627             break;
1628         case AV_PIX_FMT_ABGR:
1629         case AV_PIX_FMT_ARGB:
1630             c->alpToYV12 = abgrToA_c;
1631             break;
1632         case AV_PIX_FMT_YA8:
1633             c->alpToYV12 = uyvyToY_c;
1634             break;
1635         case AV_PIX_FMT_YA16LE:
1636             c->alpToYV12 = read_ya16le_alpha_c;
1637             break;
1638         case AV_PIX_FMT_YA16BE:
1639             c->alpToYV12 = read_ya16be_alpha_c;
1640             break;
1641         case AV_PIX_FMT_AYUV64LE:
1642             c->alpToYV12 = read_ayuv64le_A_c;
1643             break;
1644         case AV_PIX_FMT_PAL8 :
1645             c->alpToYV12 = palToA_c;
1646             break;
1647         }
1648     }
1649 }