swscale_internal.h 34.5 KB
Newer Older
1
/*
2 3
 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
 *
4
 * This file is part of Libav.
5
 *
6
 * Libav is free software; you can redistribute it and/or
7 8 9
 * 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.
10
 *
11
 * Libav is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with Libav; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20

21 22
#ifndef SWSCALE_SWSCALE_INTERNAL_H
#define SWSCALE_SWSCALE_INTERNAL_H
23

24 25
#include "config.h"

26
#if HAVE_ALTIVEC_H
27 28 29
#include <altivec.h>
#endif

30
#include "libavutil/avassert.h"
31
#include "libavutil/avutil.h"
32
#include "libavutil/common.h"
33
#include "libavutil/log.h"
34
#include "libavutil/pixfmt.h"
35
#include "libavutil/pixdesc.h"
36

37
#define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
38

39
#define FAST_BGR2YV12 // use 7-bit instead of 15-bit coefficients
40

41 42
#define MAX_FILTER_SIZE 256

43
#if HAVE_BIGENDIAN
44 45 46
#define ALT32_CORR (-1)
#else
#define ALT32_CORR   1
47 48
#endif

49
#if ARCH_X86_64
50
#   define APCK_PTR2  8
51 52 53
#   define APCK_COEF 16
#   define APCK_SIZE 24
#else
54 55
#   define APCK_PTR2  4
#   define APCK_COEF  8
56
#   define APCK_SIZE 16
57 58
#endif

59 60
struct SwsContext;

61
typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
62
                       int srcStride[], int srcSliceY, int srcSliceH,
63
                       uint8_t *dst[], int dstStride[]);
64

65
/**
66
 * Write one line of horizontally scaled data to planar output
67 68
 * without any additional vertical scaling (or point-scaling).
 *
69
 * @param src     scaled source data, 15bit for 8-10bit output,
70
 *                19-bit for 16bit output (in int32_t)
71
 * @param dest    pointer to the output plane. For >8bit
72
 *                output, this is in uint16_t
73 74 75
 * @param dstW    width of destination in pixels
 * @param dither  ordered dither array of type int16_t and size 8
 * @param offset  Dither offset
76
 */
77 78
typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
                               const uint8_t *dither, int offset);
79

80
/**
Kieran Kunhya's avatar
Kieran Kunhya committed
81
 * Write one line of horizontally scaled data to planar output
82 83
 * with multi-point vertical scaling between input pixels.
 *
Kieran Kunhya's avatar
Kieran Kunhya committed
84 85
 * @param filter        vertical luma/alpha scaling coefficients, 12bit [0,4096]
 * @param src           scaled luma (Y) or alpha (A) source data, 15bit for 8-10bit output,
86
 *                      19-bit for 16bit output (in int32_t)
Kieran Kunhya's avatar
Kieran Kunhya committed
87 88 89 90 91 92
 * @param filterSize    number of vertical input lines to scale
 * @param dest          pointer to output plane. For >8bit
 *                      output, this is in uint16_t
 * @param dstW          width of destination pixels
 * @param offset        Dither offset
 */
93 94 95
typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
                               const int16_t **src, uint8_t *dest, int dstW,
                               const uint8_t *dither, int offset);
Kieran Kunhya's avatar
Kieran Kunhya committed
96 97 98 99 100 101

/**
 * Write one line of horizontally scaled chroma to interleaved output
 * with multi-point vertical scaling between input pixels.
 *
 * @param c             SWS scaling context
102
 * @param chrFilter     vertical chroma scaling coefficients, 12bit [0,4096]
103 104 105 106
 * @param chrUSrc       scaled chroma (U) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param chrVSrc       scaled chroma (V) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
107
 * @param chrFilterSize number of vertical chroma input lines to scale
Kieran Kunhya's avatar
Kieran Kunhya committed
108
 * @param dest          pointer to the output plane. For >8bit
109
 *                      output, this is in uint16_t
Kieran Kunhya's avatar
Kieran Kunhya committed
110
 * @param dstW          width of chroma planes
111
 */
112 113 114 115 116 117
typedef void (*yuv2interleavedX_fn)(struct SwsContext *c,
                                    const int16_t *chrFilter,
                                    int chrFilterSize,
                                    const int16_t **chrUSrc,
                                    const int16_t **chrVSrc,
                                    uint8_t *dest, int dstW);
