swscale_unscaled.c 54.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*
 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of Libav.
 *
 * Libav is free software; you can redistribute it and/or
 * 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.
 *
 * Libav is distributed in the hope that it will be useful,
 * 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
 * License along with Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <inttypes.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include "config.h"
#include <assert.h>
#include "swscale.h"
#include "swscale_internal.h"
#include "rgb2rgb.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/cpu.h"
#include "libavutil/avutil.h"
#include "libavutil/mathematics.h"
#include "libavutil/bswap.h"
#include "libavutil/pixdesc.h"

37
DECLARE_ALIGNED(8, static const uint8_t, dither_8x8_1)[8][8] = {
38 39 40 41 42 43 44 45 46
    {   0,  1,  0,  1,  0,  1,  0,  1,},
    {   1,  0,  1,  0,  1,  0,  1,  0,},
    {   0,  1,  0,  1,  0,  1,  0,  1,},
    {   1,  0,  1,  0,  1,  0,  1,  0,},
    {   0,  1,  0,  1,  0,  1,  0,  1,},
    {   1,  0,  1,  0,  1,  0,  1,  0,},
    {   0,  1,  0,  1,  0,  1,  0,  1,},
    {   1,  0,  1,  0,  1,  0,  1,  0,},
};
47
DECLARE_ALIGNED(8, static const uint8_t, dither_8x8_3)[8][8] = {
48 49 50 51 52 53 54 55 56
    {   1,  2,  1,  2,  1,  2,  1,  2,},
    {   3,  0,  3,  0,  3,  0,  3,  0,},
    {   1,  2,  1,  2,  1,  2,  1,  2,},
    {   3,  0,  3,  0,  3,  0,  3,  0,},
    {   1,  2,  1,  2,  1,  2,  1,  2,},
    {   3,  0,  3,  0,  3,  0,  3,  0,},
    {   1,  2,  1,  2,  1,  2,  1,  2,},
    {   3,  0,  3,  0,  3,  0,  3,  0,},
};
57
DECLARE_ALIGNED(8, static const uint8_t, dither_8x8_64)[8][8] = {
58 59 60 61 62 63 64 65 66
    {  18, 34, 30, 46, 17, 33, 29, 45,},
    {  50,  2, 62, 14, 49,  1, 61, 13,},
    {  26, 42, 22, 38, 25, 41, 21, 37,},
    {  58, 10, 54,  6, 57,  9, 53,  5,},
    {  16, 32, 28, 44, 19, 35, 31, 47,},
    {  48,  0, 60, 12, 51,  3, 63, 15,},
    {  24, 40, 20, 36, 27, 43, 23, 39,},
    {  56,  8, 52,  4, 59, 11, 55,  7,},
};
67
DECLARE_ALIGNED(8, static const uint8_t, dither_8x8_256)[8][8] = {
68 69 70 71 72 73 74 75 76 77
    {  72, 136, 120, 184,  68, 132, 116, 180,},
    { 200,   8, 248,  56, 196,   4, 244,  52,},
    { 104, 168,  88, 152, 100, 164,  84, 148,},
    { 232,  40, 216,  24, 228,  36, 212,  20,},
    {  64, 128, 102, 176,  76, 140, 124, 188,},
    { 192,   0, 240,  48, 204,  12, 252,  60,},
    {  96, 160,  80, 144, 108, 172,  92, 156,},
    { 224,  32, 208,  16, 236,  44, 220,  28,},
};

78
#define RGB2YUV_SHIFT 15
79 80 81 82 83 84 85 86 87 88 89 90
#define BY ( (int) (0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define BV (-(int) (0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define BU ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define GY ( (int) (0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define GV (-(int) (0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define GU (-(int) (0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define RY ( (int) (0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define RV ( (int) (0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
#define RU (-(int) (0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))

static void fillPlane(uint8_t *plane, int stride, int width, int height, int y,
                      uint8_t val)
91 92
{
    int i;
93 94
    uint8_t *ptr = plane + stride * y;
    for (i = 0; i < height; i++) {
95 96 97 98 99
        memset(ptr, val, width);
        ptr += stride;
    }
}

100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
static void fill_plane9or10(uint8_t *plane, int stride, int width,
                            int height, int y, uint8_t val,
                            const int dst_depth, const int big_endian)
{
    int i, j;
    uint16_t *dst = (uint16_t *) (plane + stride * y);
#define FILL8TO9_OR_10(wfunc) \
    for (i = 0; i < height; i++) { \
        for (j = 0; j < width; j++) { \
            wfunc(&dst[j], (val << (dst_depth - 8)) |  \
                               (val >> (16 - dst_depth))); \
        } \
        dst += stride / 2; \
    }
    if (big_endian) {
        FILL8TO9_OR_10(AV_WB16);
    } else {
        FILL8TO9_OR_10(AV_WL16);
    }
}

121 122 123 124 125 126 127 128 129
static void copyPlane(const uint8_t *src, int srcStride,
                      int srcSliceY, int srcSliceH, int width,
                      uint8_t *dst, int dstStride)
{
    dst += dstStride * srcSliceY;
    if (dstStride == srcStride && srcStride > 0) {
        memcpy(dst, src, srcSliceH * dstStride);
    } else {
        int i;
130
        for (i = 0; i < srcSliceH; i++) {
131 132 133 134 135 136 137
            memcpy(dst, src, width);
            src += srcStride;
            dst += dstStride;
        }
    }
}

138 139 140 141
static int planarToNv12Wrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY,
                               int srcSliceH, uint8_t *dstParam[],
                               int dstStride[])
142
{
143
    uint8_t *dst = dstParam[1] + dstStride[1] * srcSliceY / 2;
144 145 146 147

    copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
              dstParam[0], dstStride[0]);

148
    if (c->dstFormat == AV_PIX_FMT_NV12)
149
        interleaveBytes(src[1], src[2], dst, c->srcW / 2, srcSliceH / 2,
150
                        srcStride[1], srcStride[2], dstStride[1]);
151
    else
152
        interleaveBytes(src[2], src[1], dst, c->srcW / 2, srcSliceH / 2,
153
                        srcStride[2], srcStride[1], dstStride[1]);
154 155 156 157

    return srcSliceH;
}

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
static int nv12ToPlanarWrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY,
                               int srcSliceH, uint8_t *dstParam[],
                               int dstStride[])
{
    uint8_t *dst1 = dstParam[1] + dstStride[1] * srcSliceY / 2;
    uint8_t *dst2 = dstParam[2] + dstStride[2] * srcSliceY / 2;

    copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
              dstParam[0], dstStride[0]);

    if (c->srcFormat == AV_PIX_FMT_NV12)
        deinterleaveBytes(src[1], dst1, dst2,c->srcW / 2, srcSliceH / 2,
                          srcStride[1], dstStride[1], dstStride[2]);
    else
        deinterleaveBytes(src[1], dst2, dst1, c->srcW / 2, srcSliceH / 2,
                          srcStride[1], dstStride[2], dstStride[1]);

    return srcSliceH;
}

179 180 181
static int planarToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY, int srcSliceH,
                               uint8_t *dstParam[], int dstStride[])
182
{
183
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
184

185 186
    yv12toyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
               srcStride[1], dstStride[0]);
187 188 189 190

    return srcSliceH;
}

191 192 193
static int planarToUyvyWrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY, int srcSliceH,
                               uint8_t *dstParam[], int dstStride[])
194
{
195
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
196

197 198
    yv12touyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
               srcStride[1], dstStride[0]);
199 200 201 202

    return srcSliceH;
}

