swscale_internal.h 45.1 KB
Newer Older
1
/*
M
Michael Niedermayer 已提交
2
 * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
3 4 5
 *
 * This file is part of FFmpeg.
 *
6 7 8 9
 * FFmpeg 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.
10 11 12
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * 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 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; 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 31
#include "version.h"

32
#include "libavutil/avassert.h"
33
#include "libavutil/avutil.h"
34
#include "libavutil/common.h"
35
#include "libavutil/intreadwrite.h"
M
Mans Rullgard 已提交
36
#include "libavutil/log.h"
37
#include "libavutil/pixfmt.h"
38
#include "libavutil/pixdesc.h"
39

40
#define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
41

42
#define YUVRGB_TABLE_HEADROOM 256
43

44
#define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
45

46 47
#define DITHER1XBPP

48
#if HAVE_BIGENDIAN
49 50 51
#define ALT32_CORR (-1)
#else
#define ALT32_CORR   1
52 53
#endif

54
#if ARCH_X86_64
55
#   define APCK_PTR2  8
56 57 58
#   define APCK_COEF 16
#   define APCK_SIZE 24
#else
59 60
#   define APCK_PTR2  4
#   define APCK_COEF  8
61
#   define APCK_SIZE 16
62 63
#endif

64 65
#define RETCODE_USE_CASCADE -12345

66 67
struct SwsContext;

M
Michael Niedermayer 已提交
68 69 70 71 72
typedef enum SwsDither {
    SWS_DITHER_NONE = 0,
    SWS_DITHER_AUTO,
    SWS_DITHER_BAYER,
    SWS_DITHER_ED,
73 74
    SWS_DITHER_A_DITHER,
    SWS_DITHER_X_DITHER,
M
Michael Niedermayer 已提交
75 76 77
    NB_SWS_DITHER,
} SwsDither;

78 79 80
typedef enum SwsAlphaBlend {
    SWS_ALPHA_BLEND_NONE  = 0,
    SWS_ALPHA_BLEND_UNIFORM,
81
    SWS_ALPHA_BLEND_CHECKERBOARD,
82 83 84
    SWS_ALPHA_BLEND_NB,
} SwsAlphaBlend;

85
typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
86
                       int srcStride[], int srcSliceY, int srcSliceH,
87
                       uint8_t *dst[], int dstStride[]);
88

89
/**
90
 * Write one line of horizontally scaled data to planar output
91 92
 * without any additional vertical scaling (or point-scaling).
 *
93
 * @param src     scaled source data, 15bit for 8-10bit output,
94
 *                19-bit for 16bit output (in int32_t)
95
 * @param dest    pointer to the output plane. For >8bit
96
 *                output, this is in uint16_t
97 98 99
 * @param dstW    width of destination in pixels
 * @param dither  ordered dither array of type int16_t and size 8
 * @param offset  Dither offset
100
 */
101 102
typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
                               const uint8_t *dither, int offset);
103

104
/**
K
Kieran Kunhya 已提交
105
 * Write one line of horizontally scaled data to planar output
106 107
 * with multi-point vertical scaling between input pixels.
 *
K
Kieran Kunhya 已提交
108 109
 * @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,
110
 *                      19-bit for 16bit output (in int32_t)
K
Kieran Kunhya 已提交
111 112 113 114 115 116
 * @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
 */
117 118 119
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);
K
Kieran Kunhya 已提交
120 121 122 123 124 125

/**
 * Write one line of horizontally scaled chroma to interleaved output
 * with multi-point vertical scaling between input pixels.
 *
 * @param c             SWS scaling context
126
 * @param chrFilter     vertical chroma scaling coefficients, 12bit [0,4096]
127 128 129 130
 * @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)
131
 * @param chrFilterSize number of vertical chroma input lines to scale
K
Kieran Kunhya 已提交
132
 * @param dest          pointer to the output plane. For >8bit
133
 *                      output, this is in uint16_t
K
Kieran Kunhya 已提交
134
 * @param dstW          width of chroma planes
135
 */
136 137 138 139 140 141
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);
K
Kieran Kunhya 已提交
142

143 144 145 146 147 148
/**
 * 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
149 150 151 152 153 154 155 156 157 158
 * @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
159 160 161 162 163 164 165 166 167 168 169 170 171
 * @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.
 */