Kieran Kunhya's avatar
Kieran Kunhya committed
118

119 120 121 122 123 124
/**
 * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
 * output without any additional vertical scaling (or point-scaling). Note
 * that this function may do chroma scaling, see the "uvalpha" argument.
 *
 * @param c       SWS scaling context
125 126 127 128 129 130 131 132 133 134
 * @param lumSrc  scaled luma (Y) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param alpSrc  scaled alpha (A) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param dest    pointer to the output plane. For 16bit output, this is
 *                uint16_t
135 136 137 138 139 140 141 142 143 144 145 146 147
 * @param dstW    width of lumSrc and alpSrc in pixels, number of pixels
 *                to write into dest[]
 * @param uvalpha chroma scaling coefficient for the second line of chroma
 *                pixels, either 2048 or 0. If 0, one chroma input is used
 *                for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
 *                is set, it generates 1 output pixel). If 2048, two chroma
 *                input pixels should be averaged for 2 output pixels (this
 *                only happens if SWS_FLAG_FULL_CHR_INT is not set)
 * @param y       vertical line number for this output. This does not need
 *                to be used to calculate the offset in the destination,
 *                but can be used to generate comfort noise using dithering
 *                for some output formats.
 */
148 149 150 151 152
typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
                               const int16_t *chrUSrc[2],
                               const int16_t *chrVSrc[2],
                               const int16_t *alpSrc, uint8_t *dest,
                               int dstW, int uvalpha, int y);
153 154 155 156 157
/**
 * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
 * output by doing bilinear scaling between two input lines.
 *
 * @param c       SWS scaling context
158 159 160 161 162 163 164 165 166 167
 * @param lumSrc  scaled luma (Y) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param chrUSrc scaled chroma (U) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param chrVSrc scaled chroma (V) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param alpSrc  scaled alpha (A) source data, 15bit for 8-10bit output,
 *                19-bit for 16bit output (in int32_t)
 * @param dest    pointer to the output plane. For 16bit output, this is
 *                uint16_t
168 169 170 171 172 173 174 175 176 177 178 179 180
 * @param dstW    width of lumSrc and alpSrc in pixels, number of pixels
 *                to write into dest[]
 * @param yalpha  luma/alpha scaling coefficients for the second input line.
 *                The first line's coefficients can be calculated by using
 *                4096 - yalpha
 * @param uvalpha chroma scaling coefficient for the second input line. The
 *                first line's coefficients can be calculated by using
 *                4096 - uvalpha
 * @param y       vertical line number for this output. This does not need
 *                to be used to calculate the offset in the destination,
 *                but can be used to generate comfort noise using dithering
 *                for some output formats.
 */
181 182 183 184 185 186
typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
                               const int16_t *chrUSrc[2],
                               const int16_t *chrVSrc[2],
                               const int16_t *alpSrc[2],
                               uint8_t *dest,
                               int dstW, int yalpha, int uvalpha, int y);
187 188 189 190 191 192
/**
 * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
 * output by doing multi-point vertical scaling between input pixels.
 *
 * @param c             SWS scaling context
 * @param lumFilter     vertical luma/alpha scaling coefficients, 12bit [0,4096]
193 194
 * @param lumSrc        scaled luma (Y) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
195 196
 * @param lumFilterSize number of vertical luma/alpha input lines to scale
 * @param chrFilter     vertical chroma scaling coefficients, 12bit [0,4096]
197 198 199 200
 * @param chrUSrc       scaled chroma (U) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param chrVSrc       scaled chroma (V) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
201
 * @param chrFilterSize number of vertical chroma input lines to scale
202 203 204 205
 * @param alpSrc        scaled alpha (A) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param dest          pointer to the output plane. For 16bit output, this is
 *                      uint16_t
206 207 208 209 210 211 212
 * @param dstW          width of lumSrc and alpSrc in pixels, number of pixels
 *                      to write into dest[]
 * @param y             vertical line number for this output. This does not need
 *                      to be used to calculate the offset in the destination,
 *                      but can be used to generate comfort noise using dithering
 *                      or some output formats.
 */