203 204 205
static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t *src[],
                                int srcStride[], int srcSliceY, int srcSliceH,
                                uint8_t *dstParam[], int dstStride[])
206
{
207
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
208

209 210
    yuv422ptoyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
                  srcStride[1], dstStride[0]);
211 212 213 214

    return srcSliceH;
}

215 216 217
static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t *src[],
                                int srcStride[], int srcSliceY, int srcSliceH,
                                uint8_t *dstParam[], int dstStride[])
218
{
219
    uint8_t *dst = dstParam[0] + dstStride[0] * srcSliceY;
220

221 222
    yuv422ptouyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0],
                  srcStride[1], dstStride[0]);
223 224 225 226

    return srcSliceH;
}

227 228 229
static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY, int srcSliceH,
                               uint8_t *dstParam[], int dstStride[])
230
{
231 232 233
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
234

235 236
    yuyvtoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
                 dstStride[1], srcStride[0]);
237 238 239 240 241 242 243

    if (dstParam[3])
        fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);

    return srcSliceH;
}

244 245 246
static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY, int srcSliceH,
                               uint8_t *dstParam[], int dstStride[])
247
{
248 249 250
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
251

252 253
    yuyvtoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
                 dstStride[1], srcStride[0]);
254 255 256 257

    return srcSliceH;
}

258 259 260
static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY, int srcSliceH,
                               uint8_t *dstParam[], int dstStride[])
261
{
262 263 264
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY / 2;
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY / 2;
265

266 267
    uyvytoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
                 dstStride[1], srcStride[0]);
268 269 270 271 272 273 274

    if (dstParam[3])
        fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);

    return srcSliceH;
}

275 276 277
static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t *src[],
                               int srcStride[], int srcSliceY, int srcSliceH,
                               uint8_t *dstParam[], int dstStride[])
278
{
279 280 281
    uint8_t *ydst = dstParam[0] + dstStride[0] * srcSliceY;
    uint8_t *udst = dstParam[1] + dstStride[1] * srcSliceY;
    uint8_t *vdst = dstParam[2] + dstStride[2] * srcSliceY;
282

283 284
    uyvytoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0],
                 dstStride[1], srcStride[0]);
285 286 287 288

    return srcSliceH;
}

289 290
static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels,
                             const uint8_t *palette)
291 292
{
    int i;
293 294
    for (i = 0; i < num_pixels; i++)
        ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | (src[(i << 1) + 1] << 24);
295 296
}

297 298
static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels,
                               const uint8_t *palette)
299 300 301
{
    int i;

302 303
    for (i = 0; i < num_pixels; i++)
        ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i << 1]] | src[(i << 1) + 1];
304 305
}

306 307
static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels,
                             const uint8_t *palette)
308 309 310
{
    int i;

311
    for (i = 0; i < num_pixels; i++) {
312
        //FIXME slow?
313 314 315 316
        dst[0] = palette[src[i << 1] * 4 + 0];
        dst[1] = palette[src[i << 1] * 4 + 1];
        dst[2] = palette[src[i << 1] * 4 + 2];
        dst += 3;
317 318 319
    }
}

320
static int packed_16bpc_bswap(SwsContext *c, const uint8_t *src[],
321
                              int srcStride[], int srcSliceY, int srcSliceH,
322
                              uint8_t *dst[], int dstStride[])
323 324 325 326
{
    int i, j;
    int srcstr = srcStride[0] >> 1;
    int dststr = dstStride[0] >> 1;
327 328
    uint16_t       *dstPtr =       (uint16_t *) dst[0];
    const uint16_t *srcPtr = (const uint16_t *) src[0];
329
    int min_stride         = FFMIN(srcstr, dststr);
330 331

    for (i = 0; i < srcSliceH; i++) {
332
        for (j = 0; j < min_stride; j++) {
333 334 335 336 337 338 339 340 341
            dstPtr[j] = av_bswap16(srcPtr[j]);
        }
        srcPtr += srcstr;
        dstPtr += dststr;
    }

    return srcSliceH;
}

342 343 344
static int palToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
                           int srcSliceY, int srcSliceH, uint8_t *dst[],
                           int dstStride[])
345
{
346 347
    const enum AVPixelFormat srcFormat = c->srcFormat;
    const enum AVPixelFormat dstFormat = c->dstFormat;
348
    void (*conv)(const uint8_t *src, uint8_t *dst, int num_pixels,
349
                 const uint8_t *palette) = NULL;
350
    int i;
351 352
    uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
    const uint8_t *srcPtr = src[0];
353

354
    if (srcFormat == AV_PIX_FMT_YA8) {
355
        switch (dstFormat) {
356 357 358 359 360 361
        case AV_PIX_FMT_RGB32  : conv = gray8aToPacked32; break;
        case AV_PIX_FMT_BGR32  : conv = gray8aToPacked32; break;
        case AV_PIX_FMT_BGR32_1: conv = gray8aToPacked32_1; break;
        case AV_PIX_FMT_RGB32_1: conv = gray8aToPacked32_1; break;
        case AV_PIX_FMT_RGB24  : conv = gray8aToPacked24; break;
        case AV_PIX_FMT_BGR24  : conv = gray8aToPacked24; break;
362 363 364
        }
    } else if (usePal(srcFormat)) {
        switch (dstFormat) {
365 366 367 368 369 370
        case AV_PIX_FMT_RGB32  : conv = sws_convertPalette8ToPacked32; break;
        case AV_PIX_FMT_BGR32  : conv = sws_convertPalette8ToPacked32; break;
        case AV_PIX_FMT_BGR32_1: conv = sws_convertPalette8ToPacked32; break;
        case AV_PIX_FMT_RGB32_1: conv = sws_convertPalette8ToPacked32; break;
        case AV_PIX_FMT_RGB24  : conv = sws_convertPalette8ToPacked24; break;
        case AV_PIX_FMT_BGR24  : conv = sws_convertPalette8ToPacked24; break;
371 372 373 374 375 376 377
        }
    }

    if (!conv)
        av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
               sws_format_name(srcFormat), sws_format_name(dstFormat));
    else {
378
        for (i = 0; i < srcSliceH; i++) {
379
            conv(srcPtr, dstPtr, c->srcW, (uint8_t *) c->pal_rgb);
380 381
            srcPtr += srcStride[0];
            dstPtr += dstStride[0];
382 383 384 385 386 387
        }
    }

    return srcSliceH;
}

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
static void gbr24ptopacked24(const uint8_t *src[], int srcStride[],
                             uint8_t *dst, int dstStride, int srcSliceH,
                             int width)
{
    int x, h, i;
    for (h = 0; h < srcSliceH; h++) {
        uint8_t *dest = dst + dstStride * h;
        for (x = 0; x < width; x++) {
            *dest++ = src[0][x];
            *dest++ = src[1][x];
            *dest++ = src[2][x];
        }

        for (i = 0; i < 3; i++)
            src[i] += srcStride[i];
    }
}

static void gbr24ptopacked32(const uint8_t *src[], int srcStride[],
                             uint8_t *dst, int dstStride, int srcSliceH,
                             int alpha_first, int width)
{
    int x, h, i;
    for (h = 0; h < srcSliceH; h++) {
        uint8_t *dest = dst + dstStride * h;

        if (alpha_first) {
            for (x = 0; x < width; x++) {
                *dest++ = 0xff;
                *dest++ = src[0][x];
                *dest++ = src[1][x];
                *dest++ = src[2][x];
            }
        } else {
            for (x = 0; x < width; x++) {
                *dest++ = src[0][x];
                *dest++ = src[1][x];
                *dest++ = src[2][x];
                *dest++ = 0xff;
            }
        }

        for (i = 0; i < 3; i++)
            src[i] += srcStride[i];
    }
}

