input.c 57.1 KB
Newer Older
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 8 9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19 20 21 22 23 24 25 26 27 28 29 30 31
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "libavutil/avutil.h"
#include "libavutil/bswap.h"
#include "libavutil/cpu.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
#include "libavutil/pixdesc.h"
32
#include "libavutil/avassert.h"
33 34 35 36 37 38 39
#include "config.h"
#include "rgb2rgb.h"
#include "swscale.h"
#include "swscale_internal.h"

#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))

40 41
#define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? b_r : r_b)
#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 44
static av_always_inline void
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 49 50 51 52 53
    int i;
    for (i = 0; i < width; i++) {
        unsigned int r_b = input_pixel(&src[i*4+0]);
        unsigned int   g = input_pixel(&src[i*4+1]);
        unsigned int b_r = input_pixel(&src[i*4+2]);

54
        dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
55 56 57 58 59 60
    }
}

static av_always_inline void
rgb64ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
                    const uint16_t *src1, const uint16_t *src2,
61
                    int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
62 63
{
    int i;
64 65
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
66
    av_assert1(src1==src2);
67 68 69 70 71
    for (i = 0; i < width; i++) {
        int r_b = input_pixel(&src1[i*4+0]);
        int   g = input_pixel(&src1[i*4+1]);
        int b_r = input_pixel(&src1[i*4+2]);

72 73
        dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
        dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
74 75 76 77 78 79
    }
}

static av_always_inline void
rgb64ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
                          const uint16_t *src1, const uint16_t *src2,
80
                          int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
81 82
{
    int i;
83 84
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
85
    av_assert1(src1==src2);
86 87 88 89 90
    for (i = 0; i < width; i++) {
        int r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
        int   g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
        int b_r = (input_pixel(&src1[8 * i + 2]) + input_pixel(&src1[8 * i + 6]) + 1) >> 1;

91 92
        dstU[i]= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
        dstV[i]= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
93 94 95 96 97
    }
}

#define rgb64funcs(pattern, BE_LE, origin) \
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 101
{ \
    const uint16_t *src = (const uint16_t *) _src; \
    uint16_t *dst = (uint16_t *) _dst; \
102
    rgb64ToY_c_template(dst, src, width, origin, rgb2yuv); \
103 104 105 106
} \
 \
static void pattern ## 64 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
                                    const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
107
                                    int width, uint32_t *rgb2yuv) \
108 109 110 111
{ \
    const uint16_t *src1 = (const uint16_t *) _src1, \
                   *src2 = (const uint16_t *) _src2; \
    uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
112
    rgb64ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
113 114 115 116
} \
 \
static void pattern ## 64 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
                                    const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
117
                                    int width, uint32_t *rgb2yuv) \
118 119 120 121
{ \
    const uint16_t *src1 = (const uint16_t *) _src1, \
                   *src2 = (const uint16_t *) _src2; \
    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 126
rgb64funcs(rgb, LE, AV_PIX_FMT_RGBA64LE)
rgb64funcs(rgb, BE, AV_PIX_FMT_RGBA64BE)
127 128
rgb64funcs(bgr, LE, AV_PIX_FMT_BGRA64LE)
rgb64funcs(bgr, BE, AV_PIX_FMT_BGRA64BE)
129

130 131
static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
                                                 const uint16_t *src, int width,
132 133
                                                 enum AVPixelFormat origin,
                                                 int32_t *rgb2yuv)
134
{
135
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
136 137
    int i;
    for (i = 0; i < width; i++) {
138 139 140
        unsigned int r_b = input_pixel(&src[i * 3 + 0]);
        unsigned int g   = input_pixel(&src[i * 3 + 1]);
        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 147 148 149 150
static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
                                                  uint16_t *dstV,
                                                  const uint16_t *src1,
                                                  const uint16_t *src2,
                                                  int width,
151 152
                                                  enum AVPixelFormat origin,
                                                  int32_t *rgb2yuv)
153 154
{
    int i;
155 156
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    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 160 161
        int r_b = input_pixel(&src1[i * 3 + 0]);
        int g   = input_pixel(&src1[i * 3 + 1]);
        int b_r = input_pixel(&src1[i * 3 + 2]);
162

163 164
        dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
        dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
165 166 167
    }
}

168 169 170 171 172
static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
                                                       uint16_t *dstV,
                                                       const uint16_t *src1,
                                                       const uint16_t *src2,
                                                       int width,
173 174
                                                       enum AVPixelFormat origin,
                                                       int32_t *rgb2yuv)
175 176
{
    int i;
177 178
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    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 182 183 184 185 186
        int r_b = (input_pixel(&src1[6 * i + 0]) +
                   input_pixel(&src1[6 * i + 3]) + 1) >> 1;
        int g   = (input_pixel(&src1[6 * i + 1]) +
                   input_pixel(&src1[6 * i + 4]) + 1) >> 1;
        int b_r = (input_pixel(&src1[6 * i + 2]) +
                   input_pixel(&src1[6 * i + 5]) + 1) >> 1;
187

188 189
        dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
        dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
190 191 192 193 194 195 196
    }
}

#undef r
#undef b
#undef input_pixel

197 198 199
#define rgb48funcs(pattern, BE_LE, origin)                              \
static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst,              \
                                            const uint8_t *_src,        \
200
                                            const uint8_t *unused0, const uint8_t *unused1,\
201
                                            int width,                  \
202
                                            uint32_t *rgb2yuv)          \
203 204 205
{                                                                       \
    const uint16_t *src = (const uint16_t *)_src;                       \
    uint16_t *dst       = (uint16_t *)_dst;                             \
206
    rgb48ToY_c_template(dst, src, width, origin, rgb2yuv);              \
207 208 209 210
}                                                                       \
                                                                        \
static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU,            \
                                             uint8_t *_dstV,            \
211
                                             const uint8_t *unused0,    \
212 213 214
                                             const uint8_t *_src1,      \
                                             const uint8_t *_src2,      \
                                             int width,                 \
215
                                             uint32_t *rgb2yuv)         \
216 217 218 219 220
{                                                                       \
    const uint16_t *src1 = (const uint16_t *)_src1,                     \
                   *src2 = (const uint16_t *)_src2;                     \
    uint16_t *dstU = (uint16_t *)_dstU,                                 \
             *dstV = (uint16_t *)_dstV;                                 \
221
    rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);        \
222 223 224 225
}                                                                       \
                                                                        \
static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU,       \
                                                  uint8_t *_dstV,       \
226
                                                  const uint8_t *unused0,    \
227 228 229
                                                  const uint8_t *_src1, \
                                                  const uint8_t *_src2, \
                                                  int width,            \
