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

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