172 173 174 175 176
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);
177 178 179 180 181
/**
 * 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
182 183 184 185 186 187 188 189 190 191
 * @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
192 193 194 195 196 197 198 199 200 201 202 203 204
 * @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.
 */
205 206 207 208 209 210
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);
211 212 213 214 215 216
/**
 * 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]
217 218
 * @param lumSrc        scaled luma (Y) source data, 15bit for 8-10bit output,
 *                      19-bit for 16bit output (in int32_t)
219 220
 * @param lumFilterSize number of vertical luma/alpha input lines to scale
 * @param chrFilter     vertical chroma scaling coefficients, 12bit [0,4096]
221 222 223 224
 * @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)
225
 * @param chrFilterSize number of vertical chroma input lines to scale
226 227 228 229
 * @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
230 231 232 233 234 235 236
 * @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.
 */
237 238 239 240 241 242 243
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);
244

M
Michael Niedermayer 已提交
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
/**
 * 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,
272 273 274 275 276 277
                            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);
M
Michael Niedermayer 已提交
278

279 280 281
struct SwsSlice;
struct SwsFilterDescriptor;

282
/* This struct should be aligned on at least a 32-byte boundary. */
R
Ramiro Polla 已提交
283
typedef struct SwsContext {
284 285 286
    /**
     * info on struct for av_log
     */
287
    const AVClass *av_class;
288 289

    /**
D
Diego Biurrun 已提交
290 291
     * Note that src, dst, srcStride, dstStride will be copied in the
     * sws_scale() wrapper so they can be freely modified here.
292
     */
293
    SwsFunc swscale;
R
Ramiro Polla 已提交
294 295 296 297 298 299 300
    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.
301 302
    int lumXInc, chrXInc;
    int lumYInc, chrYInc;
303 304
    enum AVPixelFormat dstFormat; ///< Destination pixel format.
    enum AVPixelFormat srcFormat; ///< Source      pixel format.
305 306
    int dstFormatBpp;             ///< Number of bits per pixel of the destination pixel format.
    int srcFormatBpp;             ///< Number of bits per pixel of the source      pixel format.
307
    int dstBpc, srcBpc;
R
Ramiro Polla 已提交
308 309 310 311 312 313
    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).
R
Ramiro Polla 已提交
314
    double param[2];              ///< Input parameters for scaling algorithms that need them.
315

316 317 318 319
    /* The cascaded_* fields allow spliting a scaler task into multiple
     * sequential steps, this is for example used to limit the maximum
     * downscaling factor that needs to be supported in one scaler.
     */
320
    struct SwsContext *cascaded_context[3];
321 322
    int cascaded_tmpStride[4];
    uint8_t *cascaded_tmp[4];
323 324 325 326 327
    int cascaded1_tmpStride[4];
    uint8_t *cascaded1_tmp[4];

    double gamma_value;
    int gamma_flag;
328
    int is_internal_gamma;
329 330
    uint16_t *gamma;
    uint16_t *inv_gamma;
331

332 333 334 335 336 337
    int numDesc;
    int descIndex[2];
    int numSlice;
    struct SwsSlice *slice;
    struct SwsFilterDescriptor *desc;

338 339 340
    uint32_t pal_yuv[256];
    uint32_t pal_rgb[256];