static int planarRgbToRgbWrapper(SwsContext *c, const uint8_t *src[],
                                 int srcStride[], int srcSliceY, int srcSliceH,
                                 uint8_t *dst[], int dstStride[])
{
    int alpha_first = 0;
440 441 442 443 444
    const uint8_t *src102[] = { src[1], src[0], src[2] };
    const uint8_t *src201[] = { src[2], src[0], src[1] };
    int stride102[] = { srcStride[1], srcStride[0], srcStride[2] };
    int stride201[] = { srcStride[2], srcStride[0], srcStride[1] };

445
    if (c->srcFormat != AV_PIX_FMT_GBRP) {
446 447 448 449 450 451 452
        av_log(c, AV_LOG_ERROR, "unsupported planar RGB conversion %s -> %s\n",
               av_get_pix_fmt_name(c->srcFormat),
               av_get_pix_fmt_name(c->dstFormat));
        return srcSliceH;
    }

    switch (c->dstFormat) {
453
    case AV_PIX_FMT_BGR24:
454
        gbr24ptopacked24(src102, stride102,
455 456 457 458
                         dst[0] + srcSliceY * dstStride[0], dstStride[0],
                         srcSliceH, c->srcW);
        break;

459
    case AV_PIX_FMT_RGB24:
460
        gbr24ptopacked24(src201, stride201,
461 462 463 464
                         dst[0] + srcSliceY * dstStride[0], dstStride[0],
                         srcSliceH, c->srcW);
        break;

465
    case AV_PIX_FMT_ARGB:
466
        alpha_first = 1;
467
    case AV_PIX_FMT_RGBA:
468
        gbr24ptopacked32(src201, stride201,
469 470 471 472
                         dst[0] + srcSliceY * dstStride[0], dstStride[0],
                         srcSliceH, alpha_first, c->srcW);
        break;

473
    case AV_PIX_FMT_ABGR:
474
        alpha_first = 1;
475
    case AV_PIX_FMT_BGRA:
476
        gbr24ptopacked32(src102, stride102,
477 478 479 480 481 482 483 484 485 486 487 488 489 490
                         dst[0] + srcSliceY * dstStride[0], dstStride[0],
                         srcSliceH, alpha_first, c->srcW);
        break;

    default:
        av_log(c, AV_LOG_ERROR,
               "unsupported planar RGB conversion %s -> %s\n",
               av_get_pix_fmt_name(c->srcFormat),
               av_get_pix_fmt_name(c->dstFormat));
    }

    return srcSliceH;
}

491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
static int planarRgbToplanarRgbWrapper(SwsContext *c,
                                       const uint8_t *src[], int srcStride[],
                                       int srcSliceY, int srcSliceH,
                                       uint8_t *dst[], int dstStride[])
{
    copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
              dst[0], dstStride[0]);
    copyPlane(src[1], srcStride[1], srcSliceY, srcSliceH, c->srcW,
              dst[1], dstStride[1]);
    copyPlane(src[2], srcStride[2], srcSliceY, srcSliceH, c->srcW,
              dst[2], dstStride[2]);
    if (dst[3])
        fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);

    return srcSliceH;
}

508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
static void packedtogbr24p(const uint8_t *src, int srcStride,
                           uint8_t *dst[], int dstStride[], int srcSliceH,
                           int alpha_first, int inc_size, int width)
{
    uint8_t *dest[3];
    int x, h;

    dest[0] = dst[0];
    dest[1] = dst[1];
    dest[2] = dst[2];

    if (alpha_first)
        src++;

    for (h = 0; h < srcSliceH; h++) {
        for (x = 0; x < width; x++) {
            dest[0][x] = src[0];
            dest[1][x] = src[1];
            dest[2][x] = src[2];

            src += inc_size;
        }
        src     += srcStride - width * inc_size;
        dest[0] += dstStride[0];
        dest[1] += dstStride[1];
        dest[2] += dstStride[2];
    }
}

static int rgbToPlanarRgbWrapper(SwsContext *c, const uint8_t *src[],
                                 int srcStride[], int srcSliceY, int srcSliceH,
                                 uint8_t *dst[], int dstStride[])
{
    int alpha_first = 0;
    int stride102[] = { dstStride[1], dstStride[0], dstStride[2] };
    int stride201[] = { dstStride[2], dstStride[0], dstStride[1] };
    uint8_t *dst102[] = { dst[1] + srcSliceY * dstStride[1],
                          dst[0] + srcSliceY * dstStride[0],
                          dst[2] + srcSliceY * dstStride[2] };
    uint8_t *dst201[] = { dst[2] + srcSliceY * dstStride[2],
                          dst[0] + srcSliceY * dstStride[0],
                          dst[1] + srcSliceY * dstStride[1] };

    switch (c->srcFormat) {
552
    case AV_PIX_FMT_RGB24:
553 554 555
        packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst201,
                       stride201, srcSliceH, alpha_first, 3, c->srcW);
        break;
556
    case AV_PIX_FMT_BGR24:
557 558 559
        packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst102,
                       stride102, srcSliceH, alpha_first, 3, c->srcW);
        break;
560
    case AV_PIX_FMT_ARGB:
561
        alpha_first = 1;
562
    case AV_PIX_FMT_RGBA:
563 564 565
        packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst201,
                       stride201, srcSliceH, alpha_first, 4, c->srcW);
        break;
566
    case AV_PIX_FMT_ABGR:
567
        alpha_first = 1;
568
    case AV_PIX_FMT_BGRA:
569 570 571 572 573 574 575 576 577 578 579 580 581
        packedtogbr24p((const uint8_t *) src[0], srcStride[0], dst102,
                       stride102, srcSliceH, alpha_first, 4, c->srcW);
        break;
    default:
        av_log(c, AV_LOG_ERROR,
               "unsupported planar RGB conversion %s -> %s\n",
               av_get_pix_fmt_name(c->srcFormat),
               av_get_pix_fmt_name(c->dstFormat));
    }

    return srcSliceH;
}

582
#define isRGBA32(x) (            \
583 584 585 586
           (x) == AV_PIX_FMT_ARGB   \
        || (x) == AV_PIX_FMT_RGBA   \
        || (x) == AV_PIX_FMT_BGRA   \
        || (x) == AV_PIX_FMT_ABGR   \
587 588 589
        )

/* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
590 591
typedef void (* rgbConvFn) (const uint8_t *, uint8_t *, int);
static rgbConvFn findRgbConvFn(SwsContext *c)
592
{
593 594
    const enum AVPixelFormat srcFormat = c->srcFormat;
    const enum AVPixelFormat dstFormat = c->dstFormat;
595 596
    const int srcId = c->srcFormatBpp;
    const int dstId = c->dstFormatBpp;
597
    rgbConvFn conv = NULL;
598 599
    const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(srcFormat);
    const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(dstFormat);
600

601
#define IS_NOT_NE(bpp, desc) \
602
    (((bpp + 7) >> 3) == 2 && \
603
     (!(desc->flags & AV_PIX_FMT_FLAG_BE) != !HAVE_BIGENDIAN))
604 605

    /* if this is non-native rgb444/555/565, don't handle it here. */
606
    if (IS_NOT_NE(srcId, desc_src) || IS_NOT_NE(dstId, desc_dst))
607
        return NULL;
608