213 214 215 216 217 218 219
typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
                               const int16_t **lumSrc, int lumFilterSize,
                               const int16_t *chrFilter,
                               const int16_t **chrUSrc,
                               const int16_t **chrVSrc, int chrFilterSize,
                               const int16_t **alpSrc, uint8_t *dest,
                               int dstW, int y);
220

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
/**
 * Write one line of horizontally scaled Y/U/V/A to YUV/RGB
 * output by doing multi-point vertical scaling between input pixels.
 *
 * @param c             SWS scaling context
 * @param lumFilter     vertical luma/alpha scaling coefficients, 12bit [0,4096]
 * @param lumSrc        scaled luma (Y) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param lumFilterSize number of vertical luma/alpha input lines to scale
 * @param chrFilter     vertical chroma scaling coefficients, 12bit [0,4096]
 * @param chrUSrc       scaled chroma (U) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param chrVSrc       scaled chroma (V) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param chrFilterSize number of vertical chroma input lines to scale
 * @param alpSrc        scaled alpha (A) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
 * @param dest          pointer to the output planes. For 16bit output, this is
 *                      uint16_t
 * @param dstW          width of lumSrc and alpSrc in pixels, number of pixels
 *                      to write into dest[]
 * @param y             vertical line number for this output. This does not need
 *                      to be used to calculate the offset in the destination,
 *                      but can be used to generate comfort noise using dithering
 *                      or some output formats.
 */
typedef void (*yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter,
                            const int16_t **lumSrc, int lumFilterSize,
                            const int16_t *chrFilter,
                            const int16_t **chrUSrc,
                            const int16_t **chrVSrc, int chrFilterSize,
                            const int16_t **alpSrc, uint8_t **dest,
                            int dstW, int y);