R
Ramiro Polla 已提交
341 342 343 344 345 346 347 348 349 350 351
    /**
     * @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.
352 353
    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.
R
Ramiro Polla 已提交
354
    int16_t **alpPixBuf;          ///< Ring buffer for scaled horizontal alpha  plane lines to be fed to the vertical scaler.
355 356 357 358 359 360
    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.
R
Ramiro Polla 已提交
361
    //@}
362

363
    uint8_t *formatConvBuffer;
364

R
Ramiro Polla 已提交
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
    /**
     * @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.
383 384 385 386
    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.
387 388 389 390
    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.
R
Ramiro Polla 已提交
391
    //@}
392

393 394 395 396
    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.
397

398
    int canMMXEXTBeUsed;
399

R
Ramiro Polla 已提交
400 401
    int dstY;                     ///< Last destination vertical line output from last slice.
    int flags;                    ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
402
    void *yuvTable;             // pointer to the yuv->rgb table start so it can be freed()
403 404 405
    // alignment ensures the offset can be added in a single
    // instruction on e.g. ARM
    DECLARE_ALIGNED(16, int, table_gV)[256 + 2*YUVRGB_TABLE_HEADROOM];
406 407 408
    uint8_t *table_rV[256 + 2*YUVRGB_TABLE_HEADROOM];
    uint8_t *table_gU[256 + 2*YUVRGB_TABLE_HEADROOM];
    uint8_t *table_bU[256 + 2*YUVRGB_TABLE_HEADROOM];
M
Michael Niedermayer 已提交
409
    DECLARE_ALIGNED(16, int32_t, input_rgb2yuv_table)[16+40*4]; // This table can contain both C and SIMD formatted values, the C vales are always at the XY_IDX points
410 411 412 413 414 415 416 417 418
#define RY_IDX 0
#define GY_IDX 1
#define BY_IDX 2
#define RU_IDX 3
#define GU_IDX 4
#define BU_IDX 5
#define RV_IDX 6
#define GV_IDX 7
#define BV_IDX 8
419
#define RGB2YUV_SHIFT 15
420

421 422
    int *dither_error[4];

423 424 425 426
    //Colorspace stuff
    int contrast, brightness, saturation;    // for sws_getColorspaceDetails
    int srcColorspaceTable[4];
    int dstColorspaceTable[4];
R
Ramiro Polla 已提交
427 428
    int srcRange;                 ///< 0 = MPG YUV range, 1 = JPG YUV range (source      image).
    int dstRange;                 ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
429 430
    int src0Alpha;
    int dst0Alpha;
M
Michael Niedermayer 已提交
431 432
    int srcXYZ;
    int dstXYZ;
433 434 435 436
    int src_h_chr_pos;
    int dst_h_chr_pos;
    int src_v_chr_pos;
    int dst_v_chr_pos;
437 438 439 440 441 442
    int yuv2rgb_y_offset;
    int yuv2rgb_y_coeff;
    int yuv2rgb_v2r_coeff;
    int yuv2rgb_v2g_coeff;
    int yuv2rgb_u2g_coeff;
    int yuv2rgb_u2b_coeff;
443 444 445 446 447 448 449 450 451 452 453 454

#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"
455
#define LUM_MMX_FILTER_OFFSET "11*8"
456
#define CHR_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)
457
#define DSTW_OFFSET           "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2"
458 459 460 461 462 463 464 465 466 467
#define ESP_OFFSET            "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+8"
#define VROUNDER_OFFSET       "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+16"
#define U_TEMP                "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+24"
#define V_TEMP                "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+32"
#define Y_TEMP                "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+40"
#define ALP_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+48"
#define UV_OFF_PX             "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+48"
#define UV_OFF_BYTE           "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+56"
#define DITHER16              "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+64"
#define DITHER32              "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+80"
A
Andreas Cadhalpun 已提交
468
#define DITHER32_INT          (11*8+4*4*MAX_FILTER_SIZE*3+80) // value equal to above, used for checking that the struct hasn't been changed by mistake
469

470 471 472 473 474 475 476 477 478 479 480 481
    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);
482 483
    int32_t lumMmxFilter[4 * MAX_FILTER_SIZE];
    int32_t chrMmxFilter[4 * MAX_FILTER_SIZE];
R
Ramiro Polla 已提交
484
    int dstW;                     ///< Width  of destination luma/alpha planes.
485 486 487 488 489
    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);
R
Ronald S. Bultje 已提交
490
    int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
491 492 493
    // 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.
494
    DECLARE_ALIGNED(8, ptrdiff_t, uv_off); ///< offset (in pixels) between u and v planes
495
    DECLARE_ALIGNED(8, ptrdiff_t, uv_offx2); ///< offset (in bytes) between u and v planes
496 497
    DECLARE_ALIGNED(8, uint16_t, dither16)[8];
    DECLARE_ALIGNED(8, uint32_t, dither32)[8];
M
Michael Niedermayer 已提交
498

499 500
    const uint8_t *chrDither8, *lumDither8;

501
#if HAVE_ALTIVEC
R
Ramiro Polla 已提交
502 503 504 505 506 507 508
    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;
509
    vector signed short  *vYCoeffsBank, *vCCoeffsBank;
M
Michael Niedermayer 已提交
510 511
#endif

512
    int use_mmx_vfilter;
513

M
Michael Niedermayer 已提交
514 515 516
/* pre defined color-spaces gamma */
#define XYZ_GAMMA (2.6f)
#define RGB_GAMMA (2.2f)
517 518
    int16_t *xyzgamma;
    int16_t *rgbgamma;