609
#define CONV_IS(src, dst) (srcFormat == AV_PIX_FMT_##src && dstFormat == AV_PIX_FMT_##dst)
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625

    if (isRGBA32(srcFormat) && isRGBA32(dstFormat)) {
        if (     CONV_IS(ABGR, RGBA)
              || CONV_IS(ARGB, BGRA)
              || CONV_IS(BGRA, ARGB)
              || CONV_IS(RGBA, ABGR)) conv = shuffle_bytes_3210;
        else if (CONV_IS(ABGR, ARGB)
              || CONV_IS(ARGB, ABGR)) conv = shuffle_bytes_0321;
        else if (CONV_IS(ABGR, BGRA)
              || CONV_IS(ARGB, RGBA)) conv = shuffle_bytes_1230;
        else if (CONV_IS(BGRA, RGBA)
              || CONV_IS(RGBA, BGRA)) conv = shuffle_bytes_2103;
        else if (CONV_IS(BGRA, ABGR)
              || CONV_IS(RGBA, ARGB)) conv = shuffle_bytes_3012;
    } else
    /* BGR -> BGR */
626 627
    if ((isBGRinInt(srcFormat) && isBGRinInt(dstFormat)) ||
        (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
628
        switch (srcId | (dstId << 16)) {
Paul B Mahol's avatar
Paul B Mahol committed
629
        case 0x000F000C: conv = rgb12to15; break;
630 631 632 633 634 635 636 637 638 639 640 641
        case 0x000F0010: conv = rgb16to15; break;
        case 0x000F0018: conv = rgb24to15; break;
        case 0x000F0020: conv = rgb32to15; break;
        case 0x0010000F: conv = rgb15to16; break;
        case 0x00100018: conv = rgb24to16; break;
        case 0x00100020: conv = rgb32to16; break;
        case 0x0018000F: conv = rgb15to24; break;
        case 0x00180010: conv = rgb16to24; break;
        case 0x00180020: conv = rgb32to24; break;
        case 0x0020000F: conv = rgb15to32; break;
        case 0x00200010: conv = rgb16to32; break;
        case 0x00200018: conv = rgb24to32; break;
642
        }
643 644
    } else if ((isBGRinInt(srcFormat) && isRGBinInt(dstFormat)) ||
               (isRGBinInt(srcFormat) && isBGRinInt(dstFormat))) {
645
        switch (srcId | (dstId << 16)) {
Paul B Mahol's avatar
Paul B Mahol committed
646
        case 0x000C000C: conv = rgb12tobgr12; break;
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
        case 0x000F000F: conv = rgb15tobgr15; break;
        case 0x000F0010: conv = rgb16tobgr15; break;
        case 0x000F0018: conv = rgb24tobgr15; break;
        case 0x000F0020: conv = rgb32tobgr15; break;
        case 0x0010000F: conv = rgb15tobgr16; break;
        case 0x00100010: conv = rgb16tobgr16; break;
        case 0x00100018: conv = rgb24tobgr16; break;
        case 0x00100020: conv = rgb32tobgr16; break;
        case 0x0018000F: conv = rgb15tobgr24; break;
        case 0x00180010: conv = rgb16tobgr24; break;
        case 0x00180018: conv = rgb24tobgr24; break;
        case 0x00180020: conv = rgb32tobgr24; break;
        case 0x0020000F: conv = rgb15tobgr32; break;
        case 0x00200010: conv = rgb16tobgr32; break;
        case 0x00200018: conv = rgb24tobgr32; break;
662 663 664
        }
    }

665 666 667 668 669 670 671 672 673
    return conv;
}

/* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
static int rgbToRgbWrapper(SwsContext *c, const uint8_t *src[], int srcStride[],
                           int srcSliceY, int srcSliceH, uint8_t *dst[],
                           int dstStride[])

{
674 675
    const enum AVPixelFormat srcFormat = c->srcFormat;
    const enum AVPixelFormat dstFormat = c->dstFormat;
676 677 678 679
    const int srcBpp = (c->srcFormatBpp + 7) >> 3;
    const int dstBpp = (c->dstFormatBpp + 7) >> 3;
    rgbConvFn conv = findRgbConvFn(c);

680 681 682 683
    if (!conv) {
        av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
               sws_format_name(srcFormat), sws_format_name(dstFormat));
    } else {
684 685
        const uint8_t *srcPtr = src[0];
              uint8_t *dstPtr = dst[0];
686
        if ((srcFormat == AV_PIX_FMT_RGB32_1 || srcFormat == AV_PIX_FMT_BGR32_1) &&
687
            !isRGBA32(dstFormat))
688 689
            srcPtr += ALT32_CORR;

690
        if ((dstFormat == AV_PIX_FMT_RGB32_1 || dstFormat == AV_PIX_FMT_BGR32_1) &&
691
            !isRGBA32(srcFormat))
692 693
            dstPtr += ALT32_CORR;

694 695 696
        if (dstStride[0] * srcBpp == srcStride[0] * dstBpp && srcStride[0] > 0 &&
            !(srcStride[0] % srcBpp))
            conv(srcPtr, dstPtr + dstStride[0] * srcSliceY,
697
                 (srcSliceH - 1) * srcStride[0] + c->srcW * srcBpp);
698 699
        else {
            int i;
700
            dstPtr += dstStride[0] * srcSliceY;
701

702 703 704 705
            for (i = 0; i < srcSliceH; i++) {
                conv(srcPtr, dstPtr, c->srcW * srcBpp);
                srcPtr += srcStride[0];
                dstPtr += dstStride[0];
706 707 708 709 710 711
            }
        }
    }
    return srcSliceH;
}

712 713 714
static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
                              int srcStride[], int srcSliceY, int srcSliceH,
                              uint8_t *dst[], int dstStride[])
715 716 717
{
    rgb24toyv12(
        src[0],
718 719 720
        dst[0] +  srcSliceY       * dstStride[0],
        dst[1] + (srcSliceY >> 1) * dstStride[1],
        dst[2] + (srcSliceY >> 1) * dstStride[2],
721 722 723 724 725 726 727
        c->srcW, srcSliceH,
        dstStride[0], dstStride[1], srcStride[0]);
    if (dst[3])
        fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
    return srcSliceH;
}

728 729 730
static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t *src[],
                             int srcStride[], int srcSliceY, int srcSliceH,
                             uint8_t *dst[], int dstStride[])
731 732 733 734
{
    copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
              dst[0], dstStride[0]);

735
    planar2x(src[1], dst[1] + dstStride[1] * (srcSliceY >> 1), c->chrSrcW,
736
             srcSliceH >> 2, srcStride[1], dstStride[1]);
737
    planar2x(src[2], dst[2] + dstStride[2] * (srcSliceY >> 1), c->chrSrcW,
738 739 740 741 742 743 744
             srcSliceH >> 2, srcStride[2], dstStride[2]);
    if (dst[3])
        fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
    return srcSliceH;
}

/* unscaled copy like stuff (assumes nearly identical formats) */
745 746 747
static int packedCopyWrapper(SwsContext *c, const uint8_t *src[],
                             int srcStride[], int srcSliceY, int srcSliceH,
                             uint8_t *dst[], int dstStride[])