230
                                                  uint32_t *rgb2yuv)    \
231 232 233 234 235
{                                                                       \
    const uint16_t *src1 = (const uint16_t *)_src1,                     \
                   *src2 = (const uint16_t *)_src2;                     \
    uint16_t *dstU = (uint16_t *)_dstU,                                 \
             *dstV = (uint16_t *)_dstV;                                 \
236
    rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);   \
237 238
}

239 240 241 242
rgb48funcs(rgb, LE, AV_PIX_FMT_RGB48LE)
rgb48funcs(rgb, BE, AV_PIX_FMT_RGB48BE)
rgb48funcs(bgr, LE, AV_PIX_FMT_BGR48LE)
rgb48funcs(bgr, BE, AV_PIX_FMT_BGR48BE)
243

244 245 246 247
#define input_pixel(i) ((origin == AV_PIX_FMT_RGBA ||                      \
                         origin == AV_PIX_FMT_BGRA ||                      \
                         origin == AV_PIX_FMT_ARGB ||                      \
                         origin == AV_PIX_FMT_ABGR)                        \
248 249 250 251
                        ? AV_RN32A(&src[(i) * 4])                       \
                        : (isBE(origin) ? AV_RB16(&src[(i) * 2])        \
                                        : AV_RL16(&src[(i) * 2])))

252
static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
253 254
                                                    const uint8_t *src,
                                                    int width,
255
                                                    enum AVPixelFormat origin,
256 257 258 259
                                                    int shr, int shg,
                                                    int shb, int shp,
                                                    int maskr, int maskg,
                                                    int maskb, int rsh,
260 261
                                                    int gsh, int bsh, int S,
                                                    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 266 267 268
    int i;

    for (i = 0; i < width; i++) {
        int px = input_pixel(i) >> shp;
269 270 271
        int b  = (px & maskb) >> shb;
        int g  = (px & maskg) >> shg;
        int r  = (px & maskr) >> shr;
272

273
        dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
274 275 276
    }
}

277 278
static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
                                                     int16_t *dstV,
279 280
                                                     const uint8_t *src,
                                                     int width,
281
                                                     enum AVPixelFormat origin,
282 283 284 285
                                                     int shr, int shg,
                                                     int shb, int shp,
                                                     int maskr, int maskg,
                                                     int maskb, int rsh,
286 287
                                                     int gsh, int bsh, int S,
                                                     int32_t *rgb2yuv)
288
{
289 290
    const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
              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 293 294 295
    int i;

    for (i = 0; i < width; i++) {
        int px = input_pixel(i) >> shp;
296 297 298
        int b  = (px & maskb)   >> shb;
        int g  = (px & maskg)   >> shg;
        int r  = (px & maskr)   >> shr;
299

300 301
        dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
        dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
302 303 304
    }
}

305 306
static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
                                                          int16_t *dstV,
307 308
                                                          const uint8_t *src,
                                                          int width,
309
                                                          enum AVPixelFormat origin,
310 311 312 313
                                                          int shr, int shg,
                                                          int shb, int shp,
                                                          int maskr, int maskg,
                                                          int maskb, int rsh,
314 315
                                                          int gsh, int bsh, int S,
                                                          int32_t *rgb2yuv)
316
{
317 318
    const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
              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 322
    int i;

323 324 325
    maskr |= maskr << 1;
    maskb |= maskb << 1;
    maskg |= maskg << 1;
326
    for (i = 0; i < width; i++) {
327 328
        unsigned px0 = input_pixel(2 * i + 0) >> shp;
        unsigned px1 = input_pixel(2 * i + 1) >> shp;
329 330 331 332
        int b, r, g = (px0 & maskgx) + (px1 & maskgx);
        int rb = px0 + px1 - g;

        b = (rb & maskb) >> shb;
333
        if (shp ||
334 335
            origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
            origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
336 337
            g >>= shg;
        } else {
338
            g = (g & maskg) >> shg;
339 340 341
        }
        r = (rb & maskr) >> shr;

342 343
        dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
        dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
344 345 346 347 348
    }
}

#undef input_pixel

349 350
#define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr,          \
                         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 374
                                 shr, shg, shb, shp,                    \
                                 maskr, maskg, maskb,                   \
375
                                 rsh, gsh, bsh, S, tab);                \
376 377
}

378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
rgb16_32_wrapper(AV_PIX_FMT_BGR32,    bgr32,  16, 0,  0, 0, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_BGR32_1,  bgr321, 16, 0,  0, 8, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_RGB32,    rgb32,   0, 0, 16, 0,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_RGB32_1,  rgb321,  0, 0, 16, 8,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
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 400
    uint16_t *dstU = (uint16_t *)_dstU;
    uint16_t *dstV = (uint16_t *)_dstV;
401 402 403
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];

404
    int i;
405
    for (i = 0; i < width; i++) {
406 407 408 409
        unsigned int g   = gsrc[2*i] + gsrc[2*i+1];
        unsigned int b   = bsrc[2*i] + bsrc[2*i+1];
        unsigned int r   = rsrc[2*i] + rsrc[2*i+1];

410 411
        dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
        dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
412 413 414
    }
}

415 416
static void rgba64leToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
                          const uint8_t *unused2, int width, uint32_t *unused)
417
{
418 419
    int16_t *dst = (int16_t *)_dst;
    const uint16_t *src = (const uint16_t *)_src;
420
    int i;
421
    for (i = 0; i < width; i++)
422 423 424 425 426 427 428 429 430 431 432
        dst[i] = AV_RL16(src + 4 * i + 3);
}