255
/* This struct should be aligned on at least a 32-byte boundary. */
Ramiro Polla's avatar
Ramiro Polla committed
256
typedef struct SwsContext {
257 258 259
    /**
     * info on struct for av_log
     */
260
    const AVClass *av_class;
261 262

    /**
Diego Biurrun's avatar
Diego Biurrun committed
263 264
     * Note that src, dst, srcStride, dstStride will be copied in the
     * sws_scale() wrapper so they can be freely modified here.
265 266
     */
    SwsFunc swScale;
Ramiro Polla's avatar
Ramiro Polla committed
267 268 269 270 271 272 273
    int srcW;                     ///< Width  of source      luma/alpha planes.
    int srcH;                     ///< Height of source      luma/alpha planes.
    int dstH;                     ///< Height of destination luma/alpha planes.
    int chrSrcW;                  ///< Width  of source      chroma     planes.
    int chrSrcH;                  ///< Height of source      chroma     planes.
    int chrDstW;                  ///< Width  of destination chroma     planes.
    int chrDstH;                  ///< Height of destination chroma     planes.
274 275
    int lumXInc, chrXInc;
    int lumYInc, chrYInc;
276 277
    enum AVPixelFormat dstFormat; ///< Destination pixel format.
    enum AVPixelFormat srcFormat; ///< Source      pixel format.
278 279
    int dstFormatBpp;             ///< Number of bits per pixel of the destination pixel format.
    int srcFormatBpp;             ///< Number of bits per pixel of the source      pixel format.
280
    int dstBpc, srcBpc;
281 282 283 284 285 286
    int chrSrcHSubSample;         ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source      image.
    int chrSrcVSubSample;         ///< Binary logarithm of vertical   subsampling factor between luma/alpha and chroma planes in source      image.
    int chrDstHSubSample;         ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
    int chrDstVSubSample;         ///< Binary logarithm of vertical   subsampling factor between luma/alpha and chroma planes in destination image.
    int vChrDrop;                 ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
    int sliceDir;                 ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
Ramiro Polla's avatar
Ramiro Polla committed
287
    double param[2];              ///< Input parameters for scaling algorithms that need them.
288

289 290 291
    uint32_t pal_yuv[256];
    uint32_t pal_rgb[256];

292 293 294 295 296 297 298 299 300 301 302
    /**
     * @name Scaled horizontal lines ring buffer.
     * The horizontal scaler keeps just enough scaled lines in a ring buffer
     * so they may be passed to the vertical scaler. The pointers to the
     * allocated buffers for each line are duplicated in sequence in the ring
     * buffer to simplify indexing and avoid wrapping around between lines
     * inside the vertical scaler code. The wrapping is done before the
     * vertical scaler is called.
     */
    //@{
    int16_t **lumPixBuf;          ///< Ring buffer for scaled horizontal luma   plane lines to be fed to the vertical scaler.
303 304
    int16_t **chrUPixBuf;         ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
    int16_t **chrVPixBuf;         ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler.
305
    int16_t **alpPixBuf;          ///< Ring buffer for scaled horizontal alpha  plane lines to be fed to the vertical scaler.
306 307 308 309 310 311
    int vLumBufSize;              ///< Number of vertical luma/alpha lines allocated in the ring buffer.
    int vChrBufSize;              ///< Number of vertical chroma     lines allocated in the ring buffer.
    int lastInLumBuf;             ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
    int lastInChrBuf;             ///< Last scaled horizontal chroma     line from source in the ring buffer.
    int lumBufIndex;              ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
    int chrBufIndex;              ///< Index in ring buffer of the last scaled horizontal chroma     line from source.
312
    //@}
313

314
    uint8_t *formatConvBuffer;
315

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
    /**
     * @name Horizontal and vertical filters.
     * To better understand the following fields, here is a pseudo-code of
     * their usage in filtering a horizontal line:
     * @code
     * for (i = 0; i < width; i++) {
     *     dst[i] = 0;
     *     for (j = 0; j < filterSize; j++)
     *         dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
     *     dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
     * }
     * @endcode
     */
    //@{
    int16_t *hLumFilter;          ///< Array of horizontal filter coefficients for luma/alpha planes.
    int16_t *hChrFilter;          ///< Array of horizontal filter coefficients for chroma     planes.
    int16_t *vLumFilter;          ///< Array of vertical   filter coefficients for luma/alpha planes.
    int16_t *vChrFilter;          ///< Array of vertical   filter coefficients for chroma     planes.
334 335 336 337
    int32_t *hLumFilterPos;       ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
    int32_t *hChrFilterPos;       ///< Array of horizontal filter starting positions for each dst[i] for chroma     planes.
    int32_t *vLumFilterPos;       ///< Array of vertical   filter starting positions for each dst[i] for luma/alpha planes.
    int32_t *vChrFilterPos;       ///< Array of vertical   filter starting positions for each dst[i] for chroma     planes.
338 339 340 341
    int hLumFilterSize;           ///< Horizontal filter size for luma/alpha pixels.
    int hChrFilterSize;           ///< Horizontal filter size for chroma     pixels.
    int vLumFilterSize;           ///< Vertical   filter size for luma/alpha pixels.
    int vChrFilterSize;           ///< Vertical   filter size for chroma     pixels.
342
    //@}
343

344 345 346 347
    int lumMmxextFilterCodeSize;  ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
    int chrMmxextFilterCodeSize;  ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
    uint8_t *lumMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
    uint8_t *chrMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
348

349
    int canMMXEXTBeUsed;
350

Ramiro Polla's avatar
Ramiro Polla committed
351 352
    int dstY;                     ///< Last destination vertical line output from last slice.
    int flags;                    ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
353 354 355 356 357
    void *yuvTable;             // pointer to the yuv->rgb table start so it can be freed()
    uint8_t *table_rV[256];
    uint8_t *table_gU[256];
    int table_gV[256];
    uint8_t *table_bU[256];
358 359 360 361 362

    //Colorspace stuff
    int contrast, brightness, saturation;    // for sws_getColorspaceDetails
    int srcColorspaceTable[4];
    int dstColorspaceTable[4];
Ramiro Polla's avatar
Ramiro Polla committed
363 364
    int srcRange;                 ///< 0 = MPG YUV range, 1 = JPG YUV range (source      image).
    int dstRange;                 ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
365 366 367 368 369 370
    int yuv2rgb_y_offset;
    int yuv2rgb_y_coeff;
    int yuv2rgb_v2r_coeff;
    int yuv2rgb_v2g_coeff;
    int yuv2rgb_u2g_coeff;
    int yuv2rgb_u2b_coeff;
371 372 373 374 375 376 377 378 379 380 381 382

#define RED_DITHER            "0*8"
#define GREEN_DITHER          "1*8"
#define BLUE_DITHER           "2*8"
#define Y_COEFF               "3*8"
#define VR_COEFF              "4*8"
#define UB_COEFF              "5*8"
#define VG_COEFF              "6*8"
#define UG_COEFF              "7*8"
#define Y_OFFSET              "8*8"
#define U_OFFSET              "9*8"
#define V_OFFSET              "10*8"
383 384
#define LUM_MMX_FILTER_OFFSET "11*8"
#define CHR_MMX_FILTER_OFFSET "11*8+4*4*256"
385
#define DSTW_OFFSET           "11*8+4*4*256*2" //do not change, it is hardcoded in the ASM
386 387 388 389
#define ESP_OFFSET            "11*8+4*4*256*2+8"
#define VROUNDER_OFFSET       "11*8+4*4*256*2+16"
#define U_TEMP                "11*8+4*4*256*2+24"
#define V_TEMP                "11*8+4*4*256*2+32"
Cédric Schieli's avatar
Cédric Schieli committed
390
#define Y_TEMP                "11*8+4*4*256*2+40"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
391 392 393 394 395
#define ALP_MMX_FILTER_OFFSET "11*8+4*4*256*2+48"
#define UV_OFF_PX             "11*8+4*4*256*3+48"
#define UV_OFF_BYTE           "11*8+4*4*256*3+56"
#define DITHER16              "11*8+4*4*256*3+64"
#define DITHER32              "11*8+4*4*256*3+80"
396

397 398 399 400 401 402 403 404 405 406 407 408
    DECLARE_ALIGNED(8, uint64_t, redDither);
    DECLARE_ALIGNED(8, uint64_t, greenDither);
    DECLARE_ALIGNED(8, uint64_t, blueDither);

    DECLARE_ALIGNED(8, uint64_t, yCoeff);
    DECLARE_ALIGNED(8, uint64_t, vrCoeff);
    DECLARE_ALIGNED(8, uint64_t, ubCoeff);
    DECLARE_ALIGNED(8, uint64_t, vgCoeff);
    DECLARE_ALIGNED(8, uint64_t, ugCoeff);
    DECLARE_ALIGNED(8, uint64_t, yOffset);
    DECLARE_ALIGNED(8, uint64_t, uOffset);
    DECLARE_ALIGNED(8, uint64_t, vOffset);
409 410
    int32_t lumMmxFilter[4 * MAX_FILTER_SIZE];
    int32_t chrMmxFilter[4 * MAX_FILTER_SIZE];
411
    int dstW;                     ///< Width  of destination luma/alpha planes.
412 413 414 415 416
    DECLARE_ALIGNED(8, uint64_t, esp);
    DECLARE_ALIGNED(8, uint64_t, vRounder);
    DECLARE_ALIGNED(8, uint64_t, u_temp);
    DECLARE_ALIGNED(8, uint64_t, v_temp);
    DECLARE_ALIGNED(8, uint64_t, y_temp);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
417
    int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
418 419 420
    // alignment of these values is not necessary, but merely here
    // to maintain the same offset across x8632 and x86-64. Once we
    // use proper offset macros in the asm, they can be removed.
421 422
    DECLARE_ALIGNED(8, ptrdiff_t, uv_off_px);   ///< offset (in pixels) between u and v planes
    DECLARE_ALIGNED(8, ptrdiff_t, uv_off_byte); ///< offset (in bytes) between u and v planes
423 424
    DECLARE_ALIGNED(8, uint16_t, dither16)[8];
    DECLARE_ALIGNED(8, uint32_t, dither32)[8];
425 426

    const uint8_t *chrDither8, *lumDither8;
427

428
#if HAVE_ALTIVEC
Ramiro Polla's avatar
Ramiro Polla committed
429 430 431 432 433 434 435
    vector signed short   CY;
    vector signed short   CRV;
    vector signed short   CBU;
    vector signed short   CGU;
    vector signed short   CGV;
    vector signed short   OY;
    vector unsigned short CSHIFT;
436
    vector signed short  *vYCoeffsBank, *vCCoeffsBank;
437 438
#endif

439
#if ARCH_BFIN
440 441 442 443 444 445 446 447 448 449 450
    DECLARE_ALIGNED(4, uint32_t, oy);
    DECLARE_ALIGNED(4, uint32_t, oc);
    DECLARE_ALIGNED(4, uint32_t, zero);
    DECLARE_ALIGNED(4, uint32_t, cy);
    DECLARE_ALIGNED(4, uint32_t, crv);
    DECLARE_ALIGNED(4, uint32_t, rmask);
    DECLARE_ALIGNED(4, uint32_t, cbu);
    DECLARE_ALIGNED(4, uint32_t, bmask);
    DECLARE_ALIGNED(4, uint32_t, cgu);
    DECLARE_ALIGNED(4, uint32_t, cgv);
    DECLARE_ALIGNED(4, uint32_t, gmask);
451 452
#endif

453
#if HAVE_VIS
454
    DECLARE_ALIGNED(8, uint64_t, sparc_coeffs)[10];
Denes Balatoni's avatar
Denes Balatoni committed
455
#endif
456

457
    /* function pointers for swScale() */
458 459 460
    yuv2planar1_fn yuv2plane1;
    yuv2planarX_fn yuv2planeX;
    yuv2interleavedX_fn yuv2nv12cX;
461 462 463
    yuv2packed1_fn yuv2packed1;
    yuv2packed2_fn yuv2packed2;
    yuv2packedX_fn yuv2packedX;
464
    yuv2anyX_fn yuv2anyX;
465

466
    /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
467
    void (*lumToYV12)(uint8_t *dst, const uint8_t *src,
468 469
                      int width, uint32_t *pal);
    /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
470
    void (*alpToYV12)(uint8_t *dst, const uint8_t *src,
471 472
                      int width, uint32_t *pal);
    /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
473 474
    void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
                      const uint8_t *src1, const uint8_t *src2,
475
                      int width, uint32_t *pal);