748
{
749 750
    if (dstStride[0] == srcStride[0] && srcStride[0] > 0)
        memcpy(dst[0] + dstStride[0] * srcSliceY, src[0], srcSliceH * dstStride[0]);
751 752
    else {
        int i;
753 754 755
        const uint8_t *srcPtr = src[0];
        uint8_t *dstPtr = dst[0] + dstStride[0] * srcSliceY;
        int length = 0;
756 757

        /* universal length finder */
758 759 760 761
        while (length + c->srcW <= FFABS(dstStride[0]) &&
               length + c->srcW <= FFABS(srcStride[0]))
            length += c->srcW;
        assert(length != 0);
762

763
        for (i = 0; i < srcSliceH; i++) {
764
            memcpy(dstPtr, srcPtr, length);
765 766
            srcPtr += srcStride[0];
            dstPtr += dstStride[0];
767 768 769 770 771
        }
    }
    return srcSliceH;
}

772 773 774
#define clip9(x)  av_clip_uintp2(x,  9)
#define clip10(x) av_clip_uintp2(x, 10)
#define DITHER_COPY(dst, dstStride, wfunc, src, srcStride, rfunc, dithers, shift, clip) \
775 776 777
    for (i = 0; i < height; i++) { \
        const uint8_t *dither = dithers[i & 7]; \
        for (j = 0; j < length - 7; j += 8) { \
778 779 780 781 782 783 784 785
            wfunc(&dst[j + 0], clip((rfunc(&src[j + 0]) + dither[0]) >> shift)); \
            wfunc(&dst[j + 1], clip((rfunc(&src[j + 1]) + dither[1]) >> shift)); \
            wfunc(&dst[j + 2], clip((rfunc(&src[j + 2]) + dither[2]) >> shift)); \
            wfunc(&dst[j + 3], clip((rfunc(&src[j + 3]) + dither[3]) >> shift)); \
            wfunc(&dst[j + 4], clip((rfunc(&src[j + 4]) + dither[4]) >> shift)); \
            wfunc(&dst[j + 5], clip((rfunc(&src[j + 5]) + dither[5]) >> shift)); \
            wfunc(&dst[j + 6], clip((rfunc(&src[j + 6]) + dither[6]) >> shift)); \
            wfunc(&dst[j + 7], clip((rfunc(&src[j + 7]) + dither[7]) >> shift)); \
786 787 788 789 790 791 792
        } \
        for (; j < length; j++) \
            wfunc(&dst[j],     (rfunc(&src[j]) + dither[j & 7]) >> shift); \
        dst += dstStride; \
        src += srcStride; \
    }

793 794 795
static int planarCopyWrapper(SwsContext *c, const uint8_t *src[],
                             int srcStride[], int srcSliceY, int srcSliceH,
                             uint8_t *dst[], int dstStride[])
796
{
797 798
    const AVPixFmtDescriptor *desc_src = av_pix_fmt_desc_get(c->srcFormat);
    const AVPixFmtDescriptor *desc_dst = av_pix_fmt_desc_get(c->dstFormat);
799
    int plane, i, j;
800
    for (plane = 0; plane < 4; plane++) {
801 802 803
        int length = (plane == 0 || plane == 3) ? c->srcW  : AV_CEIL_RSHIFT(c->srcW,   c->chrDstHSubSample);
        int y =      (plane == 0 || plane == 3) ? srcSliceY: AV_CEIL_RSHIFT(srcSliceY, c->chrDstVSubSample);
        int height = (plane == 0 || plane == 3) ? srcSliceH: AV_CEIL_RSHIFT(srcSliceH, c->chrDstVSubSample);
804 805
        const uint8_t *srcPtr = src[plane];
        uint8_t *dstPtr = dst[plane] + dstStride[plane] * y;
806
        int shiftonly = plane == 1 || plane == 2 || (!c->srcRange && plane == 0);
807 808 809

        if (!dst[plane])
            continue;
810 811 812
        // ignore palette for GRAY8
        if (plane == 1 && !dst[2]) continue;
        if (!src[plane] || (plane == 1 && !src[2])) {
813
            int val = (plane == 3) ? 255 : 128;
814 815
            if (is16BPS(c->dstFormat))
                length *= 2;
816
            if (is9_15BPS(c->dstFormat)) {
817 818
                fill_plane9or10(dst[plane], dstStride[plane],
                                length, height, y, val,
819
                                desc_dst->comp[plane].depth,
820 821 822 823
                                isBE(c->dstFormat));
            } else
                fillPlane(dst[plane], dstStride[plane], length, height, y,
                          val);
824
        } else {
825
            if (is9_15BPS(c->srcFormat)) {
826 827
                const int src_depth = desc_src->comp[plane].depth;
                const int dst_depth = desc_dst->comp[plane].depth;
828
                const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
829 830

                if (is16BPS(c->dstFormat)) {
831
                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
832
#define COPY9_OR_10TO16(rfunc, wfunc) \
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
                    if (shiftonly) { \
                        for (i = 0; i < height; i++) { \
                            for (j = 0; j < length; j++) { \
                                int srcpx = rfunc(&srcPtr2[j]); \
                                wfunc(&dstPtr2[j], srcpx << (16 - src_depth)); \
                            } \
                            dstPtr2 += dstStride[plane] / 2; \
                            srcPtr2 += srcStride[plane] / 2; \
                        } \
                    } else { \
                        for (i = 0; i < height; i++) { \
                            for (j = 0; j < length; j++) { \
                                int srcpx = rfunc(&srcPtr2[j]); \
                                wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
                            } \
                            dstPtr2 += dstStride[plane] / 2; \
                            srcPtr2 += srcStride[plane] / 2; \
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
                        } \
                    }
                    if (isBE(c->dstFormat)) {
                        if (isBE(c->srcFormat)) {
                            COPY9_OR_10TO16(AV_RB16, AV_WB16);
                        } else {
                            COPY9_OR_10TO16(AV_RL16, AV_WB16);
                        }
                    } else {
                        if (isBE(c->srcFormat)) {
                            COPY9_OR_10TO16(AV_RB16, AV_WL16);
                        } else {
                            COPY9_OR_10TO16(AV_RL16, AV_WL16);
                        }
                    }
865
                } else if (is9_15BPS(c->dstFormat)) {
866
                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
867 868 869 870 871
#define COPY9_OR_10TO9_OR_10(loop) \
                    for (i = 0; i < height; i++) { \
                        for (j = 0; j < length; j++) { \
                            loop; \
                        } \
872 873
                        dstPtr2 += dstStride[plane] / 2; \
                        srcPtr2 += srcStride[plane] / 2; \
874 875 876 877 878 879
                    }
#define COPY9_OR_10TO9_OR_10_2(rfunc, wfunc) \
                    if (dst_depth > src_depth) { \
                        COPY9_OR_10TO9_OR_10(int srcpx = rfunc(&srcPtr2[j]); \
                            wfunc(&dstPtr2[j], (srcpx << 1) | (srcpx >> 9))); \
                    } else if (dst_depth < src_depth) { \
880 881
                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
882
                                    dither_8x8_1, 1, clip9); \
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
                    } else { \
                        COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]))); \
                    }
                    if (isBE(c->dstFormat)) {
                        if (isBE(c->srcFormat)) {
                            COPY9_OR_10TO9_OR_10_2(AV_RB16, AV_WB16);
                        } else {
                            COPY9_OR_10TO9_OR_10_2(AV_RL16, AV_WB16);
                        }
                    } else {
                        if (isBE(c->srcFormat)) {
                            COPY9_OR_10TO9_OR_10_2(AV_RB16, AV_WL16);
                        } else {
                            COPY9_OR_10TO9_OR_10_2(AV_RL16, AV_WL16);
                        }
                    }
                } else {
900
#define W8(a, b) { *(a) = (b); }
901
#define COPY9_OR_10TO8(rfunc) \
902 903
                    if (src_depth == 9) { \
                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
904
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
905
                                    dither_8x8_1, 1, av_clip_uint8); \
906 907
                    } else { \
                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
908
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
909
                                    dither_8x8_3, 2, av_clip_uint8); \