C
clook 已提交
519 520
    int16_t *xyzgammainv;
    int16_t *rgbgammainv;
M
Michael Niedermayer 已提交
521
    int16_t xyz2rgb_matrix[3][4];
C
clook 已提交
522
    int16_t rgb2xyz_matrix[3][4];
M
Michael Niedermayer 已提交
523

524
    /* function pointers for swscale() */
525 526 527
    yuv2planar1_fn yuv2plane1;
    yuv2planarX_fn yuv2planeX;
    yuv2interleavedX_fn yuv2nv12cX;
528 529 530
    yuv2packed1_fn yuv2packed1;
    yuv2packed2_fn yuv2packed2;
    yuv2packedX_fn yuv2packedX;
M
Michael Niedermayer 已提交
531
    yuv2anyX_fn yuv2anyX;
532

533
    /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
534
    void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
535 536
                      int width, uint32_t *pal);
    /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
537
    void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
538 539
                      int width, uint32_t *pal);
    /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
540
    void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
541
                      const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
542
                      int width, uint32_t *pal);
543 544

    /**
545
     * Functions to read planar input, such as planar RGB, and convert
546
     * internally to Y/UV/A.
547
     */
548
    /** @{ */
549
    void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
550
    void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
551
                          int width, int32_t *rgb2yuv);
552
    void (*readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
553 554
    /** @} */

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
    /**
     * 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.
     */
    /** @{ */
574
    void (*hyscale_fast)(struct SwsContext *c,
A
Anton Khirnov 已提交
575
                         int16_t *dst, int dstWidth,
576 577
                         const uint8_t *src, int srcW, int xInc);
    void (*hcscale_fast)(struct SwsContext *c,
A
Anton Khirnov 已提交
578
                         int16_t *dst1, int16_t *dst2, int dstWidth,
579 580
                         const uint8_t *src1, const uint8_t *src2,
                         int srcW, int xInc);
581
    /** @} */
582

583 584 585 586 587
    /**
     * 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
588 589 590 591 592
     *                   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.
593
     * @param dstW       width of destination image
594 595 596 597 598 599 600
     * @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.
601 602 603 604 605 606 607 608 609 610 611 612
     * @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.
     */
613
    /** @{ */
614 615
    void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
                    const uint8_t *src, const int16_t *filter,
616
                    const int32_t *filterPos, int filterSize);
617 618
    void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
                    const uint8_t *src, const int16_t *filter,
619
                    const int32_t *filterPos, int filterSize);
620
    /** @} */
621

622 623 624 625
    /// 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);
626

627
    int needs_hcscale; ///< Set if there are chroma planes to be converted.
M
Michael Niedermayer 已提交
628 629

    SwsDither dither;
630 631

    SwsAlphaBlend alphablend;
632 633 634
} SwsContext;
//FIXME check init (where 0)

635
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c);
636 637 638
int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
                             int fullRange, int brightness,
                             int contrast, int saturation);
639 640
void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4],
                                int brightness, int contrast, int saturation);
641

642
void ff_updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex,
643 644
                           int lastInLumBuf, int lastInChrBuf);

645 646
av_cold void ff_sws_init_range_convert(SwsContext *c);

647
SwsFunc ff_yuv2rgb_init_x86(SwsContext *c);
648
SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c);
649

650 651 652 653
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
654
    return desc->comp[0].depth == 16;
655
}
M
Michael Niedermayer 已提交
656

657 658 659 660
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);
661
    return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
662
}
M
Michael Niedermayer 已提交
663

664 665
#define isNBPS(x) is9_OR_10BPS(x)

666 667 668 669
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
670
    return desc->flags & AV_PIX_FMT_FLAG_BE;
671 672 673 674 675 676
}

static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
677
    return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
678 679 680 681 682 683
}

static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
684
    return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
685 686 687 688 689 690
}

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

694
#if 0 // FIXME
695
#define isGray(x) \
696
    (!(av_pix_fmt_desc_get(x)->flags & AV_PIX_FMT_FLAG_PAL) && \
697
     av_pix_fmt_desc_get(x)->nb_components <= 2)
