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

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