910 911 912 913 914 915 916
                    }
                    if (isBE(c->srcFormat)) {
                        COPY9_OR_10TO8(AV_RB16);
                    } else {
                        COPY9_OR_10TO8(AV_RL16);
                    }
                }
917
            } else if (is9_15BPS(c->dstFormat)) {
918
                const int dst_depth = desc_dst->comp[plane].depth;
919
                uint16_t *dstPtr2 = (uint16_t *) dstPtr;
920 921

                if (is16BPS(c->srcFormat)) {
922
                    const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
923
#define COPY16TO9_OR_10(rfunc, wfunc) \
924
                    if (dst_depth == 9) { \
925 926
                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
927
                                    ff_dither_8x8_128, 7, clip9); \
928
                    } else { \
929 930
                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
                                    srcPtr2, srcStride[plane] / 2, rfunc, \
931
                                    dither_8x8_64, 6, clip10); \
932 933 934 935 936 937 938 939 940 941 942 943 944 945
                    }
                    if (isBE(c->dstFormat)) {
                        if (isBE(c->srcFormat)) {
                            COPY16TO9_OR_10(AV_RB16, AV_WB16);
                        } else {
                            COPY16TO9_OR_10(AV_RL16, AV_WB16);
                        }
                    } else {
                        if (isBE(c->srcFormat)) {
                            COPY16TO9_OR_10(AV_RB16, AV_WL16);
                        } else {
                            COPY16TO9_OR_10(AV_RL16, AV_WL16);
                        }
                    }
946
                } else /* 8 bits */ {
947
#define COPY8TO9_OR_10(wfunc) \
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
                    if (shiftonly) { \
                        for (i = 0; i < height; i++) { \
                            for (j = 0; j < length; j++) { \
                                const int srcpx = srcPtr[j]; \
                                wfunc(&dstPtr2[j], srcpx << (dst_depth - 8)); \
                            } \
                            dstPtr2 += dstStride[plane] / 2; \
                            srcPtr  += srcStride[plane]; \
                        } \
                    } else { \
                        for (i = 0; i < height; i++) { \
                            for (j = 0; j < length; j++) { \
                                const int srcpx = srcPtr[j]; \
                                wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
                            } \
                            dstPtr2 += dstStride[plane] / 2; \
                            srcPtr  += srcStride[plane]; \
965 966 967 968 969 970 971 972
                        } \
                    }
                    if (isBE(c->dstFormat)) {
                        COPY8TO9_OR_10(AV_WB16);
                    } else {
                        COPY8TO9_OR_10(AV_WL16);
                    }
                }
973 974
            } else if (is16BPS(c->srcFormat) && !is16BPS(c->dstFormat)) {
                const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
975 976
#define COPY16TO8(rfunc) \
                    DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
977
                                srcPtr2, srcStride[plane] / 2, rfunc, \
978
                                dither_8x8_256, 8, av_clip_uint8);
979 980 981 982
                if (isBE(c->srcFormat)) {
                    COPY16TO8(AV_RB16);
                } else {
                    COPY16TO8(AV_RL16);
983
                }
984 985 986 987 988
            } else if (!is16BPS(c->srcFormat) && is16BPS(c->dstFormat)) {
                for (i = 0; i < height; i++) {
                    for (j = 0; j < length; j++) {
                        dstPtr[ j << 1     ] = srcPtr[j];
                        dstPtr[(j << 1) + 1] = srcPtr[j];
989
                    }
990 991
                    srcPtr += srcStride[plane];
                    dstPtr += dstStride[plane];
992
                }
993 994 995 996 997 998 999 1000
            } else if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat) &&
                      isBE(c->srcFormat) != isBE(c->dstFormat)) {

                for (i = 0; i < height; i++) {
                    for (j = 0; j < length; j++)
                        ((uint16_t *) dstPtr)[j] = av_bswap16(((const uint16_t *) srcPtr)[j]);
                    srcPtr += srcStride[plane];
                    dstPtr += dstStride[plane];
1001 1002 1003
                }
            } else if (dstStride[plane] == srcStride[plane] &&
                       srcStride[plane] > 0 && srcStride[plane] == length) {
1004 1005
                memcpy(dst[plane] + dstStride[plane] * y, src[plane],
                       height * dstStride[plane]);
1006
            } else {
1007 1008
                if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
                    length *= 2;
1009
                else if (desc_src->comp[0].depth == 1)
1010
                    length >>= 3; // monowhite/black
1011
                for (i = 0; i < height; i++) {
1012
                    memcpy(dstPtr, srcPtr, length);
1013 1014
                    srcPtr += srcStride[plane];
                    dstPtr += dstStride[plane];
1015 1016 1017 1018 1019 1020 1021
                }
            }
        }
    }
    return srcSliceH;
}

1022 1023 1024 1025 1026 1027

#define IS_DIFFERENT_ENDIANESS(src_fmt, dst_fmt, pix_fmt)          \
    ((src_fmt == pix_fmt ## BE && dst_fmt == pix_fmt ## LE) ||     \
     (src_fmt == pix_fmt ## LE && dst_fmt == pix_fmt ## BE))


1028 1029
void ff_get_unscaled_swscale(SwsContext *c)
{
1030 1031
    const enum AVPixelFormat srcFormat = c->srcFormat;
    const enum AVPixelFormat dstFormat = c->dstFormat;
1032 1033 1034 1035
    const int flags = c->flags;
    const int dstH = c->dstH;
    int needsDither;

1036 1037 1038
    needsDither = isAnyRGB(dstFormat) &&
            c->dstFormatBpp < 24 &&
           (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
1039 1040

    /* yv12_to_nv12 */
1041 1042
    if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) &&
        (dstFormat == AV_PIX_FMT_NV12 || dstFormat == AV_PIX_FMT_NV21)) {
1043
        c->swscale = planarToNv12Wrapper;
1044
    }
1045 1046 1047 1048 1049
    /* nv12_to_yv12 */
    if (dstFormat == AV_PIX_FMT_YUV420P &&
        (srcFormat == AV_PIX_FMT_NV12 || srcFormat == AV_PIX_FMT_NV21)) {
        c->swscale = nv12ToPlanarWrapper;
    }
1050
    /* yuv2bgr */
1051 1052
    if ((srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUV422P ||
         srcFormat == AV_PIX_FMT_YUVA420P) && isAnyRGB(dstFormat) &&
1053
        !(flags & SWS_ACCURATE_RND) && !(dstH & 1)) {
1054
        c->swscale = ff_yuv2rgb_get_func_ptr(c);
1055 1056
    }

1057 1058
    if (srcFormat == AV_PIX_FMT_YUV410P &&
        (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P) &&
1059
        !(flags & SWS_BITEXACT)) {
1060
        c->swscale = yvu9ToYv12Wrapper;
1061 1062 1063
    }

    /* bgr24toYV12 */
1064 1065
    if (srcFormat == AV_PIX_FMT_BGR24 &&
        (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P) &&
1066
        !(flags & SWS_ACCURATE_RND))
1067
        c->swscale = bgr24ToYv12Wrapper;
1068 1069

    /* RGB/BGR -> RGB/BGR (no dither needed forms) */
1070
    if (isAnyRGB(srcFormat) && isAnyRGB(dstFormat) && findRgbConvFn(c)
1071
        && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
1072
        c->swscale = rgbToRgbWrapper;
1073

1074 1075 1076 1077 1078
    /* RGB to planar RGB */
    if ((srcFormat == AV_PIX_FMT_GBRP && dstFormat == AV_PIX_FMT_GBRAP) ||
        (srcFormat == AV_PIX_FMT_GBRAP && dstFormat == AV_PIX_FMT_GBRP))
        c->swscale = planarRgbToplanarRgbWrapper;

1079 1080 1081 1082 1083 1084 1085 1086 1087
#define isByteRGB(f) (             \
        f == AV_PIX_FMT_RGB32   || \
        f == AV_PIX_FMT_RGB32_1 || \
        f == AV_PIX_FMT_RGB24   || \
        f == AV_PIX_FMT_BGR32   || \
        f == AV_PIX_FMT_BGR32_1 || \
        f == AV_PIX_FMT_BGR24)

    if (srcFormat == AV_PIX_FMT_GBRP && isPlanar(srcFormat) && isByteRGB(dstFormat))
1088
        c->swscale = planarRgbToRgbWrapper;
1089

1090
    if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
1091
        isPackedRGB(srcFormat) && dstFormat == AV_PIX_FMT_GBRP)
1092
        c->swscale = rgbToPlanarRgbWrapper;
1093

1094
    /* bswap 16 bits per pixel/component packed formats */
1095 1096 1097 1098
    if (IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR444) ||
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR48)  ||
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR555) ||
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR565) ||
1099
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGRA64) ||
Luca Barbato's avatar
Luca Barbato committed
1100
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY12) ||
1101
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY16) ||
1102
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YA16)   ||
1103
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP12)||
1104
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GBRAP16)||
1105 1106 1107
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB444) ||
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB48)  ||
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB555) ||
1108
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGB565) ||
1109
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_RGBA64) ||
1110
        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_XYZ12))
