input.c 58.6 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 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
static void p016LEToUV_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));
        AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2));
    }
}

static void p016BEToUV_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));
        AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2));
    }
}

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

746
static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
747
                       int width, uint32_t *rgb2yuv)
748
{
749
    int16_t *dst = (int16_t *)_dst;
750
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
751
    int i;
752 753 754 755
    for (i = 0; i < width; i++) {
        int b = src[i * 3 + 0];
        int g = src[i * 3 + 1];
        int r = src[i * 3 + 2];
756

757
        dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
758 759 760
    }
}

761
static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
762
                        const uint8_t *src2, int width, uint32_t *rgb2yuv)
763
{
764 765
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
766 767
    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];
768
    int i;
769 770 771 772
    for (i = 0; i < width; i++) {
        int b = src1[3 * i + 0];
        int g = src1[3 * i + 1];
        int r = src1[3 * i + 2];
773

774 775
        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);
776
    }
777
    av_assert1(src1 == src2);
778 779
}

780
static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
781
                             const uint8_t *src2, int width, uint32_t *rgb2yuv)
782
{
783 784
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
785
    int i;
786 787
    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];
788 789 790 791
    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];
792

793 794
        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);
795
    }
796
    av_assert1(src1 == src2);
797 798
}

799
static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
800
                       uint32_t *rgb2yuv)
801
{
802
    int16_t *dst = (int16_t *)_dst;
803
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
804
    int i;
805 806 807 808
    for (i = 0; i < width; i++) {
        int r = src[i * 3 + 0];
        int g = src[i * 3 + 1];
        int b = src[i * 3 + 2];
809

810
        dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
811 812 813
    }
}

814
static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
815
                        const uint8_t *src2, int width, uint32_t *rgb2yuv)
816
{
817 818
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
819
    int i;
820 821
    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];
822
    av_assert1(src1 == src2);
823 824 825 826
    for (i = 0; i < width; i++) {
        int r = src1[3 * i + 0];
        int g = src1[3 * i + 1];
        int b = src1[3 * i + 2];
827

828 829
        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);
830 831 832
    }
}

833
static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
834
                             const uint8_t *src2, int width, uint32_t *rgb2yuv)
835
{
836 837
    int16_t *dstU = (int16_t *)_dstU;
    int16_t *dstV = (int16_t *)_dstV;
838
    int i;
839 840
    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];
841
    av_assert1(src1 == src2);
842 843 844 845
    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];
846

847 848
        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);
849 850 851
    }
}

852
static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
853
{
854
    uint16_t *dst = (uint16_t *)_dst;
855
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
856 857 858 859 860 861
    int i;
    for (i = 0; i < width; i++) {
        int g = src[0][i];
        int b = src[1][i];
        int r = src[2][i];

862
        dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
863 864 865
    }
}

866 867 868 869 870 871 872 873
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;
}

874
static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
875
{
876 877
    uint16_t *dstU = (uint16_t *)_dstU;
    uint16_t *dstV = (uint16_t *)_dstV;
878 879
    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];
880 881
    int i;
    for (i = 0; i < width; i++) {
882 883 884
        int g = src[0][i];
        int b = src[1][i];
        int r = src[2][i];
885

886 887
        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);
888 889 890
    }
}

891 892 893
#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],
894
                                               int width, int bpc, int is_be, int32_t *rgb2yuv)
895 896
{
    int i;
897 898
    const uint16_t **src = (const uint16_t **)_src;
    uint16_t *dst        = (uint16_t *)_dst;
899
    int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
900
    int shift = bpc < 16 ? bpc : 14;
901
    for (i = 0; i < width; i++) {
902 903 904
        int g = rdpx(src[0] + i);
        int b = rdpx(src[1] + i);
        int r = rdpx(src[2] + i);
905

906
        dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
907 908 909
    }
}

910 911 912 913 914 915 916 917 918 919 920 921 922
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);
    }
}

923 924
static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
                                                const uint8_t *_src[4], int width,
925
                                                int bpc, int is_be, int32_t *rgb2yuv)
926 927
{
    int i;
928 929 930
    const uint16_t **src = (const uint16_t **)_src;
    uint16_t *dstU       = (uint16_t *)_dstU;
    uint16_t *dstV       = (uint16_t *)_dstV;
931 932
    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];
933
    int shift = bpc < 16 ? bpc : 14;