static void rgba64beToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
                          const uint8_t *unused2, int width, uint32_t *unused)
{
    int16_t *dst = (int16_t *)_dst;
    const uint16_t *src = (const uint16_t *)_src;
    int i;
    for (i = 0; i < width; i++)
        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 439 440 441 442 443
    int i;
    for (i=0; i<width; i++) {
        dst[i]= src[4*i]<<6;
    }
}

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 448 449
    int i;
    for (i=0; i<width; i++) {
        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 457
    int i;
    for (i=0; i<width; i++) {
458 459 460
        int d= src[i];

        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 469
    for (i = 0; i < width; i++) {
        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 478
                      int width, uint32_t *pal)
{
479 480
    uint16_t *dstU = (uint16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
481
    int i;
482
    av_assert1(src1 == src2);
483 484
    for (i = 0; i < width; i++) {
        int p = pal[src1[i]];
485

486 487
        dstU[i] = (uint8_t)(p>> 8)<<6;
        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 496
    width = (width + 7) >> 3;
    for (i = 0; i < width; i++) {
497 498
        int d = ~src[i];
        for (j = 0; j < 8; j++)
499
            dst[8*i+j]= ((d>>(7-j))&1) * 16383;
500 501 502
    }
    if(width&7){
        int d= ~src[i];
503 504
        for (j = 0; j < (width&7); j++)
            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 513
    width = (width + 7) >> 3;
    for (i = 0; i < width; i++) {
514 515
        int d = src[i];
        for (j = 0; j < 8; j++)
516
            dst[8*i+j]= ((d>>(7-j))&1) * 16383;
517 518
    }
    if(width&7){
519 520 521
        int d = src[i];
        for (j = 0; j < (width&7); j++)
            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 527 528
                      uint32_t *unused)
{
    int i;
529 530
    for (i = 0; i < width; i++)
        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 535 536
                       const uint8_t *src2, int width, uint32_t *unused)
{
    int i;
537 538 539
    for (i = 0; i < width; i++) {
        dstU[i] = src1[4 * i + 1];
        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 546 547 548 549 550 551
                       const uint8_t *src2, int width, uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++) {
        dstV[i] = src1[4 * i + 1];
        dstU[i] = src1[4 * i + 3];
    }
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 560 561
    const uint16_t *src = (const uint16_t *)_src;
    uint16_t *dst       = (uint16_t *)_dst;
    for (i = 0; i < width; i++)
562 563 564
        dst[i] = av_bswap16(src[i]);
}

565
static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
566 567 568
                        const uint8_t *_src2, int width, uint32_t *unused)
{
    int i;
569 570 571 572
    const uint16_t *src1 = (const uint16_t *)_src1,
    *src2                = (const uint16_t *)_src2;
    uint16_t *dstU       = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
    for (i = 0; i < width; i++) {
573 574 575 576 577
        dstU[i] = av_bswap16(src1[i]);
        dstV[i] = av_bswap16(src2[i]);
    }
}

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 580 581 582 583 584 585
                               uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++)
        AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
}

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 588 589 590 591 592 593
                                uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++)
        AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
}

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 596 597 598 599 600 601
                               uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++)
        AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
}

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 604 605 606 607 608 609
                                uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++)
        AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
}

610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
                               uint32_t *unused2)
{
    int i;
    for (i = 0; i < width; i++)
        AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2));
}


static void read_ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
                               const uint8_t *unused1, int width, uint32_t *unused2)
{
    int i;
    for (i = 0; i < width; i++) {
        AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 4));
        AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6));
    }
}

static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
                                uint32_t *unused2)
{
    int i;
    for (i = 0; i < width; i++)
        AV_WN16(dst + i * 2, AV_RL16(src + i * 8));
}

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 641 642
                      uint32_t *unused)
{
    int i;
643 644
    for (i = 0; i < width; i++)
        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 649 650
                       const uint8_t *src2, int width, uint32_t *unused)
{
    int i;
651 652 653
    for (i = 0; i < width; i++) {
        dstU[i] = src1[4 * i + 0];
        dstV[i] = src1[4 * i + 2];
654
    }
655
    av_assert1(src1 == src2);
656 657 658 659 660 661 662
}

static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
                                        const uint8_t *src, int width)
{
    int i;
    for (i = 0; i < width; i++) {
663 664
        dst1[i] = src[2 * i + 0];
        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 671 672 673 674 675
                       int width, uint32_t *unused)
{
    nvXXtoUV_c(dstU, dstV, src1, width);
}

static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
676
                       const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
677 678 679 680 681
                       int width, uint32_t *unused)
{
    nvXXtoUV_c(dstV, dstU, src1, width);
}

682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
static void p010LEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
                        const uint8_t *unused2, int width, uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++) {
        AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> 6);
    }
}

static void p010BEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
                        const uint8_t *unused2, int width, uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++) {
        AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> 6);
    }
}

static void p010LEToUV_c(uint8_t *dstU, uint8_t *dstV,
                       const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
                       int width, uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++) {
        AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0) >> 6);
        AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2) >> 6);
    }
}

static void p010BEToUV_c(uint8_t *dstU, uint8_t *dstV,
                       const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
                       int width, uint32_t *unused)
{
    int i;
    for (i = 0; i < width; i++) {
        AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0) >> 6);
        AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2) >> 6);
    }
}

722 723
#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))

724
static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
725
                       int width, uint32_t *rgb2yuv)
726
{
727
    int16_t *dst = (int16_t *)_dst;
728
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
729
    int i;
730 731 732 733
    for (i = 0; i < width; i++) {
        int b = src[i * 3 + 0];
        int g = src[i * 3 + 1];
        int r = src[i * 3 + 2];
734

735
        dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
736 737 738
    }
}

739
static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
740
                        const uint8_t *src2, int width, uint32_t *rgb2yuv)
741
{
742 743
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
744 745
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
746
    int i;
747 748 749 750
    for (i = 0; i < width; i++) {
        int b = src1[3 * i + 0];
        int g = src1[3 * i + 1];
        int r = src1[3 * i + 2];
751

752 753
        dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
        dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
754
    }
755
    av_assert1(src1 == src2);
756 757
}

758
static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
759
                             const uint8_t *src2, int width, uint32_t *rgb2yuv)
760
{
761 762
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
763
    int i;
764 765
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
766 767 768 769
    for (i = 0; i < width; i++) {
        int b = src1[6 * i + 0] + src1[6 * i + 3];
        int g = src1[6 * i + 1] + src1[6 * i + 4];
        int r = src1[6 * i + 2] + src1[6 * i + 5];
770

771 772
        dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
        dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
773
    }
774
    av_assert1(src1 == src2);
775 776
}

777
static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
778
                       uint32_t *rgb2yuv)
779
{
780
    int16_t *dst = (int16_t *)_dst;
781
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
782
    int i;
783 784 785 786
    for (i = 0; i < width; i++) {
        int r = src[i * 3 + 0];
        int g = src[i * 3 + 1];
        int b = src[i * 3 + 2];
787

788
        dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
789 790 791
    }
}

792
static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
793
                        const uint8_t *src2, int width, uint32_t *rgb2yuv)
794
{
795 796
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
797
    int i;
798 799
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
800
    av_assert1(src1 == src2);
801 802 803 804
    for (i = 0; i < width; i++) {
        int r = src1[3 * i + 0];
        int g = src1[3 * i + 1];
        int b = src1[3 * i + 2];
805

806 807
        dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
        dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
808 809 810
    }
}

811
static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
812
                             const uint8_t *src2, int width, uint32_t *rgb2yuv)