698
#else
699
#define isGray(x)                      \
700
    ((x) == AV_PIX_FMT_GRAY8       ||  \
701
     (x) == AV_PIX_FMT_YA8         ||  \
702
     (x) == AV_PIX_FMT_GRAY16BE    ||  \
703 704 705
     (x) == AV_PIX_FMT_GRAY16LE    ||  \
     (x) == AV_PIX_FMT_YA16BE      ||  \
     (x) == AV_PIX_FMT_YA16LE)
706
#endif
707

708 709
#define isRGBinInt(x) \
    (           \
710
     (x) == AV_PIX_FMT_RGB48BE     ||  \
711 712 713 714 715 716 717 718 719 720 721 722 723
     (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   ||  \
J
Jean First 已提交
724 725
     (x) == AV_PIX_FMT_RGBA64BE    ||  \
     (x) == AV_PIX_FMT_RGBA64LE    ||  \
726
     (x) == AV_PIX_FMT_MONOBLACK   ||  \
727
     (x) == AV_PIX_FMT_MONOWHITE   \
728
    )
729 730
#define isBGRinInt(x) \
    (           \
731
     (x) == AV_PIX_FMT_BGR48BE     ||  \
732 733 734 735 736 737 738 739 740 741 742 743 744
     (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   ||  \
J
Jean First 已提交
745 746
     (x) == AV_PIX_FMT_BGRA64BE    ||  \
     (x) == AV_PIX_FMT_BGRA64LE    ||  \
747
     (x) == AV_PIX_FMT_MONOBLACK   ||  \
748
     (x) == AV_PIX_FMT_MONOWHITE   \
749
    )
750

751
#define isRGBinBytes(x) (           \
752 753 754 755 756 757 758
           (x) == AV_PIX_FMT_RGB48BE     \
        || (x) == AV_PIX_FMT_RGB48LE     \
        || (x) == AV_PIX_FMT_RGBA64BE    \
        || (x) == AV_PIX_FMT_RGBA64LE    \
        || (x) == AV_PIX_FMT_RGBA        \
        || (x) == AV_PIX_FMT_ARGB        \
        || (x) == AV_PIX_FMT_RGB24       \
759 760
    )
#define isBGRinBytes(x) (           \
761 762 763 764 765 766 767
           (x) == AV_PIX_FMT_BGR48BE     \
        || (x) == AV_PIX_FMT_BGR48LE     \
        || (x) == AV_PIX_FMT_BGRA64BE    \
        || (x) == AV_PIX_FMT_BGRA64LE    \
        || (x) == AV_PIX_FMT_BGRA        \
        || (x) == AV_PIX_FMT_ABGR        \
        || (x) == AV_PIX_FMT_BGR24       \
768
    )
769

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
#define isBayer(x) ( \
           (x)==AV_PIX_FMT_BAYER_BGGR8    \
        || (x)==AV_PIX_FMT_BAYER_BGGR16LE \
        || (x)==AV_PIX_FMT_BAYER_BGGR16BE \
        || (x)==AV_PIX_FMT_BAYER_RGGB8    \
        || (x)==AV_PIX_FMT_BAYER_RGGB16LE \
        || (x)==AV_PIX_FMT_BAYER_RGGB16BE \
        || (x)==AV_PIX_FMT_BAYER_GBRG8    \
        || (x)==AV_PIX_FMT_BAYER_GBRG16LE \
        || (x)==AV_PIX_FMT_BAYER_GBRG16BE \
        || (x)==AV_PIX_FMT_BAYER_GRBG8    \
        || (x)==AV_PIX_FMT_BAYER_GRBG16LE \
        || (x)==AV_PIX_FMT_BAYER_GRBG16BE \
    )

785 786
#define isAnyRGB(x) \
    (           \
787
          isBayer(x)          ||    \
788 789
          isRGBinInt(x)       ||    \
          isBGRinInt(x)       ||    \
790
          isRGB(x)      \
791
    )
792

793 794 795 796
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
797 798
    if (pix_fmt == AV_PIX_FMT_PAL8)
        return 1;
799
    return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
800
}
801

802
#if 1
803
#define isPacked(x)         (       \
804 805
           (x)==AV_PIX_FMT_PAL8        \
        || (x)==AV_PIX_FMT_YUYV422     \
806
        || (x)==AV_PIX_FMT_YVYU422     \
807
        || (x)==AV_PIX_FMT_UYVY422     \
808
        || (x)==AV_PIX_FMT_YA8       \
809 810
        || (x)==AV_PIX_FMT_YA16LE      \
        || (x)==AV_PIX_FMT_YA16BE      \