476 477

    /**
478 479 480
     * Functions to read planar input, such as planar RGB, and convert
     * internally to Y/UV.
     */
481 482
    /** @{ */
    void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width);
483 484
    void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
                          int width);
485 486
    /** @} */

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
    /**
     * Scale one horizontal line of input data using a bilinear filter
     * to produce one line of output data. Compared to SwsContext->hScale(),
     * please take note of the following caveats when using these:
     * - Scaling is done using only 7bit instead of 14bit coefficients.
     * - You can use no more than 5 input pixels to produce 4 output
     *   pixels. Therefore, this filter should not be used for downscaling
     *   by more than ~20% in width (because that equals more than 5/4th
     *   downscaling and thus more than 5 pixels input per 4 pixels output).
     * - In general, bilinear filters create artifacts during downscaling
     *   (even when <20%), because one output pixel will span more than one
     *   input pixel, and thus some pixels will need edges of both neighbor
     *   pixels to interpolate the output pixel. Since you can use at most
     *   two input pixels per output pixel in bilinear scaling, this is
     *   impossible and thus downscaling by any size will create artifacts.
     * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
     * in SwsContext->flags.
     */
    /** @{ */
506
    void (*hyscale_fast)(struct SwsContext *c,
507
                         int16_t *dst, int dstWidth,
508 509
                         const uint8_t *src, int srcW, int xInc);
    void (*hcscale_fast)(struct SwsContext *c,
510
                         int16_t *dst1, int16_t *dst2, int dstWidth,
511 512
                         const uint8_t *src1, const uint8_t *src2,
                         int srcW, int xInc);