813
{
814 815
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
816
    int i;
817 818
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
819
    av_assert1(src1 == src2);
820 821 822 823
    for (i = 0; i < width; i++) {
        int r = src1[6 * i + 0] + src1[6 * i + 3];
        int g = src1[6 * i + 1] + src1[6 * i + 4];
        int b = src1[6 * i + 2] + src1[6 * i + 5];
824

825 826
        dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
        dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
827 828 829
    }
}

830
static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
831
{
832
    uint16_t *dst = (uint16_t *)_dst;
833
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
834 835 836 837 838 839
    int i;
    for (i = 0; i < width; i++) {
        int g = src[0][i];
        int b = src[1][i];
        int r = src[2][i];

840
        dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
841 842 843
    }
}

844 845 846 847 848 849 850 851
static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
{
    uint16_t *dst = (uint16_t *)_dst;
    int i;
    for (i = 0; i < width; i++)
        dst[i] = src[3][i] << 6;
}

852
static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
853
{
854 855
    uint16_t *dstU = (uint16_t *)_dstU;
    uint16_t *dstV = (uint16_t *)_dstV;
856 857
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
858 859
    int i;
    for (i = 0; i < width; i++) {
860 861 862
        int g = src[0][i];
        int b = src[1][i];
        int r = src[2][i];
863

864 865
        dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
        dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
866 867 868
    }
}

869 870 871
#define rdpx(src) \
    is_be ? AV_RB16(src) : AV_RL16(src)
static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
872
                                               int width, int bpc, int is_be, int32_t *rgb2yuv)
873 874
{
    int i;
875 876
    const uint16_t **src = (const uint16_t **)_src;
    uint16_t *dst        = (uint16_t *)_dst;
877
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
878
    int shift = bpc < 16 ? bpc : 14;
879
    for (i = 0; i < width; i++) {
880 881 882
        int g = rdpx(src[0] + i);
        int b = rdpx(src[1] + i);
        int r = rdpx(src[2] + i);
883

884
        dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
885 886 887
    }
}

888 889 890 891 892 893 894 895 896 897 898 899 900
static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
                                               int width, int bpc, int is_be, int32_t *rgb2yuv)
{
    int i;
    const uint16_t **src = (const uint16_t **)_src;
    uint16_t *dst        = (uint16_t *)_dst;
    int shift = bpc < 16 ? bpc : 14;

    for (i = 0; i < width; i++) {
        dst[i] = rdpx(src[3] + i) << (14 - shift);
    }
}

901 902
static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
                                                const uint8_t *_src[4], int width,
903
                                                int bpc, int is_be, int32_t *rgb2yuv)
904 905
{
    int i;
906 907 908
    const uint16_t **src = (const uint16_t **)_src;
    uint16_t *dstU       = (uint16_t *)_dstU;
    uint16_t *dstV       = (uint16_t *)_dstV;
909 910
    int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
    int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
911
    int shift = bpc < 16 ? bpc : 14;
912
    for (i = 0; i < width; i++) {
913 914 915
        int g = rdpx(src[0] + i);
        int b = rdpx(src[1] + i);
        int r = rdpx(src[2] + i);
916

917 918
        dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
        dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
919 920
    }
}
921 922
#undef rdpx

923 924 925 926 927 928
#define rgb9plus_planar_funcs_endian(nbits, endian_name, endian)                                    \
static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4],              \
                                                  int w, int32_t *rgb2yuv)                          \
{                                                                                                   \
    planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
}                                                                                                   \
929 930 931 932 933
static void planar_rgb##nbits##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4],              \
                                                  int w, int32_t *rgb2yuv)                          \
{                                                                                                   \
    planar_rgb16_to_a(dst, src, w, nbits, endian, rgb2yuv);                                         \
}                                                                                                   \
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948
static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
                                                   const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
{                                                                                                   \
    planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
}                                                                                                   \

#define rgb9plus_planar_funcs(nbits)            \
    rgb9plus_planar_funcs_endian(nbits, le, 0)  \
    rgb9plus_planar_funcs_endian(nbits, be, 1)

rgb9plus_planar_funcs(9)
rgb9plus_planar_funcs(10)
rgb9plus_planar_funcs(12)
rgb9plus_planar_funcs(14)
rgb9plus_planar_funcs(16)
949 950 951