1111
        c->swscale = packed_16bpc_bswap;
1112

1113
    if ((usePal(srcFormat) && (
1114 1115 1116 1117 1118 1119
        dstFormat == AV_PIX_FMT_RGB32   ||
        dstFormat == AV_PIX_FMT_RGB32_1 ||
        dstFormat == AV_PIX_FMT_RGB24   ||
        dstFormat == AV_PIX_FMT_BGR32   ||
        dstFormat == AV_PIX_FMT_BGR32_1 ||
        dstFormat == AV_PIX_FMT_BGR24)))
1120
        c->swscale = palToRgbWrapper;
1121

1122 1123
    if (srcFormat == AV_PIX_FMT_YUV422P) {
        if (dstFormat == AV_PIX_FMT_YUYV422)
1124
            c->swscale = yuv422pToYuy2Wrapper;
1125
        else if (dstFormat == AV_PIX_FMT_UYVY422)
1126
            c->swscale = yuv422pToUyvyWrapper;
1127 1128 1129 1130 1131
    }

    /* LQ converters if -sws 0 or -sws 4*/
    if (c->flags&(SWS_FAST_BILINEAR|SWS_POINT)) {
        /* yv12_to_yuy2 */
1132 1133
        if (srcFormat == AV_PIX_FMT_YUV420P || srcFormat == AV_PIX_FMT_YUVA420P) {
            if (dstFormat == AV_PIX_FMT_YUYV422)
1134
                c->swscale = planarToYuy2Wrapper;
1135
            else if (dstFormat == AV_PIX_FMT_UYVY422)
1136
                c->swscale = planarToUyvyWrapper;
1137 1138
        }
    }
1139 1140
    if (srcFormat == AV_PIX_FMT_YUYV422 &&
       (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P))
1141
        c->swscale = yuyvToYuv420Wrapper;
1142 1143
    if (srcFormat == AV_PIX_FMT_UYVY422 &&
       (dstFormat == AV_PIX_FMT_YUV420P || dstFormat == AV_PIX_FMT_YUVA420P))
1144
        c->swscale = uyvyToYuv420Wrapper;
1145
    if (srcFormat == AV_PIX_FMT_YUYV422 && dstFormat == AV_PIX_FMT_YUV422P)
1146
        c->swscale = yuyvToYuv422Wrapper;
1147
    if (srcFormat == AV_PIX_FMT_UYVY422 && dstFormat == AV_PIX_FMT_YUV422P)
1148
        c->swscale = uyvyToYuv422Wrapper;
1149 1150

    /* simple copy */
1151
    if ( srcFormat == dstFormat ||
1152 1153
        (srcFormat == AV_PIX_FMT_YUVA420P && dstFormat == AV_PIX_FMT_YUV420P) ||
        (srcFormat == AV_PIX_FMT_YUV420P && dstFormat == AV_PIX_FMT_YUVA420P) ||
1154 1155 1156 1157 1158 1159
        (isPlanarYUV(srcFormat) && isGray(dstFormat)) ||
        (isPlanarYUV(dstFormat) && isGray(srcFormat)) ||
        (isGray(dstFormat) && isGray(srcFormat)) ||
        (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat) &&
         c->chrDstHSubSample == c->chrSrcHSubSample &&
         c->chrDstVSubSample == c->chrSrcVSubSample &&
1160
         dstFormat != AV_PIX_FMT_NV12 && dstFormat != AV_PIX_FMT_NV21 &&
1161
         dstFormat != AV_PIX_FMT_P010LE && dstFormat != AV_PIX_FMT_P010BE &&
1162
         dstFormat != AV_PIX_FMT_YUV420P12LE && dstFormat != AV_PIX_FMT_YUV420P12BE &&
1163
         dstFormat != AV_PIX_FMT_YUV422P12LE && dstFormat != AV_PIX_FMT_YUV422P12BE &&
1164
         dstFormat != AV_PIX_FMT_YUV444P12LE && dstFormat != AV_PIX_FMT_YUV444P12BE &&
1165
         srcFormat != AV_PIX_FMT_NV12 && srcFormat != AV_PIX_FMT_NV21 &&
1166
         srcFormat != AV_PIX_FMT_P010LE && srcFormat != AV_PIX_FMT_P010BE &&
1167
         srcFormat != AV_PIX_FMT_YUV420P12LE && srcFormat != AV_PIX_FMT_YUV420P12BE &&
1168 1169
         srcFormat != AV_PIX_FMT_YUV422P12LE && srcFormat != AV_PIX_FMT_YUV422P12BE &&
         srcFormat != AV_PIX_FMT_YUV444P12LE && srcFormat != AV_PIX_FMT_YUV444P12BE))
1170 1171
    {
        if (isPacked(c->srcFormat))
1172
            c->swscale = packedCopyWrapper;
1173
        else /* Planar YUV or gray */
1174
            c->swscale = planarCopyWrapper;
1175 1176
    }

1177
    if (ARCH_PPC)
1178
        ff_get_unscaled_swscale_ppc(c);
1179 1180
}

1181
static void reset_ptr(const uint8_t *src[], enum AVPixelFormat format)
1182
{
1183 1184
    if (!isALPHA(format))
        src[3] = NULL;
1185
    if (!isPlanar(format)) {
1186
        src[3] = src[2] = NULL;
1187 1188

        if (!usePal(format))
1189
            src[1] = NULL;
1190 1191 1192
    }
}

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
#define CHECK_IMAGE_POINTERS(data, pix_fmt, linesizes, msg)            \
    do {                                                               \
        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); \
        int i;                                                         \
                                                                       \
        for (i = 0; i < 4; i++) {                                      \
            int plane = desc->comp[i].plane;                           \
            if (!data[plane] || !linesizes[plane]) {                   \
                av_log(c, AV_LOG_ERROR, msg);                          \
                return 0;                                              \
            }                                                          \
        }                                                              \
    } while (0)