513
    /** @} */
514

515 516 517 518 519
    /**
     * Scale one horizontal line of input data using a filter over the input
     * lines, to produce one (differently sized) line of output data.
     *
     * @param dst        pointer to destination buffer for horizontally scaled
520 521 522 523 524
     *                   data. If the number of bits per component of one
     *                   destination pixel (SwsContext->dstBpc) is <= 10, data
     *                   will be 15bpc in 16bits (int16_t) width. Else (i.e.
     *                   SwsContext->dstBpc == 16), data will be 19bpc in
     *                   32bits (int32_t) width.
525
     * @param dstW       width of destination image
526 527 528 529 530 531 532
     * @param src        pointer to source data to be scaled. If the number of
     *                   bits per component of a source pixel (SwsContext->srcBpc)
     *                   is 8, this is 8bpc in 8bits (uint8_t) width. Else
     *                   (i.e. SwsContext->dstBpc > 8), this is native depth
     *                   in 16bits (uint16_t) width. In other words, for 9-bit
     *                   YUV input, this is 9bpc, for 10-bit YUV input, this is
     *                   10bpc, and for 16-bit RGB or YUV, this is 16bpc.
533 534 535 536 537 538 539 540 541 542 543 544
     * @param filter     filter coefficients to be used per output pixel for
     *                   scaling. This contains 14bpp filtering coefficients.
     *                   Guaranteed to contain dstW * filterSize entries.
     * @param filterPos  position of the first input pixel to be used for
     *                   each output pixel during scaling. Guaranteed to
     *                   contain dstW entries.
     * @param filterSize the number of input coefficients to be used (and
     *                   thus the number of input pixels to be used) for
     *                   creating a single output pixel. Is aligned to 4
     *                   (and input coefficients thus padded with zeroes)
     *                   to simplify creating SIMD code.
     */