P
Paul B Mahol 已提交
811 812
        || (x)==AV_PIX_FMT_AYUV64LE    \
        || (x)==AV_PIX_FMT_AYUV64BE    \
M
Michael Niedermayer 已提交
813 814
        ||  isRGBinInt(x)           \
        ||  isBGRinInt(x)           \
815
    )
816
#else
817 818 819 820
static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
821
    return ((desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
822 823
            pix_fmt == AV_PIX_FMT_PAL8);
}
824

825
#endif
826 827 828 829
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
830
    return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
831 832 833 834 835 836
}

static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
837
    return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) == AV_PIX_FMT_FLAG_RGB);
838 839 840 841 842 843
}

static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
844 845
    return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
            (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB));
846 847 848 849 850 851
}

static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
{
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    av_assert0(desc);
852
    return (desc->flags & AV_PIX_FMT_FLAG_PAL) || (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL);
853
}
854

855 856
extern const uint64_t ff_dither4[2];
extern const uint64_t ff_dither8[2];
857

858 859 860 861 862
extern const uint8_t ff_dither_2x2_4[3][8];
extern const uint8_t ff_dither_2x2_8[3][8];
extern const uint8_t ff_dither_4x4_16[5][8];
extern const uint8_t ff_dither_8x8_32[9][8];
extern const uint8_t ff_dither_8x8_73[9][8];
863
extern const uint8_t ff_dither_8x8_128[9][8];
864
extern const uint8_t ff_dither_8x8_220[9][8];
865 866

extern const int32_t ff_yuv2rgb_coeffs[8][4];
867

868 869
extern const AVClass sws_context_class;

870
/**
871
 * Set c->swscale to an unscaled converter if one exists for the specific
872 873 874
 * source and destination formats, bit depths, flags, etc.
 */
void ff_get_unscaled_swscale(SwsContext *c);
875
void ff_get_unscaled_swscale_ppc(SwsContext *c);
876
void ff_get_unscaled_swscale_arm(SwsContext *c);
877

878
/**
879
 * Return function pointer to fastest main scaler path function depending
880 881 882 883
 * on architecture and available optimizations.
 */
SwsFunc ff_getSwsFunc(SwsContext *c);

884
void ff_sws_init_input_funcs(SwsContext *c);
885 886 887 888 889 890
void ff_sws_init_output_funcs(SwsContext *c,
                              yuv2planar1_fn *yuv2plane1,
                              yuv2planarX_fn *yuv2planeX,
                              yuv2interleavedX_fn *yuv2nv12cX,
                              yuv2packed1_fn *yuv2packed1,
                              yuv2packed2_fn *yuv2packed2,
M
Michael Niedermayer 已提交
891 892
                              yuv2packedX_fn *yuv2packedX,
                              yuv2anyX_fn *yuv2anyX);
893
void ff_sws_init_swscale_ppc(SwsContext *c);
894
void ff_sws_init_swscale_x86(SwsContext *c);
895

896 897 898 899 900
void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
                       const uint8_t *src, int srcW, int xInc);
void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
                       int dstWidth, const uint8_t *src1,
                       const uint8_t *src2, int srcW, int xInc);
901 902 903 904 905 906 907 908 909
int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
                           int16_t *filter, int32_t *filterPos,
                           int numSplits);
void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
                            int dstWidth, const uint8_t *src,
                            int srcW, int xInc);
void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
                            int dstWidth, const uint8_t *src1,
                            const uint8_t *src2, int srcW, int xInc);
910

911 912 913 914 915 916 917 918 919 920 921
/**
 * Allocate and return an SwsContext.
 * This is like sws_getContext() but does not perform the init step, allowing
 * the user to set additional AVOptions.
 *
 * @see sws_getContext()
 */
struct SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
                                      int dstW, int dstH, enum AVPixelFormat dstFormat,
                                      int flags, const double *param);

922 923 924 925
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[],
                          int srcStride[], int srcSliceY, int srcSliceH,
                          uint8_t *dst[], int dstStride[]);

926 927 928 929 930
static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
                               int alpha, int bits, const int big_endian)
{
    int i, j;
    uint8_t *ptr = plane + stride * y;
931
    int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
932 933 934 935 936 937 938 939 940 941 942 943 944 945
    for (i = 0; i < height; i++) {
#define FILL(wfunc) \
        for (j = 0; j < width; j++) {\
            wfunc(ptr+2*j, v);\
        }
        if (big_endian) {
            FILL(AV_WB16);
        } else {
            FILL(AV_WL16);
        }
        ptr += stride;
    }
}