934
    for (i = 0; i < width; i++) {
935 936 937
        int g = rdpx(src[0] + i);
        int b = rdpx(src[1] + i);
        int r = rdpx(src[2] + i);
938

939 940
        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);
941 942
    }
}
943 944
#undef rdpx

945 946 947 948 949 950 951 952 953 954 955 956
#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);                                         \
}                                                                                                   \
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);                                 \
}                                                                                                   \

957 958 959 960 961 962 963 964 965 966 967 968
#define rgb9plus_planar_transparency_funcs(nbits)                           \
static void planar_rgb##nbits##le_to_a(uint8_t *dst, const uint8_t *src[4], \
                                       int w, int32_t *rgb2yuv)             \
{                                                                           \
    planar_rgb16_to_a(dst, src, w, nbits, 0, rgb2yuv);                      \
}                                                                           \
static void planar_rgb##nbits##be_to_a(uint8_t *dst, const uint8_t *src[4], \
                                       int w, int32_t *rgb2yuv)             \
{                                                                           \
    planar_rgb16_to_a(dst, src, w, nbits, 1, rgb2yuv);                      \
}

969 970 971 972 973 974 975 976 977
#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)
978

979 980 981 982
rgb9plus_planar_transparency_funcs(10)
rgb9plus_planar_transparency_funcs(12)
rgb9plus_planar_transparency_funcs(16)