545
    /** @{ */
546 547
    void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
                    const uint8_t *src, const int16_t *filter,
548
                    const int32_t *filterPos, int filterSize);
549 550
    void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
                    const uint8_t *src, const int16_t *filter,
551
                    const int32_t *filterPos, int filterSize);
552
    /** @} */
553

554 555 556 557
    /// Color range conversion function for luma plane if needed.
    void (*lumConvertRange)(int16_t *dst, int width);
    /// Color range conversion function for chroma planes if needed.
    void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
558

559
    int needs_hcscale; ///< Set if there are chroma planes to be converted.
560 561 562
} SwsContext;
//FIXME check init (where 0)

563
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c);
564 565 566
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
                             int fullRange, int brightness,
                             int contrast, int saturation);
567

568 569
void ff_yuv2rgb_init_tables_altivec(SwsContext *c, const int inv_table[4],
                                    int brightness, int contrast, int saturation);
570 571 572
void updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex,
                           int lastInLumBuf, int lastInChrBuf);

Ramiro Polla's avatar
Ramiro Polla committed
573 574
SwsFunc ff_yuv2rgb_init_mmx(SwsContext *c);
SwsFunc ff_yuv2rgb_init_vis(SwsContext *c);
575
SwsFunc ff_yuv2rgb_init_altivec(SwsContext *c);
Ramiro Polla's avatar
Ramiro Polla committed
576
SwsFunc ff_yuv2rgb_get_func_ptr_bfin(SwsContext *c);
577
void ff_bfin_get_unscaled_swscale(SwsContext *c);
578

579
const char *sws_format_name(enum AVPixelFormat format);
580

581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
    return desc->comp[0].depth_minus1 == 15;
}

static av_always_inline int is9_OR_10BPS(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
    return desc->comp[0].depth_minus1 == 8 || desc->comp[0].depth_minus1 == 9;
}

static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
599
    return desc->flags & AV_PIX_FMT_FLAG_BE;
600 601 602 603 604 605
}

static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
606
    return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
607 608 609 610 611 612
}

static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
613
    return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
614 615 616 617 618 619
}

static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
620
    return (desc->flags & AV_PIX_FMT_FLAG_RGB);
621
}
622

623
#if 0 // FIXME
624
#define isGray(x) \
625
    (!(av_pix_fmt_descriptors[x].flags & AV_PIX_FMT_FLAG_PAL) && \
626
     av_pix_fmt_descriptors[x].nb_components <= 2)
627
#else
628
#define isGray(x)                      \
629 630 631 632
    ((x) == AV_PIX_FMT_GRAY8       ||  \
     (x) == AV_PIX_FMT_Y400A       ||  \
     (x) == AV_PIX_FMT_GRAY16BE    ||  \
     (x) == AV_PIX_FMT_GRAY16LE)
633
#endif
634