946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
#define MAX_SLICE_PLANES 4

/// Slice plane
typedef struct SwsPlane
{
    int available_lines;    ///< max number of lines that can be hold by this plane
    int sliceY;             ///< index of first line
    int sliceH;             ///< number of lines
    uint8_t **line;         ///< line buffer
    uint8_t **tmp;          ///< Tmp line buffer used by mmx code
} SwsPlane;

/**
 * Struct which defines a slice of an image to be scaled or a output for
 * a scaled slice.
 * A slice can also be used as intermediate ring buffer for scaling steps.
 */
typedef struct SwsSlice
{
    int width;              ///< Slice line width
    int h_chr_sub_sample;   ///< horizontal chroma subsampling factor
    int v_chr_sub_sample;   ///< vertical chroma subsampling factor
    int is_ring;            ///< flag to identify if this slice is a ring buffer
    int should_free_lines;  ///< flag to identify if there are dynamic allocated lines
    enum AVPixelFormat fmt; ///< planes pixel format
    SwsPlane plane[MAX_SLICE_PLANES];   ///< color planes
} SwsSlice;

/**
 * Struct which holds all necessary data for processing a slice.
 * A processing step can be a color conversion or horizontal/vertical scaling.
 */
typedef struct SwsFilterDescriptor
{
    SwsSlice *src;  ///< Source slice
    SwsSlice *dst;  ///< Output slice

    int alpha;      ///< Flag for processing alpha channel
    void *instance; ///< Filter instance data

    /// Function for processing input slice sliceH lines starting from line sliceY
    int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
} SwsFilterDescriptor;

/// Color conversion instance data
typedef struct ColorContext
{
    uint32_t *pal;
} ColorContext;

/// Scaler instance data
typedef struct FilterContext
{
    uint16_t *filter;
    int *filter_pos;
    int filter_size;
    int xInc;
} FilterContext;

P
Pedro Arthur 已提交
1005 1006 1007 1008 1009 1010 1011 1012 1013
typedef struct VScalerContext
{
    uint16_t *filter[2];
    int32_t  *filter_pos;
    int filter_size;
    int isMMX;
    void *pfn;
} VScalerContext;

1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
// warp input lines in the form (src + width*i + j) to slice format (line[i][j])
int ff_init_slice_from_src(SwsSlice * s, uint8_t *src[4], int stride[4], int srcW, int lumY, int lumH, int chrY, int chrH);

// Initialize scaler filter descriptor chain
int ff_init_filters(SwsContext *c);

// Free all filter data
int ff_free_filters(SwsContext *c);

/*
 function for applying ring buffer logic into slice s
 It checks if the slice can hold more @lum lines, if yes
 do nothing otherwise remove @lum least used lines.
P
Pedro Arthur 已提交
1027
 It applies the same procedure for @chr lines.
1028 1029 1030
*/
int ff_rotate_slice(SwsSlice *s, int lum, int chr);

P
Pedro Arthur 已提交
1031 1032 1033
/// initializes gamma conversion descriptor
int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice * src, uint16_t *table);

1034 1035 1036 1037 1038 1039
/// initializes lum pixel format conversion descriptor
int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal);

/// initializes lum horizontal scaling descriptor
int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);

P
Pedro Arthur 已提交
1040
/// initializes chr pixel format conversion descriptor
1041 1042 1043 1044 1045 1046 1047
int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal);

/// initializes chr horizontal scaling descriptor
int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);

int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst);

P
Pedro Arthur 已提交
1048 1049 1050 1051 1052 1053 1054 1055
/// initializes vertical scaling descriptors
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst);

/// setup vertical scaler functions
void ff_init_vscale_pfn(SwsContext *c, yuv2planar1_fn yuv2plane1, yuv2planarX_fn yuv2planeX,
    yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
    yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx);

1056 1057 1058
//number of extra lines to process
#define MAX_LINES_AHEAD 4

P
Pedro Arthur 已提交
1059
// enable use of refactored scaler code
P
Pedro Arthur 已提交
1060
#define NEW_FILTER
P
Pedro Arthur 已提交
1061

1062
#endif /* SWSCALE_SWSCALE_INTERNAL_H */