1206 1207 1208 1209 1210

/**
 * swscale wrapper, so we don't need to export the SwsContext.
 * Assumes planar YUV to be in YUV order instead of YVU.
 */
1211 1212 1213 1214 1215
int attribute_align_arg sws_scale(struct SwsContext *c,
                                  const uint8_t * const srcSlice[],
                                  const int srcStride[], int srcSliceY,
                                  int srcSliceH, uint8_t *const dst[],
                                  const int dstStride[])
1216 1217
{
    int i;
1218 1219
    const uint8_t *src2[4] = { srcSlice[0], srcSlice[1], srcSlice[2], srcSlice[3] };
    uint8_t *dst2[4] = { dst[0], dst[1], dst[2], dst[3] };
1220 1221 1222 1223 1224

    // do not mess up sliceDir if we have a "trailing" 0-size slice
    if (srcSliceH == 0)
        return 0;

1225 1226
    CHECK_IMAGE_POINTERS(srcSlice, c->srcFormat, srcStride, "bad src image pointers\n");
    CHECK_IMAGE_POINTERS(dst, c->dstFormat, dstStride, "bad dst image pointers\n");
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236

    if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
        av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
        return 0;
    }
    if (c->sliceDir == 0) {
        if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
    }

    if (usePal(c->srcFormat)) {
1237
        for (i = 0; i < 256; i++) {
1238
            int r, g, b, y, u, v;
1239
            if (c->srcFormat == AV_PIX_FMT_PAL8) {
1240
                uint32_t p = ((const uint32_t *)(srcSlice[1]))[i];
1241 1242 1243
                r = (p >> 16) & 0xFF;
                g = (p >>  8) & 0xFF;
                b =  p        & 0xFF;
1244
            } else if (c->srcFormat == AV_PIX_FMT_RGB8) {
1245 1246 1247
                r = ( i >> 5     ) * 36;
                g = ((i >> 2) & 7) * 36;
                b = ( i       & 3) * 85;
1248
            } else if (c->srcFormat == AV_PIX_FMT_BGR8) {
1249 1250 1251
                b = ( i >> 6     ) * 85;
                g = ((i >> 3) & 7) * 36;
                r = ( i       & 7) * 36;
1252
            } else if (c->srcFormat == AV_PIX_FMT_RGB4_BYTE) {
1253 1254 1255
                r = ( i >> 3     ) * 255;
                g = ((i >> 1) & 3) * 85;
                b = ( i       & 1) * 255;
1256
            } else if (c->srcFormat == AV_PIX_FMT_GRAY8 ||
1257
                       c->srcFormat == AV_PIX_FMT_YA8) {
1258 1259
                r = g = b = i;
            } else {
1260
                assert(c->srcFormat == AV_PIX_FMT_BGR4_BYTE);
1261 1262 1263
                b = ( i >> 3     ) * 255;
                g = ((i >> 1) & 3) * 85;
                r = ( i       & 1) * 255;
1264
            }
1265 1266 1267
            y = av_clip_uint8((RY * r + GY * g + BY * b + ( 33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
            u = av_clip_uint8((RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
            v = av_clip_uint8((RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1268
            c->pal_yuv[i] = y + (u << 8) + (v << 16) + (0xFFU << 24);
1269

1270
            switch (c->dstFormat) {
1271
            case AV_PIX_FMT_BGR32:
1272
#if !HAVE_BIGENDIAN
1273
            case AV_PIX_FMT_RGB24:
1274
#endif
1275
                c->pal_rgb[i] =  r + (g << 8) + (b << 16) + (0xFFU << 24);
1276
                break;
1277
            case AV_PIX_FMT_BGR32_1:
1278
#if HAVE_BIGENDIAN
1279
            case AV_PIX_FMT_BGR24:
1280
#endif
1281
                c->pal_rgb[i] = 0xFF + (r << 8) + (g << 16) + ((unsigned)b << 24);
1282
                break;
1283
            case AV_PIX_FMT_RGB32_1:
1284
#if HAVE_BIGENDIAN
1285
            case AV_PIX_FMT_RGB24:
1286
#endif
1287
                c->pal_rgb[i] = 0xFF + (b << 8) + (g << 16) + ((unsigned)r << 24);
1288
                break;
1289
            case AV_PIX_FMT_RGB32:
1290
#if !HAVE_BIGENDIAN
1291
            case AV_PIX_FMT_BGR24:
1292 1293
#endif
            default:
1294
                c->pal_rgb[i] =  b + (g << 8) + (r << 16) + (0xFFU << 24);
1295 1296 1297 1298 1299 1300 1301
            }
        }
    }

    // copy strides, so they can safely be modified
    if (c->sliceDir == 1) {
        // slices go from top to bottom
1302 1303 1304 1305
        int srcStride2[4] = { srcStride[0], srcStride[1], srcStride[2],
                              srcStride[3] };
        int dstStride2[4] = { dstStride[0], dstStride[1], dstStride[2],
                              dstStride[3] };
1306 1307

        reset_ptr(src2, c->srcFormat);
1308
        reset_ptr((const uint8_t **) dst2, c->dstFormat);
1309 1310 1311 1312 1313

        /* reset slice direction at end of frame */
        if (srcSliceY + srcSliceH == c->srcH)
            c->sliceDir = 0;

1314
        return c->swscale(c, src2, srcStride2, srcSliceY, srcSliceH, dst2,
1315
                          dstStride2);
1316 1317
    } else {
        // slices go from bottom to top => we flip the image internally
1318 1319 1320 1321
        int srcStride2[4] = { -srcStride[0], -srcStride[1], -srcStride[2],
                              -srcStride[3] };
        int dstStride2[4] = { -dstStride[0], -dstStride[1], -dstStride[2],
                              -dstStride[3] };
1322

1323
        src2[0] += (srcSliceH - 1) * srcStride[0];
1324
        if (!usePal(c->srcFormat))
1325 1326 1327 1328 1329 1330 1331
            src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
        src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
        src2[3] += (srcSliceH - 1) * srcStride[3];
        dst2[0] += ( c->dstH                         - 1) * dstStride[0];
        dst2[1] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[1];
        dst2[2] += ((c->dstH >> c->chrDstVSubSample) - 1) * dstStride[2];
        dst2[3] += ( c->dstH                         - 1) * dstStride[3];
1332 1333

        reset_ptr(src2, c->srcFormat);
1334
        reset_ptr((const uint8_t **) dst2, c->dstFormat);
1335 1336 1337 1338 1339

        /* reset slice direction at end of frame */
        if (!srcSliceY)
            c->sliceDir = 0;

1340
        return c->swscale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH,
1341
                          srcSliceH, dst2, dstStride2);
1342 1343 1344 1345
    }
}

/* Convert the palette to the same packed 32-bit format as the palette */
1346 1347
void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst,
                                   int num_pixels, const uint8_t *palette)
1348 1349 1350
{
    int i;

1351
    for (i = 0; i < num_pixels; i++)
1352 1353 1354 1355
        ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
}

/* Palette format: ABCD -> dst format: ABC */
1356 1357
void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst,
                                   int num_pixels, const uint8_t *palette)
1358 1359 1360
{
    int i;

1361
    for (i = 0; i < num_pixels; i++) {
1362
        //FIXME slow?
1363 1364 1365 1366
        dst[0] = palette[src[i] * 4 + 0];
        dst[1] = palette[src[i] * 4 + 1];
        dst[2] = palette[src[i] * 4 + 2];
        dst += 3;
1367 1368
    }
}