av_cold void ff_sws_init_input_funcs(SwsContext *c)
{
952
    enum AVPixelFormat srcFormat = c->srcFormat;
953 954

    c->chrToYV12 = NULL;
955
    switch (srcFormat) {
956
    case AV_PIX_FMT_YUYV422:
957 958
        c->chrToYV12 = yuy2ToUV_c;
        break;
959 960 961
    case AV_PIX_FMT_YVYU422:
        c->chrToYV12 = yvy2ToUV_c;
        break;
962
    case AV_PIX_FMT_UYVY422:
963 964
        c->chrToYV12 = uyvyToUV_c;
        break;
965
    case AV_PIX_FMT_NV12:
966 967
        c->chrToYV12 = nv12ToUV_c;
        break;
968
    case AV_PIX_FMT_NV21:
969 970
        c->chrToYV12 = nv21ToUV_c;
        break;
971 972 973 974 975
    case AV_PIX_FMT_RGB8:
    case AV_PIX_FMT_BGR8:
    case AV_PIX_FMT_PAL8:
    case AV_PIX_FMT_BGR4_BYTE:
    case AV_PIX_FMT_RGB4_BYTE:
976 977
        c->chrToYV12 = palToUV_c;
        break;
978
    case AV_PIX_FMT_GBRP9LE:
979 980
        c->readChrPlanar = planar_rgb9le_to_uv;
        break;
981
    case AV_PIX_FMT_GBRAP10LE:
982
    case AV_PIX_FMT_GBRP10LE:
983 984
        c->readChrPlanar = planar_rgb10le_to_uv;
        break;
985
    case AV_PIX_FMT_GBRAP12LE:
986
    case AV_PIX_FMT_GBRP12LE:
987 988
        c->readChrPlanar = planar_rgb12le_to_uv;
        break;
989
    case AV_PIX_FMT_GBRP14LE:
990 991
        c->readChrPlanar = planar_rgb14le_to_uv;
        break;
992
    case AV_PIX_FMT_GBRAP16LE:
993
    case AV_PIX_FMT_GBRP16LE:
994 995
        c->readChrPlanar = planar_rgb16le_to_uv;
        break;
996
    case AV_PIX_FMT_GBRP9BE:
997 998
        c->readChrPlanar = planar_rgb9be_to_uv;
        break;
999
    case AV_PIX_FMT_GBRAP10BE:
1000
    case AV_PIX_FMT_GBRP10BE:
1001 1002
        c->readChrPlanar = planar_rgb10be_to_uv;
        break;
1003
    case AV_PIX_FMT_GBRAP12BE:
1004
    case AV_PIX_FMT_GBRP12BE:
1005 1006
        c->readChrPlanar = planar_rgb12be_to_uv;
        break;
1007
    case AV_PIX_FMT_GBRP14BE:
1008 1009
        c->readChrPlanar = planar_rgb14be_to_uv;
        break;
1010
    case AV_PIX_FMT_GBRAP16BE:
1011
    case AV_PIX_FMT_GBRP16BE:
1012 1013
        c->readChrPlanar = planar_rgb16be_to_uv;
        break;
1014
    case AV_PIX_FMT_GBRAP:
1015
    case AV_PIX_FMT_GBRP:
1016 1017
        c->readChrPlanar = planar_rgb_to_uv;
        break;
1018
#if HAVE_BIGENDIAN
1019 1020 1021 1022
    case AV_PIX_FMT_YUV444P9LE:
    case AV_PIX_FMT_YUV422P9LE:
    case AV_PIX_FMT_YUV420P9LE:
    case AV_PIX_FMT_YUV422P10LE:
1023
    case AV_PIX_FMT_YUV440P10LE:
1024 1025
    case AV_PIX_FMT_YUV444P10LE:
    case AV_PIX_FMT_YUV420P10LE:
1026
    case AV_PIX_FMT_YUV422P12LE:
1027
    case AV_PIX_FMT_YUV440P12LE:
1028 1029 1030 1031 1032
    case AV_PIX_FMT_YUV444P12LE:
    case AV_PIX_FMT_YUV420P12LE:
    case AV_PIX_FMT_YUV422P14LE:
    case AV_PIX_FMT_YUV444P14LE:
    case AV_PIX_FMT_YUV420P14LE:
1033 1034 1035
    case AV_PIX_FMT_YUV420P16LE:
    case AV_PIX_FMT_YUV422P16LE:
    case AV_PIX_FMT_YUV444P16LE:
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045

    case AV_PIX_FMT_YUVA444P9LE:
    case AV_PIX_FMT_YUVA422P9LE:
    case AV_PIX_FMT_YUVA420P9LE:
    case AV_PIX_FMT_YUVA444P10LE:
    case AV_PIX_FMT_YUVA422P10LE:
    case AV_PIX_FMT_YUVA420P10LE:
    case AV_PIX_FMT_YUVA420P16LE:
    case AV_PIX_FMT_YUVA422P16LE:
    case AV_PIX_FMT_YUVA444P16LE:
1046 1047
        c->chrToYV12 = bswap16UV_c;
        break;
1048
#else
1049 1050 1051
    case AV_PIX_FMT_YUV444P9BE:
    case AV_PIX_FMT_YUV422P9BE:
    case AV_PIX_FMT_YUV420P9BE:
1052
    case AV_PIX_FMT_YUV440P10BE:
1053 1054 1055
    case AV_PIX_FMT_YUV444P10BE:
    case AV_PIX_FMT_YUV422P10BE:
    case AV_PIX_FMT_YUV420P10BE:
1056
    case AV_PIX_FMT_YUV440P12BE:
1057 1058 1059 1060 1061 1062
    case AV_PIX_FMT_YUV444P12BE:
    case AV_PIX_FMT_YUV422P12BE:
    case AV_PIX_FMT_YUV420P12BE:
    case AV_PIX_FMT_YUV444P14BE:
    case AV_PIX_FMT_YUV422P14BE:
    case AV_PIX_FMT_YUV420P14BE:
1063 1064 1065
    case AV_PIX_FMT_YUV420P16BE:
    case AV_PIX_FMT_YUV422P16BE:
    case AV_PIX_FMT_YUV444P16BE:
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075

    case AV_PIX_FMT_YUVA444P9BE:
    case AV_PIX_FMT_YUVA422P9BE:
    case AV_PIX_FMT_YUVA420P9BE:
    case AV_PIX_FMT_YUVA444P10BE:
    case AV_PIX_FMT_YUVA422P10BE:
    case AV_PIX_FMT_YUVA420P10BE:
    case AV_PIX_FMT_YUVA420P16BE:
    case AV_PIX_FMT_YUVA422P16BE:
    case AV_PIX_FMT_YUVA444P16BE:
1076 1077
        c->chrToYV12 = bswap16UV_c;
        break;
1078
#endif
1079 1080 1081
    case AV_PIX_FMT_AYUV64LE:
        c->chrToYV12 = read_ayuv64le_UV_c;
        break;
1082 1083 1084 1085 1086 1087
    case AV_PIX_FMT_P010LE:
        c->chrToYV12 = p010LEToUV_c;
        break;
    case AV_PIX_FMT_P010BE:
        c->chrToYV12 = p010BEToUV_c;
        break;
1088 1089
    }
    if (c->chrSrcHSubSample) {
1090
        switch (srcFormat) {
1091
        case AV_PIX_FMT_RGBA64BE:
1092 1093
            c->chrToYV12 = rgb64BEToUV_half_c;
            break;
1094
        case AV_PIX_FMT_RGBA64LE:
1095 1096
            c->chrToYV12 = rgb64LEToUV_half_c;
            break;
1097 1098 1099 1100 1101 1102
        case AV_PIX_FMT_BGRA64BE:
            c->chrToYV12 = bgr64BEToUV_half_c;
            break;
        case AV_PIX_FMT_BGRA64LE:
            c->chrToYV12 = bgr64LEToUV_half_c;
            break;
1103
        case AV_PIX_FMT_RGB48BE:
1104 1105
            c->chrToYV12 = rgb48BEToUV_half_c;
            break;
1106
        case AV_PIX_FMT_RGB48LE:
1107 1108
            c->chrToYV12 = rgb48LEToUV_half_c;
            break;
1109
        case AV_PIX_FMT_BGR48BE:
1110 1111
            c->chrToYV12 = bgr48BEToUV_half_c;
            break;
1112
        case AV_PIX_FMT_BGR48LE:
1113 1114
            c->chrToYV12 = bgr48LEToUV_half_c;
            break;
1115
        case AV_PIX_FMT_RGB32:
1116 1117
            c->chrToYV12 = bgr32ToUV_half_c;
            break;
1118
        case AV_PIX_FMT_RGB32_1:
1119 1120
            c->chrToYV12 = bgr321ToUV_half_c;
            break;
1121
        case AV_PIX_FMT_BGR24:
1122 1123
            c->chrToYV12 = bgr24ToUV_half_c;
            break;
1124
        case AV_PIX_FMT_BGR565LE:
1125 1126
            c->chrToYV12 = bgr16leToUV_half_c;
            break;
1127
        case AV_PIX_FMT_BGR565BE:
1128 1129
            c->chrToYV12 = bgr16beToUV_half_c;
            break;
1130
        case AV_PIX_FMT_BGR555LE:
1131 1132
            c->chrToYV12 = bgr15leToUV_half_c;
            break;
1133
        case AV_PIX_FMT_BGR555BE:
1134 1135
            c->chrToYV12 = bgr15beToUV_half_c;
            break;
1136 1137
        case AV_PIX_FMT_GBRAP:
        case AV_PIX_FMT_GBRP:
1138 1139
            c->chrToYV12 = gbr24pToUV_half_c;
            break;
1140
        case AV_PIX_FMT_BGR444LE:
1141 1142
            c->chrToYV12 = bgr12leToUV_half_c;
            break;
1143
        case AV_PIX_FMT_BGR444BE:
1144 1145
            c->chrToYV12 = bgr12beToUV_half_c;
            break;
1146
        case AV_PIX_FMT_BGR32:
1147 1148
            c->chrToYV12 = rgb32ToUV_half_c;
            break;
1149
        case AV_PIX_FMT_BGR32_1:
1150 1151
            c->chrToYV12 = rgb321ToUV_half_c;
            break;
1152
        case AV_PIX_FMT_RGB24:
1153 1154
            c->chrToYV12 = rgb24ToUV_half_c;
            break;
1155
        case AV_PIX_FMT_RGB565LE:
1156 1157
            c->chrToYV12 = rgb16leToUV_half_c;
            break;
1158
        case AV_PIX_FMT_RGB565BE:
1159 1160
            c->chrToYV12 = rgb16beToUV_half_c;
            break;
1161
        case AV_PIX_FMT_RGB555LE:
1162 1163
            c->chrToYV12 = rgb15leToUV_half_c;
            break;
1164
        case AV_PIX_FMT_RGB555BE:
1165 1166
            c->chrToYV12 = rgb15beToUV_half_c;
            break;
1167
        case AV_PIX_FMT_RGB444LE:
1168 1169
            c->chrToYV12 = rgb12leToUV_half_c;
            break;
1170
        case AV_PIX_FMT_RGB444BE:
1171 1172
            c->chrToYV12 = rgb12beToUV_half_c;
            break;
1173 1174
        }
    } else {
1175
        switch (srcFormat) {
1176
        case AV_PIX_FMT_RGBA64BE:
1177 1178
            c->chrToYV12 = rgb64BEToUV_c;
            break;
1179
        case AV_PIX_FMT_RGBA64LE:
1180 1181
            c->chrToYV12 = rgb64LEToUV_c;
            break;
1182 1183 1184 1185 1186 1187
        case AV_PIX_FMT_BGRA64BE:
            c->chrToYV12 = bgr64BEToUV_c;
            break;
        case AV_PIX_FMT_BGRA64LE:
            c->chrToYV12 = bgr64LEToUV_c;
            break;
1188
        case AV_PIX_FMT_RGB48BE:
1189 1190
            c->chrToYV12 = rgb48BEToUV_c;
            break;
1191
        case AV_PIX_FMT_RGB48LE:
1192 1193
            c->chrToYV12 = rgb48LEToUV_c;
            break;
1194
        case AV_PIX_FMT_BGR48BE:
1195 1196
            c->chrToYV12 = bgr48BEToUV_c;
            break;
1197
        case AV_PIX_FMT_BGR48LE:
1198 1199
            c->chrToYV12 = bgr48LEToUV_c;
            break;
1200
        case AV_PIX_FMT_RGB32:
1201 1202
            c->chrToYV12 = bgr32ToUV_c;
            break;
1203
        case AV_PIX_FMT_RGB32_1:
1204 1205
            c->chrToYV12 = bgr321ToUV_c;
            break;
1206
        case AV_PIX_FMT_BGR24:
1207 1208
            c->chrToYV12 = bgr24ToUV_c;
            break;
1209
        case AV_PIX_FMT_BGR565LE:
1210 1211
            c->chrToYV12 = bgr16leToUV_c;
            break;
1212
        case AV_PIX_FMT_BGR565BE:
1213 1214
            c->chrToYV12 = bgr16beToUV_c;
            break;
1215
        case AV_PIX_FMT_BGR555LE:
1216 1217
            c->chrToYV12 = bgr15leToUV_c;
            break;
1218
        case AV_PIX_FMT_BGR555BE:
1219 1220
            c->chrToYV12 = bgr15beToUV_c;
            break;
1221
        case AV_PIX_FMT_BGR444LE:
1222 1223
            c->chrToYV12 = bgr12leToUV_c;
            break;
1224
        case AV_PIX_FMT_BGR444BE:
1225 1226
            c->chrToYV12 = bgr12beToUV_c;
            break;
1227
        case AV_PIX_FMT_BGR32:
1228 1229
            c->chrToYV12 = rgb32ToUV_c;
            break;
1230
        case AV_PIX_FMT_BGR32_1:
1231 1232
            c->chrToYV12 = rgb321ToUV_c;
            break;
1233
        case AV_PIX_FMT_RGB24:
1234 1235
            c->chrToYV12 = rgb24ToUV_c;
            break;
1236
        case AV_PIX_FMT_RGB565LE:
1237 1238
            c->chrToYV12 = rgb16leToUV_c;
            break;
1239
        case AV_PIX_FMT_RGB565BE:
1240 1241
            c->chrToYV12 = rgb16beToUV_c;
            break;
1242
        case AV_PIX_FMT_RGB555LE:
1243 1244
            c->chrToYV12 = rgb15leToUV_c;
            break;
1245
        case AV_PIX_FMT_RGB555BE:
1246 1247
            c->chrToYV12 = rgb15beToUV_c;
            break;
1248
        case AV_PIX_FMT_RGB444LE:
1249 1250
            c->chrToYV12 = rgb12leToUV_c;
            break;
1251
        case AV_PIX_FMT_RGB444BE:
1252 1253
            c->chrToYV12 = rgb12beToUV_c;
            break;
1254 1255 1256 1257 1258 1259
        }
    }

    c->lumToYV12 = NULL;
    c->alpToYV12 = NULL;
    switch (srcFormat) {
1260
    case AV_PIX_FMT_GBRP9LE:
1261 1262
        c->readLumPlanar = planar_rgb9le_to_y;
        break;
1263 1264
    case AV_PIX_FMT_GBRAP10LE:
        c->readAlpPlanar = planar_rgb10le_to_a;
1265
    case AV_PIX_FMT_GBRP10LE:
1266 1267
        c->readLumPlanar = planar_rgb10le_to_y;
        break;
1268 1269
    case AV_PIX_FMT_GBRAP12LE:
        c->readAlpPlanar = planar_rgb12le_to_a;
1270
    case AV_PIX_FMT_GBRP12LE:
1271 1272
        c->readLumPlanar = planar_rgb12le_to_y;
        break;
1273
    case AV_PIX_FMT_GBRP14LE:
1274 1275
        c->readLumPlanar = planar_rgb14le_to_y;
        break;
1276
    case AV_PIX_FMT_GBRAP16LE:
1277
        c->readAlpPlanar = planar_rgb16le_to_a;
1278
    case AV_PIX_FMT_GBRP16LE:
1279 1280
        c->readLumPlanar = planar_rgb16le_to_y;
        break;
1281
    case AV_PIX_FMT_GBRP9BE:
1282 1283
        c->readLumPlanar = planar_rgb9be_to_y;
        break;
1284 1285
    case AV_PIX_FMT_GBRAP10BE:
        c->readAlpPlanar = planar_rgb10be_to_a;
1286
    case AV_PIX_FMT_GBRP10BE:
1287 1288
        c->readLumPlanar = planar_rgb10be_to_y;
        break;
1289 1290
    case AV_PIX_FMT_GBRAP12BE:
        c->readAlpPlanar = planar_rgb12be_to_a;
1291
    case AV_PIX_FMT_GBRP12BE:
1292 1293
        c->readLumPlanar = planar_rgb12be_to_y;
        break;
1294
    case AV_PIX_FMT_GBRP14BE:
1295 1296
        c->readLumPlanar = planar_rgb14be_to_y;
        break;
1297
    case AV_PIX_FMT_GBRAP16BE:
1298
        c->readAlpPlanar = planar_rgb16be_to_a;
1299
    case AV_PIX_FMT_GBRP16BE:
1300 1301
        c->readLumPlanar = planar_rgb16be_to_y;
        break;
1302 1303
    case AV_PIX_FMT_GBRAP:
        c->readAlpPlanar = planar_rgb_to_a;
1304
    case AV_PIX_FMT_GBRP:
1305 1306
        c->readLumPlanar = planar_rgb_to_y;
        break;
1307
#if HAVE_BIGENDIAN
1308 1309 1310 1311
    case AV_PIX_FMT_YUV444P9LE:
    case AV_PIX_FMT_YUV422P9LE:
    case AV_PIX_FMT_YUV420P9LE:
    case AV_PIX_FMT_YUV444P10LE:
1312
    case AV_PIX_FMT_YUV440P10LE:
1313 1314
    case AV_PIX_FMT_YUV422P10LE:
    case AV_PIX_FMT_YUV420P10LE:
1315
    case AV_PIX_FMT_YUV444P12LE:
1316
    case AV_PIX_FMT_YUV440P12LE:
1317 1318 1319 1320 1321
    case AV_PIX_FMT_YUV422P12LE:
    case AV_PIX_FMT_YUV420P12LE:
    case AV_PIX_FMT_YUV444P14LE:
    case AV_PIX_FMT_YUV422P14LE:
    case AV_PIX_FMT_YUV420P14LE:
1322 1323 1324
    case AV_PIX_FMT_YUV420P16LE:
    case AV_PIX_FMT_YUV422P16LE:
    case AV_PIX_FMT_YUV444P16LE:
1325

1326
    case AV_PIX_FMT_GRAY16LE:
1327 1328
        c->lumToYV12 = bswap16Y_c;
        break;
1329 1330 1331 1332 1333 1334 1335 1336 1337
    case AV_PIX_FMT_YUVA444P9LE:
    case AV_PIX_FMT_YUVA422P9LE:
    case AV_PIX_FMT_YUVA420P9LE:
    case AV_PIX_FMT_YUVA444P10LE:
    case AV_PIX_FMT_YUVA422P10LE:
    case AV_PIX_FMT_YUVA420P10LE:
    case AV_PIX_FMT_YUVA420P16LE:
    case AV_PIX_FMT_YUVA422P16LE:
    case AV_PIX_FMT_YUVA444P16LE:
1338
        c->lumToYV12 = bswap16Y_c;
1339
        c->alpToYV12 = bswap16Y_c;
1340
        break;
1341
#else
1342 1343 1344 1345
    case AV_PIX_FMT_YUV444P9BE:
    case AV_PIX_FMT_YUV422P9BE:
    case AV_PIX_FMT_YUV420P9BE:
    case AV_PIX_FMT_YUV444P10BE:
1346
    case AV_PIX_FMT_YUV440P10BE:
1347 1348
    case AV_PIX_FMT_YUV422P10BE:
    case AV_PIX_FMT_YUV420P10BE:
1349
    case AV_PIX_FMT_YUV444P12BE:
1350
    case AV_PIX_FMT_YUV440P12BE:
1351 1352 1353 1354 1355
    case AV_PIX_FMT_YUV422P12BE:
    case AV_PIX_FMT_YUV420P12BE:
    case AV_PIX_FMT_YUV444P14BE:
    case AV_PIX_FMT_YUV422P14BE:
    case AV_PIX_FMT_YUV420P14BE:
1356 1357 1358
    case AV_PIX_FMT_YUV420P16BE:
    case AV_PIX_FMT_YUV422P16BE:
    case AV_PIX_FMT_YUV444P16BE:
1359

1360
    case AV_PIX_FMT_GRAY16BE:
1361 1362
        c->lumToYV12 = bswap16Y_c;
        break;
1363 1364 1365 1366 1367 1368 1369 1370 1371
    case AV_PIX_FMT_YUVA444P9BE:
    case AV_PIX_FMT_YUVA422P9BE:
    case AV_PIX_FMT_YUVA420P9BE:
    case AV_PIX_FMT_YUVA444P10BE:
    case AV_PIX_FMT_YUVA422P10BE:
    case AV_PIX_FMT_YUVA420P10BE:
    case AV_PIX_FMT_YUVA420P16BE:
    case AV_PIX_FMT_YUVA422P16BE:
    case AV_PIX_FMT_YUVA444P16BE:
1372
        c->lumToYV12 = bswap16Y_c;
1373
        c->alpToYV12 = bswap16Y_c;
1374
        break;
1375
#endif
1376 1377 1378 1379 1380 1381
    case AV_PIX_FMT_YA16LE:
        c->lumToYV12 = read_ya16le_gray_c;
        break;
    case AV_PIX_FMT_YA16BE:
        c->lumToYV12 = read_ya16be_gray_c;
        break;
1382 1383 1384
    case AV_PIX_FMT_AYUV64LE:
        c->lumToYV12 = read_ayuv64le_Y_c;
        break;
1385
    case AV_PIX_FMT_YUYV422:
1386
    case AV_PIX_FMT_YVYU422:
1387
    case AV_PIX_FMT_YA8:
1388 1389
        c->lumToYV12 = yuy2ToY_c;
        break;
1390
    case AV_PIX_FMT_UYVY422:
1391 1392
        c->lumToYV12 = uyvyToY_c;
        break;
1393
    case AV_PIX_FMT_BGR24:
1394 1395
        c->lumToYV12 = bgr24ToY_c;
        break;
1396
    case AV_PIX_FMT_BGR565LE:
1397 1398
        c->lumToYV12 = bgr16leToY_c;
        break;
1399
    case AV_PIX_FMT_BGR565BE:
1400 1401
        c->lumToYV12 = bgr16beToY_c;
        break;
1402
    case AV_PIX_FMT_BGR555LE:
1403 1404
        c->lumToYV12 = bgr15leToY_c;
        break;
1405
    case AV_PIX_FMT_BGR555BE:
1406 1407
        c->lumToYV12 = bgr15beToY_c;
        break;
1408
    case AV_PIX_FMT_BGR444LE:
1409 1410
        c->lumToYV12 = bgr12leToY_c;
        break;
1411
    case AV_PIX_FMT_BGR444BE:
1412 1413
        c->lumToYV12 = bgr12beToY_c;
        break;
1414
    case AV_PIX_FMT_RGB24:
1415 1416
        c->lumToYV12 = rgb24ToY_c;
        break;
1417
    case AV_PIX_FMT_RGB565LE:
1418 1419
        c->lumToYV12 = rgb16leToY_c;
        break;
1420
    case AV_PIX_FMT_RGB565BE:
1421 1422
        c->lumToYV12 = rgb16beToY_c;
        break;
1423
    case AV_PIX_FMT_RGB555LE:
1424 1425
        c->lumToYV12 = rgb15leToY_c;
        break;
1426
    case AV_PIX_FMT_RGB555BE:
1427 1428
        c->lumToYV12 = rgb15beToY_c;
        break;
1429
    case AV_PIX_FMT_RGB444LE:
1430 1431
        c->lumToYV12 = rgb12leToY_c;
        break;
1432
    case AV_PIX_FMT_RGB444BE:
1433 1434
        c->lumToYV12 = rgb12beToY_c;
        break;
1435 1436 1437 1438 1439
    case AV_PIX_FMT_RGB8:
    case AV_PIX_FMT_BGR8:
    case AV_PIX_FMT_PAL8:
    case AV_PIX_FMT_BGR4_BYTE:
    case AV_PIX_FMT_RGB4_BYTE:
1440 1441
        c->lumToYV12 = palToY_c;
        break;
1442
    case AV_PIX_FMT_MONOBLACK:
1443 1444
        c->lumToYV12 = monoblack2Y_c;
        break;
1445
    case AV_PIX_FMT_MONOWHITE:
1446 1447
        c->lumToYV12 = monowhite2Y_c;
        break;
1448
    case AV_PIX_FMT_RGB32:
1449 1450
        c->lumToYV12 = bgr32ToY_c;
        break;
1451
    case AV_PIX_FMT_RGB32_1:
1452 1453
        c->lumToYV12 = bgr321ToY_c;
        break;
1454
    case AV_PIX_FMT_BGR32:
1455 1456
        c->lumToYV12 = rgb32ToY_c;
        break;
1457
    case AV_PIX_FMT_BGR32_1:
1458 1459
        c->lumToYV12 = rgb321ToY_c;
        break;
1460
    case AV_PIX_FMT_RGB48BE:
1461 1462
        c->lumToYV12 = rgb48BEToY_c;
        break;
1463
    case AV_PIX_FMT_RGB48LE:
1464 1465
        c->lumToYV12 = rgb48LEToY_c;
        break;
1466
    case AV_PIX_FMT_BGR48BE:
1467 1468
        c->lumToYV12 = bgr48BEToY_c;
        break;
1469
    case AV_PIX_FMT_BGR48LE:
1470 1471
        c->lumToYV12 = bgr48LEToY_c;
        break;
1472
    case AV_PIX_FMT_RGBA64BE:
1473 1474
        c->lumToYV12 = rgb64BEToY_c;
        break;
1475
    case AV_PIX_FMT_RGBA64LE:
1476 1477
        c->lumToYV12 = rgb64LEToY_c;
        break;
1478 1479 1480 1481 1482
    case AV_PIX_FMT_BGRA64BE:
        c->lumToYV12 = bgr64BEToY_c;
        break;
    case AV_PIX_FMT_BGRA64LE:
        c->lumToYV12 = bgr64LEToY_c;
1483 1484 1485 1486 1487 1488 1489
        break;
    case AV_PIX_FMT_P010LE:
        c->lumToYV12 = p010LEToY_c;
        break;
    case AV_PIX_FMT_P010BE:
        c->lumToYV12 = p010BEToY_c;
        break;
1490
    }
1491
    if (c->needAlpha) {
1492 1493 1494 1495
        if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
            if (HAVE_BIGENDIAN == !isBE(srcFormat))
                c->alpToYV12 = bswap16Y_c;
        }
1496
        switch (srcFormat) {
1497
        case AV_PIX_FMT_BGRA64LE:
1498
        case AV_PIX_FMT_RGBA64LE:  c->alpToYV12 = rgba64leToA_c; break;
1499
        case AV_PIX_FMT_BGRA64BE:
1500
        case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64beToA_c; break;
1501 1502
        case AV_PIX_FMT_BGRA:
        case AV_PIX_FMT_RGBA:
1503 1504
            c->alpToYV12 = rgbaToA_c;
            break;
1505 1506
        case AV_PIX_FMT_ABGR:
        case AV_PIX_FMT_ARGB:
1507 1508
            c->alpToYV12 = abgrToA_c;
            break;
1509
        case AV_PIX_FMT_YA8:
1510 1511
            c->alpToYV12 = uyvyToY_c;
            break;
1512 1513 1514 1515 1516 1517
        case AV_PIX_FMT_YA16LE:
            c->alpToYV12 = read_ya16le_alpha_c;
            break;
        case AV_PIX_FMT_YA16BE:
            c->alpToYV12 = read_ya16be_alpha_c;
            break;
1518 1519 1520
        case AV_PIX_FMT_AYUV64LE:
            c->alpToYV12 = read_ayuv64le_A_c;
            break;
1521
        case AV_PIX_FMT_PAL8 :
1522 1523
            c->alpToYV12 = palToA_c;
            break;
1524 1525 1526
        }
    }
}