983 984
av_cold void ff_sws_init_input_funcs(SwsContext *c)
{
985
    enum AVPixelFormat srcFormat = c->srcFormat;
986 987

    c->chrToYV12 = NULL;
988
    switch (srcFormat) {
989
    case AV_PIX_FMT_YUYV422:
990 991
        c->chrToYV12 = yuy2ToUV_c;
        break;
992 993 994
    case AV_PIX_FMT_YVYU422:
        c->chrToYV12 = yvy2ToUV_c;
        break;
995
    case AV_PIX_FMT_UYVY422:
996 997
        c->chrToYV12 = uyvyToUV_c;
        break;
998
    case AV_PIX_FMT_NV12:
999 1000
        c->chrToYV12 = nv12ToUV_c;
        break;
1001
    case AV_PIX_FMT_NV21:
1002 1003
        c->chrToYV12 = nv21ToUV_c;
        break;
1004 1005 1006 1007 1008
    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:
1009 1010
        c->chrToYV12 = palToUV_c;
        break;
1011
    case AV_PIX_FMT_GBRP9LE:
1012 1013
        c->readChrPlanar = planar_rgb9le_to_uv;
        break;
1014
    case AV_PIX_FMT_GBRAP10LE:
1015
    case AV_PIX_FMT_GBRP10LE:
1016 1017
        c->readChrPlanar = planar_rgb10le_to_uv;
        break;
1018
    case AV_PIX_FMT_GBRAP12LE:
1019
    case AV_PIX_FMT_GBRP12LE:
1020 1021
        c->readChrPlanar = planar_rgb12le_to_uv;
        break;
1022
    case AV_PIX_FMT_GBRP14LE:
1023 1024
        c->readChrPlanar = planar_rgb14le_to_uv;
        break;
1025
    case AV_PIX_FMT_GBRAP16LE:
1026
    case AV_PIX_FMT_GBRP16LE:
1027 1028
        c->readChrPlanar = planar_rgb16le_to_uv;
        break;
1029
    case AV_PIX_FMT_GBRP9BE:
1030 1031
        c->readChrPlanar = planar_rgb9be_to_uv;
        break;
1032
    case AV_PIX_FMT_GBRAP10BE:
1033
    case AV_PIX_FMT_GBRP10BE:
1034 1035
        c->readChrPlanar = planar_rgb10be_to_uv;
        break;
1036
    case AV_PIX_FMT_GBRAP12BE:
1037
    case AV_PIX_FMT_GBRP12BE:
1038 1039
        c->readChrPlanar = planar_rgb12be_to_uv;
        break;
1040
    case AV_PIX_FMT_GBRP14BE:
1041 1042
        c->readChrPlanar = planar_rgb14be_to_uv;
        break;
1043
    case AV_PIX_FMT_GBRAP16BE:
1044
    case AV_PIX_FMT_GBRP16BE:
1045 1046
        c->readChrPlanar = planar_rgb16be_to_uv;
        break;
1047
    case AV_PIX_FMT_GBRAP:
1048
    case AV_PIX_FMT_GBRP:
1049 1050
        c->readChrPlanar = planar_rgb_to_uv;
        break;
1051
#if HAVE_BIGENDIAN
1052
    case AV_PIX_FMT_YUV420P9LE:
1053 1054 1055
    case AV_PIX_FMT_YUV422P9LE:
    case AV_PIX_FMT_YUV444P9LE:
    case AV_PIX_FMT_YUV420P10LE:
1056
    case AV_PIX_FMT_YUV422P10LE:
1057
    case AV_PIX_FMT_YUV440P10LE:
1058
    case AV_PIX_FMT_YUV444P10LE:
1059
    case AV_PIX_FMT_YUV420P12LE:
1060
    case AV_PIX_FMT_YUV422P12LE:
1061
    case AV_PIX_FMT_YUV440P12LE:
1062
    case AV_PIX_FMT_YUV444P12LE:
1063
    case AV_PIX_FMT_YUV420P14LE:
1064 1065
    case AV_PIX_FMT_YUV422P14LE:
    case AV_PIX_FMT_YUV444P14LE:
1066 1067 1068
    case AV_PIX_FMT_YUV420P16LE:
    case AV_PIX_FMT_YUV422P16LE:
    case AV_PIX_FMT_YUV444P16LE:
1069 1070

    case AV_PIX_FMT_YUVA420P9LE:
1071 1072
    case AV_PIX_FMT_YUVA422P9LE:
    case AV_PIX_FMT_YUVA444P9LE:
1073
    case AV_PIX_FMT_YUVA420P10LE:
1074 1075
    case AV_PIX_FMT_YUVA422P10LE:
    case AV_PIX_FMT_YUVA444P10LE:
1076 1077 1078
    case AV_PIX_FMT_YUVA420P16LE:
    case AV_PIX_FMT_YUVA422P16LE:
    case AV_PIX_FMT_YUVA444P16LE:
1079 1080
        c->chrToYV12 = bswap16UV_c;
        break;
1081
#else
1082
    case AV_PIX_FMT_YUV420P9BE:
1083 1084
    case AV_PIX_FMT_YUV422P9BE:
    case AV_PIX_FMT_YUV444P9BE:
1085
    case AV_PIX_FMT_YUV420P10BE:
1086
    case AV_PIX_FMT_YUV422P10BE:
1087
    case AV_PIX_FMT_YUV440P10BE:
1088
    case AV_PIX_FMT_YUV444P10BE:
1089 1090
    case AV_PIX_FMT_YUV420P12BE:
    case AV_PIX_FMT_YUV422P12BE:
1091
    case AV_PIX_FMT_YUV440P12BE:
1092 1093
    case AV_PIX_FMT_YUV444P12BE:
    case AV_PIX_FMT_YUV420P14BE:
1094 1095
    case AV_PIX_FMT_YUV422P14BE:
    case AV_PIX_FMT_YUV444P14BE:
1096 1097 1098
    case AV_PIX_FMT_YUV420P16BE:
    case AV_PIX_FMT_YUV422P16BE:
    case AV_PIX_FMT_YUV444P16BE:
1099 1100

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

    c->lumToYV12 = NULL;
    c->alpToYV12 = NULL;
    switch (srcFormat) {
1299
    case AV_PIX_FMT_GBRP9LE:
1300 1301
        c->readLumPlanar = planar_rgb9le_to_y;
        break;
1302 1303
    case AV_PIX_FMT_GBRAP10LE:
        c->readAlpPlanar = planar_rgb10le_to_a;
1304
    case AV_PIX_FMT_GBRP10LE:
1305 1306
        c->readLumPlanar = planar_rgb10le_to_y;
        break;
1307 1308
    case AV_PIX_FMT_GBRAP12LE:
        c->readAlpPlanar = planar_rgb12le_to_a;
1309
    case AV_PIX_FMT_GBRP12LE:
1310 1311
        c->readLumPlanar = planar_rgb12le_to_y;
        break;
1312
    case AV_PIX_FMT_GBRP14LE:
1313 1314
        c->readLumPlanar = planar_rgb14le_to_y;
        break;
1315
    case AV_PIX_FMT_GBRAP16LE:
1316
        c->readAlpPlanar = planar_rgb16le_to_a;
1317
    case AV_PIX_FMT_GBRP16LE:
1318 1319
        c->readLumPlanar = planar_rgb16le_to_y;
        break;
1320
    case AV_PIX_FMT_GBRP9BE:
1321 1322
        c->readLumPlanar = planar_rgb9be_to_y;
        break;
1323 1324
    case AV_PIX_FMT_GBRAP10BE:
        c->readAlpPlanar = planar_rgb10be_to_a;
1325
    case AV_PIX_FMT_GBRP10BE:
1326 1327
        c->readLumPlanar = planar_rgb10be_to_y;
        break;
1328 1329
    case AV_PIX_FMT_GBRAP12BE:
        c->readAlpPlanar = planar_rgb12be_to_a;
1330
    case AV_PIX_FMT_GBRP12BE:
1331 1332
        c->readLumPlanar = planar_rgb12be_to_y;
        break;
1333
    case AV_PIX_FMT_GBRP14BE:
1334 1335
        c->readLumPlanar = planar_rgb14be_to_y;
        break;
1336
    case AV_PIX_FMT_GBRAP16BE:
1337
        c->readAlpPlanar = planar_rgb16be_to_a;
1338
    case AV_PIX_FMT_GBRP16BE:
1339 1340
        c->readLumPlanar = planar_rgb16be_to_y;
        break;
1341 1342
    case AV_PIX_FMT_GBRAP:
        c->readAlpPlanar = planar_rgb_to_a;
1343
    case AV_PIX_FMT_GBRP:
1344 1345
        c->readLumPlanar = planar_rgb_to_y;
        break;
1346
#if HAVE_BIGENDIAN
1347
    case AV_PIX_FMT_YUV420P9LE:
1348 1349
    case AV_PIX_FMT_YUV422P9LE:
    case AV_PIX_FMT_YUV444P9LE:
1350
    case AV_PIX_FMT_YUV420P10LE:
1351
    case AV_PIX_FMT_YUV422P10LE:
1352
    case AV_PIX_FMT_YUV440P10LE:
1353
    case AV_PIX_FMT_YUV444P10LE:
1354
    case AV_PIX_FMT_YUV420P12LE:
1355 1356 1357
    case AV_PIX_FMT_YUV422P12LE:
    case AV_PIX_FMT_YUV440P12LE:
    case AV_PIX_FMT_YUV444P12LE:
1358
    case AV_PIX_FMT_YUV420P14LE:
1359 1360
    case AV_PIX_FMT_YUV422P14LE:
    case AV_PIX_FMT_YUV444P14LE:
1361 1362 1363
    case AV_PIX_FMT_YUV420P16LE:
    case AV_PIX_FMT_YUV422P16LE:
    case AV_PIX_FMT_YUV444P16LE:
1364

1365
    case AV_PIX_FMT_GRAY9LE:
1366
    case AV_PIX_FMT_GRAY10LE:
Luca Barbato's avatar
Luca Barbato committed
1367
    case AV_PIX_FMT_GRAY12LE:
1368
    case AV_PIX_FMT_GRAY16LE:
1369 1370

    case AV_PIX_FMT_P016LE:
1371 1372
        c->lumToYV12 = bswap16Y_c;
        break;
1373
    case AV_PIX_FMT_YUVA420P9LE:
1374 1375
    case AV_PIX_FMT_YUVA422P9LE:
    case AV_PIX_FMT_YUVA444P9LE:
1376
    case AV_PIX_FMT_YUVA420P10LE:
1377 1378
    case AV_PIX_FMT_YUVA422P10LE:
    case AV_PIX_FMT_YUVA444P10LE:
1379 1380 1381
    case AV_PIX_FMT_YUVA420P16LE:
    case AV_PIX_FMT_YUVA422P16LE:
    case AV_PIX_FMT_YUVA444P16LE:
1382
        c->lumToYV12 = bswap16Y_c;
1383
        c->alpToYV12 = bswap16Y_c;
1384
        break;
1385
#else
1386
    case AV_PIX_FMT_YUV420P9BE:
1387 1388
    case AV_PIX_FMT_YUV422P9BE:
    case AV_PIX_FMT_YUV444P9BE:
1389
    case AV_PIX_FMT_YUV420P10BE:
1390
    case AV_PIX_FMT_YUV422P10BE:
1391
    case AV_PIX_FMT_YUV440P10BE:
1392
    case AV_PIX_FMT_YUV444P10BE:
1393
    case AV_PIX_FMT_YUV420P12BE:
1394 1395 1396
    case AV_PIX_FMT_YUV422P12BE:
    case AV_PIX_FMT_YUV440P12BE:
    case AV_PIX_FMT_YUV444P12BE:
1397
    case AV_PIX_FMT_YUV420P14BE:
1398 1399
    case AV_PIX_FMT_YUV422P14BE:
    case AV_PIX_FMT_YUV444P14BE:
1400 1401 1402
    case AV_PIX_FMT_YUV420P16BE:
    case AV_PIX_FMT_YUV422P16BE:
    case AV_PIX_FMT_YUV444P16BE:
1403

1404
    case AV_PIX_FMT_GRAY9BE:
1405
    case AV_PIX_FMT_GRAY10BE:
Luca Barbato's avatar
Luca Barbato committed
1406
    case AV_PIX_FMT_GRAY12BE:
1407
    case AV_PIX_FMT_GRAY16BE:
1408 1409

    case AV_PIX_FMT_P016BE:
1410 1411
        c->lumToYV12 = bswap16Y_c;
        break;
1412
    case AV_PIX_FMT_YUVA420P9BE:
1413 1414
    case AV_PIX_FMT_YUVA422P9BE:
    case AV_PIX_FMT_YUVA444P9BE:
1415
    case AV_PIX_FMT_YUVA420P10BE:
1416 1417
    case AV_PIX_FMT_YUVA422P10BE:
    case AV_PIX_FMT_YUVA444P10BE:
1418 1419 1420
    case AV_PIX_FMT_YUVA420P16BE:
    case AV_PIX_FMT_YUVA422P16BE:
    case AV_PIX_FMT_YUVA444P16BE:
1421
        c->lumToYV12 = bswap16Y_c;
1422
        c->alpToYV12 = bswap16Y_c;
1423
        break;
1424
#endif
1425 1426 1427 1428 1429 1430
    case AV_PIX_FMT_YA16LE:
        c->lumToYV12 = read_ya16le_gray_c;
        break;
    case AV_PIX_FMT_YA16BE:
        c->lumToYV12 = read_ya16be_gray_c;
        break;
1431 1432 1433
    case AV_PIX_FMT_AYUV64LE:
        c->lumToYV12 = read_ayuv64le_Y_c;
        break;
1434
    case AV_PIX_FMT_YUYV422:
1435
    case AV_PIX_FMT_YVYU422:
1436
    case AV_PIX_FMT_YA8:
1437 1438
        c->lumToYV12 = yuy2ToY_c;
        break;
1439
    case AV_PIX_FMT_UYVY422:
1440 1441
        c->lumToYV12 = uyvyToY_c;
        break;
1442
    case AV_PIX_FMT_BGR24:
1443 1444
        c->lumToYV12 = bgr24ToY_c;
        break;
1445
    case AV_PIX_FMT_BGR565LE:
1446 1447
        c->lumToYV12 = bgr16leToY_c;
        break;
1448
    case AV_PIX_FMT_BGR565BE:
1449 1450
        c->lumToYV12 = bgr16beToY_c;
        break;
1451
    case AV_PIX_FMT_BGR555LE:
1452 1453
        c->lumToYV12 = bgr15leToY_c;
        break;
1454
    case AV_PIX_FMT_BGR555BE:
1455 1456
        c->lumToYV12 = bgr15beToY_c;
        break;
1457
    case AV_PIX_FMT_BGR444LE:
1458 1459
        c->lumToYV12 = bgr12leToY_c;
        break;
1460
    case AV_PIX_FMT_BGR444BE:
1461 1462
        c->lumToYV12 = bgr12beToY_c;
        break;
1463
    case AV_PIX_FMT_RGB24:
1464 1465
        c->lumToYV12 = rgb24ToY_c;
        break;
1466
    case AV_PIX_FMT_RGB565LE:
1467 1468
        c->lumToYV12 = rgb16leToY_c;
        break;
1469
    case AV_PIX_FMT_RGB565BE:
1470 1471
        c->lumToYV12 = rgb16beToY_c;
        break;
1472
    case AV_PIX_FMT_RGB555LE:
1473 1474
        c->lumToYV12 = rgb15leToY_c;
        break;
1475
    case AV_PIX_FMT_RGB555BE:
1476 1477
        c->lumToYV12 = rgb15beToY_c;
        break;
1478
    case AV_PIX_FMT_RGB444LE:
1479 1480
        c->lumToYV12 = rgb12leToY_c;
        break;
1481
    case AV_PIX_FMT_RGB444BE:
1482 1483
        c->lumToYV12 = rgb12beToY_c;
        break;
1484 1485 1486 1487 1488
    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:
1489 1490
        c->lumToYV12 = palToY_c;
        break;
1491
    case AV_PIX_FMT_MONOBLACK:
1492 1493
        c->lumToYV12 = monoblack2Y_c;
        break;
1494
    case AV_PIX_FMT_MONOWHITE:
1495 1496
        c->lumToYV12 = monowhite2Y_c;
        break;
1497
    case AV_PIX_FMT_RGB32:
1498 1499
        c->lumToYV12 = bgr32ToY_c;
        break;
1500
    case AV_PIX_FMT_RGB32_1:
1501 1502
        c->lumToYV12 = bgr321ToY_c;
        break;
1503
    case AV_PIX_FMT_BGR32:
1504 1505
        c->lumToYV12 = rgb32ToY_c;
        break;
1506
    case AV_PIX_FMT_BGR32_1:
1507 1508
        c->lumToYV12 = rgb321ToY_c;
        break;
1509
    case AV_PIX_FMT_RGB48BE:
1510 1511
        c->lumToYV12 = rgb48BEToY_c;
        break;
1512
    case AV_PIX_FMT_RGB48LE:
1513 1514
        c->lumToYV12 = rgb48LEToY_c;
        break;
1515
    case AV_PIX_FMT_BGR48BE:
1516 1517
        c->lumToYV12 = bgr48BEToY_c;
        break;
1518
    case AV_PIX_FMT_BGR48LE:
1519 1520
        c->lumToYV12 = bgr48LEToY_c;
        break;
1521
    case AV_PIX_FMT_RGBA64BE:
1522 1523
        c->lumToYV12 = rgb64BEToY_c;
        break;
1524
    case AV_PIX_FMT_RGBA64LE:
1525 1526
        c->lumToYV12 = rgb64LEToY_c;
        break;
1527 1528 1529 1530 1531
    case AV_PIX_FMT_BGRA64BE:
        c->lumToYV12 = bgr64BEToY_c;
        break;
    case AV_PIX_FMT_BGRA64LE:
        c->lumToYV12 = bgr64LEToY_c;
1532 1533 1534 1535 1536 1537 1538
        break;
    case AV_PIX_FMT_P010LE:
        c->lumToYV12 = p010LEToY_c;
        break;
    case AV_PIX_FMT_P010BE:
        c->lumToYV12 = p010BEToY_c;
        break;
1539
    }
1540
    if (c->needAlpha) {
1541
        if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1542
            if (HAVE_BIGENDIAN == !isBE(srcFormat) && !c->readAlpPlanar)
1543 1544
                c->alpToYV12 = bswap16Y_c;
        }
1545
        switch (srcFormat) {
1546
        case AV_PIX_FMT_BGRA64LE:
1547
        case AV_PIX_FMT_RGBA64LE:  c->alpToYV12 = rgba64leToA_c; break;
1548
        case AV_PIX_FMT_BGRA64BE:
1549
        case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64beToA_c; break;
1550 1551
        case AV_PIX_FMT_BGRA:
        case AV_PIX_FMT_RGBA:
1552 1553
            c->alpToYV12 = rgbaToA_c;
            break;
1554 1555
        case AV_PIX_FMT_ABGR:
        case AV_PIX_FMT_ARGB:
1556 1557
            c->alpToYV12 = abgrToA_c;
            break;
1558
        case AV_PIX_FMT_YA8:
1559 1560
            c->alpToYV12 = uyvyToY_c;
            break;
1561 1562 1563 1564 1565 1566
        case AV_PIX_FMT_YA16LE:
            c->alpToYV12 = read_ya16le_alpha_c;
            break;
        case AV_PIX_FMT_YA16BE:
            c->alpToYV12 = read_ya16be_alpha_c;
            break;
1567 1568 1569
        case AV_PIX_FMT_AYUV64LE:
            c->alpToYV12 = read_ayuv64le_A_c;
            break;
1570
        case AV_PIX_FMT_PAL8 :
1571 1572
            c->alpToYV12 = palToA_c;
            break;
1573 1574 1575
        }
    }
}