635
#define isRGBinInt(x)                  \
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
    ((x) == AV_PIX_FMT_RGB48BE     ||  \
     (x) == AV_PIX_FMT_RGB48LE     ||  \
     (x) == AV_PIX_FMT_RGB32       ||  \
     (x) == AV_PIX_FMT_RGB32_1     ||  \
     (x) == AV_PIX_FMT_RGB24       ||  \
     (x) == AV_PIX_FMT_RGB565BE    ||  \
     (x) == AV_PIX_FMT_RGB565LE    ||  \
     (x) == AV_PIX_FMT_RGB555BE    ||  \
     (x) == AV_PIX_FMT_RGB555LE    ||  \
     (x) == AV_PIX_FMT_RGB444BE    ||  \
     (x) == AV_PIX_FMT_RGB444LE    ||  \
     (x) == AV_PIX_FMT_RGB8        ||  \
     (x) == AV_PIX_FMT_RGB4        ||  \
     (x) == AV_PIX_FMT_RGB4_BYTE   ||  \
     (x) == AV_PIX_FMT_MONOBLACK   ||  \
     (x) == AV_PIX_FMT_MONOWHITE)
652 653

#define isBGRinInt(x)                  \
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
    ((x) == AV_PIX_FMT_BGR48BE     ||  \
     (x) == AV_PIX_FMT_BGR48LE     ||  \
     (x) == AV_PIX_FMT_BGR32       ||  \
     (x) == AV_PIX_FMT_BGR32_1     ||  \
     (x) == AV_PIX_FMT_BGR24       ||  \
     (x) == AV_PIX_FMT_BGR565BE    ||  \
     (x) == AV_PIX_FMT_BGR565LE    ||  \
     (x) == AV_PIX_FMT_BGR555BE    ||  \
     (x) == AV_PIX_FMT_BGR555LE    ||  \
     (x) == AV_PIX_FMT_BGR444BE    ||  \
     (x) == AV_PIX_FMT_BGR444LE    ||  \
     (x) == AV_PIX_FMT_BGR8        ||  \
     (x) == AV_PIX_FMT_BGR4        ||  \
     (x) == AV_PIX_FMT_BGR4_BYTE   ||  \
     (x) == AV_PIX_FMT_MONOBLACK   ||  \
     (x) == AV_PIX_FMT_MONOWHITE)
670 671 672 673 674

#define isAnyRGB(x)                    \
    (isRGBinInt(x)              ||     \
     isBGRinInt(x))

675 676 677 678 679 680 681 682 683 684 685
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
    return desc->nb_components == 2 || desc->nb_components == 4;
}

static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
686
    return ((desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
687 688 689 690 691 692 693
            pix_fmt == AV_PIX_FMT_PAL8);
}

static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
694
    return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
695 696 697 698 699 700
}

static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
701
    return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) == AV_PIX_FMT_FLAG_RGB);
702 703 704 705 706 707
}

static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
708 709
    return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
            (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB));
710 711 712 713 714 715
}

static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
716
    return ((desc->flags & AV_PIX_FMT_FLAG_PAL) || (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) ||
717 718
            pix_fmt == AV_PIX_FMT_Y400A);
}
719

720 721
extern const uint64_t ff_dither4[2];
extern const uint64_t ff_dither8[2];
722

723 724
extern const AVClass sws_context_class;

725
/**
726
 * Set c->swScale to an unscaled converter if one exists for the specific
727 728 729 730
 * source and destination formats, bit depths, flags, etc.
 */
void ff_get_unscaled_swscale(SwsContext *c);

731 732
void ff_swscale_get_unscaled_altivec(SwsContext *c);

733
/**
734
 * Return function pointer to fastest main scaler path function depending
735 736 737 738
 * on architecture and available optimizations.
 */
SwsFunc ff_getSwsFunc(SwsContext *c);

739
void ff_sws_init_input_funcs(SwsContext *c);
740 741 742 743 744 745
void ff_sws_init_output_funcs(SwsContext *c,
                              yuv2planar1_fn *yuv2plane1,
                              yuv2planarX_fn *yuv2planeX,
                              yuv2interleavedX_fn *yuv2nv12cX,
                              yuv2packed1_fn *yuv2packed1,
                              yuv2packed2_fn *yuv2packed2,
746 747
                              yuv2packedX_fn *yuv2packedX,
                              yuv2anyX_fn *yuv2anyX);
748
void ff_sws_init_swScale_altivec(SwsContext *c);
749
void ff_sws_init_swScale_mmx(SwsContext *c);
750

751
#endif /* SWSCALE_SWSCALE_INTERNAL_H */