LCOV - code coverage report
Current view: top level - libswscale - swscale_internal.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 113 113 100.0 %
Date: 2017-10-24 00:14:43 Functions: 18 18 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2001-2011 Michael Niedermayer <michaelni@gmx.at>
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * 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 FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #ifndef SWSCALE_SWSCALE_INTERNAL_H
      22             : #define SWSCALE_SWSCALE_INTERNAL_H
      23             : 
      24             : #include "config.h"
      25             : #include "version.h"
      26             : 
      27             : #include "libavutil/avassert.h"
      28             : #include "libavutil/avutil.h"
      29             : #include "libavutil/common.h"
      30             : #include "libavutil/intreadwrite.h"
      31             : #include "libavutil/log.h"
      32             : #include "libavutil/pixfmt.h"
      33             : #include "libavutil/pixdesc.h"
      34             : #include "libavutil/ppc/util_altivec.h"
      35             : 
      36             : #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
      37             : 
      38             : #define YUVRGB_TABLE_HEADROOM 512
      39             : #define YUVRGB_TABLE_LUMA_HEADROOM 512
      40             : 
      41             : #define MAX_FILTER_SIZE SWS_MAX_FILTER_SIZE
      42             : 
      43             : #define DITHER1XBPP
      44             : 
      45             : #if HAVE_BIGENDIAN
      46             : #define ALT32_CORR (-1)
      47             : #else
      48             : #define ALT32_CORR   1
      49             : #endif
      50             : 
      51             : #if ARCH_X86_64
      52             : #   define APCK_PTR2  8
      53             : #   define APCK_COEF 16
      54             : #   define APCK_SIZE 24
      55             : #else
      56             : #   define APCK_PTR2  4
      57             : #   define APCK_COEF  8
      58             : #   define APCK_SIZE 16
      59             : #endif
      60             : 
      61             : #define RETCODE_USE_CASCADE -12345
      62             : 
      63             : struct SwsContext;
      64             : 
      65             : typedef enum SwsDither {
      66             :     SWS_DITHER_NONE = 0,
      67             :     SWS_DITHER_AUTO,
      68             :     SWS_DITHER_BAYER,
      69             :     SWS_DITHER_ED,
      70             :     SWS_DITHER_A_DITHER,
      71             :     SWS_DITHER_X_DITHER,
      72             :     NB_SWS_DITHER,
      73             : } SwsDither;
      74             : 
      75             : typedef enum SwsAlphaBlend {
      76             :     SWS_ALPHA_BLEND_NONE  = 0,
      77             :     SWS_ALPHA_BLEND_UNIFORM,
      78             :     SWS_ALPHA_BLEND_CHECKERBOARD,
      79             :     SWS_ALPHA_BLEND_NB,
      80             : } SwsAlphaBlend;
      81             : 
      82             : typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[],
      83             :                        int srcStride[], int srcSliceY, int srcSliceH,
      84             :                        uint8_t *dst[], int dstStride[]);
      85             : 
      86             : /**
      87             :  * Write one line of horizontally scaled data to planar output
      88             :  * without any additional vertical scaling (or point-scaling).
      89             :  *
      90             :  * @param src     scaled source data, 15 bits for 8-10-bit output,
      91             :  *                19 bits for 16-bit output (in int32_t)
      92             :  * @param dest    pointer to the output plane. For >8-bit
      93             :  *                output, this is in uint16_t
      94             :  * @param dstW    width of destination in pixels
      95             :  * @param dither  ordered dither array of type int16_t and size 8
      96             :  * @param offset  Dither offset
      97             :  */
      98             : typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW,
      99             :                                const uint8_t *dither, int offset);
     100             : 
     101             : /**
     102             :  * Write one line of horizontally scaled data to planar output
     103             :  * with multi-point vertical scaling between input pixels.
     104             :  *
     105             :  * @param filter        vertical luma/alpha scaling coefficients, 12 bits [0,4096]
     106             :  * @param src           scaled luma (Y) or alpha (A) source data, 15 bits for
     107             :  *                      8-10-bit output, 19 bits for 16-bit output (in int32_t)
     108             :  * @param filterSize    number of vertical input lines to scale
     109             :  * @param dest          pointer to output plane. For >8-bit
     110             :  *                      output, this is in uint16_t
     111             :  * @param dstW          width of destination pixels
     112             :  * @param offset        Dither offset
     113             :  */
     114             : typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize,
     115             :                                const int16_t **src, uint8_t *dest, int dstW,
     116             :                                const uint8_t *dither, int offset);
     117             : 
     118             : /**
     119             :  * Write one line of horizontally scaled chroma to interleaved output
     120             :  * with multi-point vertical scaling between input pixels.
     121             :  *
     122             :  * @param c             SWS scaling context
     123             :  * @param chrFilter     vertical chroma scaling coefficients, 12 bits [0,4096]
     124             :  * @param chrUSrc       scaled chroma (U) source data, 15 bits for 8-10-bit
     125             :  *                      output, 19 bits for 16-bit output (in int32_t)
     126             :  * @param chrVSrc       scaled chroma (V) source data, 15 bits for 8-10-bit
     127             :  *                      output, 19 bits for 16-bit output (in int32_t)
     128             :  * @param chrFilterSize number of vertical chroma input lines to scale
     129             :  * @param dest          pointer to the output plane. For >8-bit
     130             :  *                      output, this is in uint16_t
     131             :  * @param dstW          width of chroma planes
     132             :  */
     133             : typedef void (*yuv2interleavedX_fn)(struct SwsContext *c,
     134             :                                     const int16_t *chrFilter,
     135             :                                     int chrFilterSize,
     136             :                                     const int16_t **chrUSrc,
     137             :                                     const int16_t **chrVSrc,
     138             :                                     uint8_t *dest, int dstW);
     139             : 
     140             : /**
     141             :  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
     142             :  * output without any additional vertical scaling (or point-scaling). Note
     143             :  * that this function may do chroma scaling, see the "uvalpha" argument.
     144             :  *
     145             :  * @param c       SWS scaling context
     146             :  * @param lumSrc  scaled luma (Y) source data, 15 bits for 8-10-bit output,
     147             :  *                19 bits for 16-bit output (in int32_t)
     148             :  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
     149             :  *                19 bits for 16-bit output (in int32_t)
     150             :  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
     151             :  *                19 bits for 16-bit output (in int32_t)
     152             :  * @param alpSrc  scaled alpha (A) source data, 15 bits for 8-10-bit output,
     153             :  *                19 bits for 16-bit output (in int32_t)
     154             :  * @param dest    pointer to the output plane. For 16-bit output, this is
     155             :  *                uint16_t
     156             :  * @param dstW    width of lumSrc and alpSrc in pixels, number of pixels
     157             :  *                to write into dest[]
     158             :  * @param uvalpha chroma scaling coefficient for the second line of chroma
     159             :  *                pixels, either 2048 or 0. If 0, one chroma input is used
     160             :  *                for 2 output pixels (or if the SWS_FLAG_FULL_CHR_INT flag
     161             :  *                is set, it generates 1 output pixel). If 2048, two chroma
     162             :  *                input pixels should be averaged for 2 output pixels (this
     163             :  *                only happens if SWS_FLAG_FULL_CHR_INT is not set)
     164             :  * @param y       vertical line number for this output. This does not need
     165             :  *                to be used to calculate the offset in the destination,
     166             :  *                but can be used to generate comfort noise using dithering
     167             :  *                for some output formats.
     168             :  */
     169             : typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc,
     170             :                                const int16_t *chrUSrc[2],
     171             :                                const int16_t *chrVSrc[2],
     172             :                                const int16_t *alpSrc, uint8_t *dest,
     173             :                                int dstW, int uvalpha, int y);
     174             : /**
     175             :  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
     176             :  * output by doing bilinear scaling between two input lines.
     177             :  *
     178             :  * @param c       SWS scaling context
     179             :  * @param lumSrc  scaled luma (Y) source data, 15 bits for 8-10-bit output,
     180             :  *                19 bits for 16-bit output (in int32_t)
     181             :  * @param chrUSrc scaled chroma (U) source data, 15 bits for 8-10-bit output,
     182             :  *                19 bits for 16-bit output (in int32_t)
     183             :  * @param chrVSrc scaled chroma (V) source data, 15 bits for 8-10-bit output,
     184             :  *                19 bits for 16-bit output (in int32_t)
     185             :  * @param alpSrc  scaled alpha (A) source data, 15 bits for 8-10-bit output,
     186             :  *                19 bits for 16-bit output (in int32_t)
     187             :  * @param dest    pointer to the output plane. For 16-bit output, this is
     188             :  *                uint16_t
     189             :  * @param dstW    width of lumSrc and alpSrc in pixels, number of pixels
     190             :  *                to write into dest[]
     191             :  * @param yalpha  luma/alpha scaling coefficients for the second input line.
     192             :  *                The first line's coefficients can be calculated by using
     193             :  *                4096 - yalpha
     194             :  * @param uvalpha chroma scaling coefficient for the second input line. The
     195             :  *                first line's coefficients can be calculated by using
     196             :  *                4096 - uvalpha
     197             :  * @param y       vertical line number for this output. This does not need
     198             :  *                to be used to calculate the offset in the destination,
     199             :  *                but can be used to generate comfort noise using dithering
     200             :  *                for some output formats.
     201             :  */
     202             : typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2],
     203             :                                const int16_t *chrUSrc[2],
     204             :                                const int16_t *chrVSrc[2],
     205             :                                const int16_t *alpSrc[2],
     206             :                                uint8_t *dest,
     207             :                                int dstW, int yalpha, int uvalpha, int y);
     208             : /**
     209             :  * Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB
     210             :  * output by doing multi-point vertical scaling between input pixels.
     211             :  *
     212             :  * @param c             SWS scaling context
     213             :  * @param lumFilter     vertical luma/alpha scaling coefficients, 12 bits [0,4096]
     214             :  * @param lumSrc        scaled luma (Y) source data, 15 bits for 8-10-bit output,
     215             :  *                      19 bits for 16-bit output (in int32_t)
     216             :  * @param lumFilterSize number of vertical luma/alpha input lines to scale
     217             :  * @param chrFilter     vertical chroma scaling coefficients, 12 bits [0,4096]
     218             :  * @param chrUSrc       scaled chroma (U) source data, 15 bits for 8-10-bit output,
     219             :  *                      19 bits for 16-bit output (in int32_t)
     220             :  * @param chrVSrc       scaled chroma (V) source data, 15 bits for 8-10-bit output,
     221             :  *                      19 bits for 16-bit output (in int32_t)
     222             :  * @param chrFilterSize number of vertical chroma input lines to scale
     223             :  * @param alpSrc        scaled alpha (A) source data, 15 bits for 8-10-bit output,
     224             :  *                      19 bits for 16-bit output (in int32_t)
     225             :  * @param dest          pointer to the output plane. For 16-bit output, this is
     226             :  *                      uint16_t
     227             :  * @param dstW          width of lumSrc and alpSrc in pixels, number of pixels
     228             :  *                      to write into dest[]
     229             :  * @param y             vertical line number for this output. This does not need
     230             :  *                      to be used to calculate the offset in the destination,
     231             :  *                      but can be used to generate comfort noise using dithering
     232             :  *                      or some output formats.
     233             :  */
     234             : typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter,
     235             :                                const int16_t **lumSrc, int lumFilterSize,
     236             :                                const int16_t *chrFilter,
     237             :                                const int16_t **chrUSrc,
     238             :                                const int16_t **chrVSrc, int chrFilterSize,
     239             :                                const int16_t **alpSrc, uint8_t *dest,
     240             :                                int dstW, int y);
     241             : 
     242             : /**
     243             :  * Write one line of horizontally scaled Y/U/V/A to YUV/RGB
     244             :  * output by doing multi-point vertical scaling between input pixels.
     245             :  *
     246             :  * @param c             SWS scaling context
     247             :  * @param lumFilter     vertical luma/alpha scaling coefficients, 12 bits [0,4096]
     248             :  * @param lumSrc        scaled luma (Y) source data, 15 bits for 8-10-bit output,
     249             :  *                      19 bits for 16-bit output (in int32_t)
     250             :  * @param lumFilterSize number of vertical luma/alpha input lines to scale
     251             :  * @param chrFilter     vertical chroma scaling coefficients, 12 bits [0,4096]
     252             :  * @param chrUSrc       scaled chroma (U) source data, 15 bits for 8-10-bit output,
     253             :  *                      19 bits for 16-bit output (in int32_t)
     254             :  * @param chrVSrc       scaled chroma (V) source data, 15 bits for 8-10-bit output,
     255             :  *                      19 bits for 16-bit output (in int32_t)
     256             :  * @param chrFilterSize number of vertical chroma input lines to scale
     257             :  * @param alpSrc        scaled alpha (A) source data, 15 bits for 8-10-bit output,
     258             :  *                      19 bits for 16-bit output (in int32_t)
     259             :  * @param dest          pointer to the output planes. For 16-bit output, this is
     260             :  *                      uint16_t
     261             :  * @param dstW          width of lumSrc and alpSrc in pixels, number of pixels
     262             :  *                      to write into dest[]
     263             :  * @param y             vertical line number for this output. This does not need
     264             :  *                      to be used to calculate the offset in the destination,
     265             :  *                      but can be used to generate comfort noise using dithering
     266             :  *                      or some output formats.
     267             :  */
     268             : typedef void (*yuv2anyX_fn)(struct SwsContext *c, const int16_t *lumFilter,
     269             :                             const int16_t **lumSrc, int lumFilterSize,
     270             :                             const int16_t *chrFilter,
     271             :                             const int16_t **chrUSrc,
     272             :                             const int16_t **chrVSrc, int chrFilterSize,
     273             :                             const int16_t **alpSrc, uint8_t **dest,
     274             :                             int dstW, int y);
     275             : 
     276             : struct SwsSlice;
     277             : struct SwsFilterDescriptor;
     278             : 
     279             : /* This struct should be aligned on at least a 32-byte boundary. */
     280             : typedef struct SwsContext {
     281             :     /**
     282             :      * info on struct for av_log
     283             :      */
     284             :     const AVClass *av_class;
     285             : 
     286             :     /**
     287             :      * Note that src, dst, srcStride, dstStride will be copied in the
     288             :      * sws_scale() wrapper so they can be freely modified here.
     289             :      */
     290             :     SwsFunc swscale;
     291             :     int srcW;                     ///< Width  of source      luma/alpha planes.
     292             :     int srcH;                     ///< Height of source      luma/alpha planes.
     293             :     int dstH;                     ///< Height of destination luma/alpha planes.
     294             :     int chrSrcW;                  ///< Width  of source      chroma     planes.
     295             :     int chrSrcH;                  ///< Height of source      chroma     planes.
     296             :     int chrDstW;                  ///< Width  of destination chroma     planes.
     297             :     int chrDstH;                  ///< Height of destination chroma     planes.
     298             :     int lumXInc, chrXInc;
     299             :     int lumYInc, chrYInc;
     300             :     enum AVPixelFormat dstFormat; ///< Destination pixel format.
     301             :     enum AVPixelFormat srcFormat; ///< Source      pixel format.
     302             :     int dstFormatBpp;             ///< Number of bits per pixel of the destination pixel format.
     303             :     int srcFormatBpp;             ///< Number of bits per pixel of the source      pixel format.
     304             :     int dstBpc, srcBpc;
     305             :     int chrSrcHSubSample;         ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in source      image.
     306             :     int chrSrcVSubSample;         ///< Binary logarithm of vertical   subsampling factor between luma/alpha and chroma planes in source      image.
     307             :     int chrDstHSubSample;         ///< Binary logarithm of horizontal subsampling factor between luma/alpha and chroma planes in destination image.
     308             :     int chrDstVSubSample;         ///< Binary logarithm of vertical   subsampling factor between luma/alpha and chroma planes in destination image.
     309             :     int vChrDrop;                 ///< Binary logarithm of extra vertical subsampling factor in source image chroma planes specified by user.
     310             :     int sliceDir;                 ///< Direction that slices are fed to the scaler (1 = top-to-bottom, -1 = bottom-to-top).
     311             :     double param[2];              ///< Input parameters for scaling algorithms that need them.
     312             : 
     313             :     /* The cascaded_* fields allow spliting a scaler task into multiple
     314             :      * sequential steps, this is for example used to limit the maximum
     315             :      * downscaling factor that needs to be supported in one scaler.
     316             :      */
     317             :     struct SwsContext *cascaded_context[3];
     318             :     int cascaded_tmpStride[4];
     319             :     uint8_t *cascaded_tmp[4];
     320             :     int cascaded1_tmpStride[4];
     321             :     uint8_t *cascaded1_tmp[4];
     322             :     int cascaded_mainindex;
     323             : 
     324             :     double gamma_value;
     325             :     int gamma_flag;
     326             :     int is_internal_gamma;
     327             :     uint16_t *gamma;
     328             :     uint16_t *inv_gamma;
     329             : 
     330             :     int numDesc;
     331             :     int descIndex[2];
     332             :     int numSlice;
     333             :     struct SwsSlice *slice;
     334             :     struct SwsFilterDescriptor *desc;
     335             : 
     336             :     uint32_t pal_yuv[256];
     337             :     uint32_t pal_rgb[256];
     338             : 
     339             :     /**
     340             :      * @name Scaled horizontal lines ring buffer.
     341             :      * The horizontal scaler keeps just enough scaled lines in a ring buffer
     342             :      * so they may be passed to the vertical scaler. The pointers to the
     343             :      * allocated buffers for each line are duplicated in sequence in the ring
     344             :      * buffer to simplify indexing and avoid wrapping around between lines
     345             :      * inside the vertical scaler code. The wrapping is done before the
     346             :      * vertical scaler is called.
     347             :      */
     348             :     //@{
     349             :     int lastInLumBuf;             ///< Last scaled horizontal luma/alpha line from source in the ring buffer.
     350             :     int lastInChrBuf;             ///< Last scaled horizontal chroma     line from source in the ring buffer.
     351             :     int lumBufIndex;              ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source.
     352             :     int chrBufIndex;              ///< Index in ring buffer of the last scaled horizontal chroma     line from source.
     353             :     //@}
     354             : 
     355             :     uint8_t *formatConvBuffer;
     356             :     int needAlpha;
     357             : 
     358             :     /**
     359             :      * @name Horizontal and vertical filters.
     360             :      * To better understand the following fields, here is a pseudo-code of
     361             :      * their usage in filtering a horizontal line:
     362             :      * @code
     363             :      * for (i = 0; i < width; i++) {
     364             :      *     dst[i] = 0;
     365             :      *     for (j = 0; j < filterSize; j++)
     366             :      *         dst[i] += src[ filterPos[i] + j ] * filter[ filterSize * i + j ];
     367             :      *     dst[i] >>= FRAC_BITS; // The actual implementation is fixed-point.
     368             :      * }
     369             :      * @endcode
     370             :      */
     371             :     //@{
     372             :     int16_t *hLumFilter;          ///< Array of horizontal filter coefficients for luma/alpha planes.
     373             :     int16_t *hChrFilter;          ///< Array of horizontal filter coefficients for chroma     planes.
     374             :     int16_t *vLumFilter;          ///< Array of vertical   filter coefficients for luma/alpha planes.
     375             :     int16_t *vChrFilter;          ///< Array of vertical   filter coefficients for chroma     planes.
     376             :     int32_t *hLumFilterPos;       ///< Array of horizontal filter starting positions for each dst[i] for luma/alpha planes.
     377             :     int32_t *hChrFilterPos;       ///< Array of horizontal filter starting positions for each dst[i] for chroma     planes.
     378             :     int32_t *vLumFilterPos;       ///< Array of vertical   filter starting positions for each dst[i] for luma/alpha planes.
     379             :     int32_t *vChrFilterPos;       ///< Array of vertical   filter starting positions for each dst[i] for chroma     planes.
     380             :     int hLumFilterSize;           ///< Horizontal filter size for luma/alpha pixels.
     381             :     int hChrFilterSize;           ///< Horizontal filter size for chroma     pixels.
     382             :     int vLumFilterSize;           ///< Vertical   filter size for luma/alpha pixels.
     383             :     int vChrFilterSize;           ///< Vertical   filter size for chroma     pixels.
     384             :     //@}
     385             : 
     386             :     int lumMmxextFilterCodeSize;  ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for luma/alpha planes.
     387             :     int chrMmxextFilterCodeSize;  ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code size for chroma planes.
     388             :     uint8_t *lumMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for luma/alpha planes.
     389             :     uint8_t *chrMmxextFilterCode; ///< Runtime-generated MMXEXT horizontal fast bilinear scaler code for chroma planes.
     390             : 
     391             :     int canMMXEXTBeUsed;
     392             :     int warned_unuseable_bilinear;
     393             : 
     394             :     int dstY;                     ///< Last destination vertical line output from last slice.
     395             :     int flags;                    ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc...
     396             :     void *yuvTable;             // pointer to the yuv->rgb table start so it can be freed()
     397             :     // alignment ensures the offset can be added in a single
     398             :     // instruction on e.g. ARM
     399             :     DECLARE_ALIGNED(16, int, table_gV)[256 + 2*YUVRGB_TABLE_HEADROOM];
     400             :     uint8_t *table_rV[256 + 2*YUVRGB_TABLE_HEADROOM];
     401             :     uint8_t *table_gU[256 + 2*YUVRGB_TABLE_HEADROOM];
     402             :     uint8_t *table_bU[256 + 2*YUVRGB_TABLE_HEADROOM];
     403             :     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
     404             : #define RY_IDX 0
     405             : #define GY_IDX 1
     406             : #define BY_IDX 2
     407             : #define RU_IDX 3
     408             : #define GU_IDX 4
     409             : #define BU_IDX 5
     410             : #define RV_IDX 6
     411             : #define GV_IDX 7
     412             : #define BV_IDX 8
     413             : #define RGB2YUV_SHIFT 15
     414             : 
     415             :     int *dither_error[4];
     416             : 
     417             :     //Colorspace stuff
     418             :     int contrast, brightness, saturation;    // for sws_getColorspaceDetails
     419             :     int srcColorspaceTable[4];
     420             :     int dstColorspaceTable[4];
     421             :     int srcRange;                 ///< 0 = MPG YUV range, 1 = JPG YUV range (source      image).
     422             :     int dstRange;                 ///< 0 = MPG YUV range, 1 = JPG YUV range (destination image).
     423             :     int src0Alpha;
     424             :     int dst0Alpha;
     425             :     int srcXYZ;
     426             :     int dstXYZ;
     427             :     int src_h_chr_pos;
     428             :     int dst_h_chr_pos;
     429             :     int src_v_chr_pos;
     430             :     int dst_v_chr_pos;
     431             :     int yuv2rgb_y_offset;
     432             :     int yuv2rgb_y_coeff;
     433             :     int yuv2rgb_v2r_coeff;
     434             :     int yuv2rgb_v2g_coeff;
     435             :     int yuv2rgb_u2g_coeff;
     436             :     int yuv2rgb_u2b_coeff;
     437             : 
     438             : #define RED_DITHER            "0*8"
     439             : #define GREEN_DITHER          "1*8"
     440             : #define BLUE_DITHER           "2*8"
     441             : #define Y_COEFF               "3*8"
     442             : #define VR_COEFF              "4*8"
     443             : #define UB_COEFF              "5*8"
     444             : #define VG_COEFF              "6*8"
     445             : #define UG_COEFF              "7*8"
     446             : #define Y_OFFSET              "8*8"
     447             : #define U_OFFSET              "9*8"
     448             : #define V_OFFSET              "10*8"
     449             : #define LUM_MMX_FILTER_OFFSET "11*8"
     450             : #define CHR_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)
     451             : #define DSTW_OFFSET           "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2"
     452             : #define ESP_OFFSET            "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+8"
     453             : #define VROUNDER_OFFSET       "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+16"
     454             : #define U_TEMP                "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+24"
     455             : #define V_TEMP                "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+32"
     456             : #define Y_TEMP                "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+40"
     457             : #define ALP_MMX_FILTER_OFFSET "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*2+48"
     458             : #define UV_OFF_PX             "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+48"
     459             : #define UV_OFF_BYTE           "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+56"
     460             : #define DITHER16              "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+64"
     461             : #define DITHER32              "11*8+4*4*"AV_STRINGIFY(MAX_FILTER_SIZE)"*3+80"
     462             : #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
     463             : 
     464             :     DECLARE_ALIGNED(8, uint64_t, redDither);
     465             :     DECLARE_ALIGNED(8, uint64_t, greenDither);
     466             :     DECLARE_ALIGNED(8, uint64_t, blueDither);
     467             : 
     468             :     DECLARE_ALIGNED(8, uint64_t, yCoeff);
     469             :     DECLARE_ALIGNED(8, uint64_t, vrCoeff);
     470             :     DECLARE_ALIGNED(8, uint64_t, ubCoeff);
     471             :     DECLARE_ALIGNED(8, uint64_t, vgCoeff);
     472             :     DECLARE_ALIGNED(8, uint64_t, ugCoeff);
     473             :     DECLARE_ALIGNED(8, uint64_t, yOffset);
     474             :     DECLARE_ALIGNED(8, uint64_t, uOffset);
     475             :     DECLARE_ALIGNED(8, uint64_t, vOffset);
     476             :     int32_t lumMmxFilter[4 * MAX_FILTER_SIZE];
     477             :     int32_t chrMmxFilter[4 * MAX_FILTER_SIZE];
     478             :     int dstW;                     ///< Width  of destination luma/alpha planes.
     479             :     DECLARE_ALIGNED(8, uint64_t, esp);
     480             :     DECLARE_ALIGNED(8, uint64_t, vRounder);
     481             :     DECLARE_ALIGNED(8, uint64_t, u_temp);
     482             :     DECLARE_ALIGNED(8, uint64_t, v_temp);
     483             :     DECLARE_ALIGNED(8, uint64_t, y_temp);
     484             :     int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
     485             :     // alignment of these values is not necessary, but merely here
     486             :     // to maintain the same offset across x8632 and x86-64. Once we
     487             :     // use proper offset macros in the asm, they can be removed.
     488             :     DECLARE_ALIGNED(8, ptrdiff_t, uv_off); ///< offset (in pixels) between u and v planes
     489             :     DECLARE_ALIGNED(8, ptrdiff_t, uv_offx2); ///< offset (in bytes) between u and v planes
     490             :     DECLARE_ALIGNED(8, uint16_t, dither16)[8];
     491             :     DECLARE_ALIGNED(8, uint32_t, dither32)[8];
     492             : 
     493             :     const uint8_t *chrDither8, *lumDither8;
     494             : 
     495             : #if HAVE_ALTIVEC
     496             :     vector signed short   CY;
     497             :     vector signed short   CRV;
     498             :     vector signed short   CBU;
     499             :     vector signed short   CGU;
     500             :     vector signed short   CGV;
     501             :     vector signed short   OY;
     502             :     vector unsigned short CSHIFT;
     503             :     vector signed short  *vYCoeffsBank, *vCCoeffsBank;
     504             : #endif
     505             : 
     506             :     int use_mmx_vfilter;
     507             : 
     508             : /* pre defined color-spaces gamma */
     509             : #define XYZ_GAMMA (2.6f)
     510             : #define RGB_GAMMA (2.2f)
     511             :     int16_t *xyzgamma;
     512             :     int16_t *rgbgamma;
     513             :     int16_t *xyzgammainv;
     514             :     int16_t *rgbgammainv;
     515             :     int16_t xyz2rgb_matrix[3][4];
     516             :     int16_t rgb2xyz_matrix[3][4];
     517             : 
     518             :     /* function pointers for swscale() */
     519             :     yuv2planar1_fn yuv2plane1;
     520             :     yuv2planarX_fn yuv2planeX;
     521             :     yuv2interleavedX_fn yuv2nv12cX;
     522             :     yuv2packed1_fn yuv2packed1;
     523             :     yuv2packed2_fn yuv2packed2;
     524             :     yuv2packedX_fn yuv2packedX;
     525             :     yuv2anyX_fn yuv2anyX;
     526             : 
     527             :     /// Unscaled conversion of luma plane to YV12 for horizontal scaler.
     528             :     void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
     529             :                       int width, uint32_t *pal);
     530             :     /// Unscaled conversion of alpha plane to YV12 for horizontal scaler.
     531             :     void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3,
     532             :                       int width, uint32_t *pal);
     533             :     /// Unscaled conversion of chroma planes to YV12 for horizontal scaler.
     534             :     void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV,
     535             :                       const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
     536             :                       int width, uint32_t *pal);
     537             : 
     538             :     /**
     539             :      * Functions to read planar input, such as planar RGB, and convert
     540             :      * internally to Y/UV/A.
     541             :      */
     542             :     /** @{ */
     543             :     void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
     544             :     void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4],
     545             :                           int width, int32_t *rgb2yuv);
     546             :     void (*readAlpPlanar)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv);
     547             :     /** @} */
     548             : 
     549             :     /**
     550             :      * Scale one horizontal line of input data using a bilinear filter
     551             :      * to produce one line of output data. Compared to SwsContext->hScale(),
     552             :      * please take note of the following caveats when using these:
     553             :      * - Scaling is done using only 7 bits instead of 14-bit coefficients.
     554             :      * - You can use no more than 5 input pixels to produce 4 output
     555             :      *   pixels. Therefore, this filter should not be used for downscaling
     556             :      *   by more than ~20% in width (because that equals more than 5/4th
     557             :      *   downscaling and thus more than 5 pixels input per 4 pixels output).
     558             :      * - In general, bilinear filters create artifacts during downscaling
     559             :      *   (even when <20%), because one output pixel will span more than one
     560             :      *   input pixel, and thus some pixels will need edges of both neighbor
     561             :      *   pixels to interpolate the output pixel. Since you can use at most
     562             :      *   two input pixels per output pixel in bilinear scaling, this is
     563             :      *   impossible and thus downscaling by any size will create artifacts.
     564             :      * To enable this type of scaling, set SWS_FLAG_FAST_BILINEAR
     565             :      * in SwsContext->flags.
     566             :      */
     567             :     /** @{ */
     568             :     void (*hyscale_fast)(struct SwsContext *c,
     569             :                          int16_t *dst, int dstWidth,
     570             :                          const uint8_t *src, int srcW, int xInc);
     571             :     void (*hcscale_fast)(struct SwsContext *c,
     572             :                          int16_t *dst1, int16_t *dst2, int dstWidth,
     573             :                          const uint8_t *src1, const uint8_t *src2,
     574             :                          int srcW, int xInc);
     575             :     /** @} */
     576             : 
     577             :     /**
     578             :      * Scale one horizontal line of input data using a filter over the input
     579             :      * lines, to produce one (differently sized) line of output data.
     580             :      *
     581             :      * @param dst        pointer to destination buffer for horizontally scaled
     582             :      *                   data. If the number of bits per component of one
     583             :      *                   destination pixel (SwsContext->dstBpc) is <= 10, data
     584             :      *                   will be 15 bpc in 16 bits (int16_t) width. Else (i.e.
     585             :      *                   SwsContext->dstBpc == 16), data will be 19bpc in
     586             :      *                   32 bits (int32_t) width.
     587             :      * @param dstW       width of destination image
     588             :      * @param src        pointer to source data to be scaled. If the number of
     589             :      *                   bits per component of a source pixel (SwsContext->srcBpc)
     590             :      *                   is 8, this is 8bpc in 8 bits (uint8_t) width. Else
     591             :      *                   (i.e. SwsContext->dstBpc > 8), this is native depth
     592             :      *                   in 16 bits (uint16_t) width. In other words, for 9-bit
     593             :      *                   YUV input, this is 9bpc, for 10-bit YUV input, this is
     594             :      *                   10bpc, and for 16-bit RGB or YUV, this is 16bpc.
     595             :      * @param filter     filter coefficients to be used per output pixel for
     596             :      *                   scaling. This contains 14bpp filtering coefficients.
     597             :      *                   Guaranteed to contain dstW * filterSize entries.
     598             :      * @param filterPos  position of the first input pixel to be used for
     599             :      *                   each output pixel during scaling. Guaranteed to
     600             :      *                   contain dstW entries.
     601             :      * @param filterSize the number of input coefficients to be used (and
     602             :      *                   thus the number of input pixels to be used) for
     603             :      *                   creating a single output pixel. Is aligned to 4
     604             :      *                   (and input coefficients thus padded with zeroes)
     605             :      *                   to simplify creating SIMD code.
     606             :      */
     607             :     /** @{ */
     608             :     void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW,
     609             :                     const uint8_t *src, const int16_t *filter,
     610             :                     const int32_t *filterPos, int filterSize);
     611             :     void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW,
     612             :                     const uint8_t *src, const int16_t *filter,
     613             :                     const int32_t *filterPos, int filterSize);
     614             :     /** @} */
     615             : 
     616             :     /// Color range conversion function for luma plane if needed.
     617             :     void (*lumConvertRange)(int16_t *dst, int width);
     618             :     /// Color range conversion function for chroma planes if needed.
     619             :     void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width);
     620             : 
     621             :     int needs_hcscale; ///< Set if there are chroma planes to be converted.
     622             : 
     623             :     SwsDither dither;
     624             : 
     625             :     SwsAlphaBlend alphablend;
     626             : } SwsContext;
     627             : //FIXME check init (where 0)
     628             : 
     629             : SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c);
     630             : int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
     631             :                              int fullRange, int brightness,
     632             :                              int contrast, int saturation);
     633             : void ff_yuv2rgb_init_tables_ppc(SwsContext *c, const int inv_table[4],
     634             :                                 int brightness, int contrast, int saturation);
     635             : 
     636             : void ff_updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufIndex,
     637             :                            int lastInLumBuf, int lastInChrBuf);
     638             : 
     639             : av_cold void ff_sws_init_range_convert(SwsContext *c);
     640             : 
     641             : SwsFunc ff_yuv2rgb_init_x86(SwsContext *c);
     642             : SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c);
     643             : 
     644       95167 : static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
     645             : {
     646       95167 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     647       95167 :     av_assert0(desc);
     648       95167 :     return desc->comp[0].depth == 16;
     649             : }
     650             : 
     651       96702 : static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
     652             : {
     653       96702 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     654       96702 :     av_assert0(desc);
     655       96702 :     return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
     656             : }
     657             : 
     658   385793781 : static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
     659             : {
     660   385793781 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     661   385793781 :     av_assert0(desc);
     662   385793781 :     return desc->flags & AV_PIX_FMT_FLAG_BE;
     663             : }
     664             : 
     665      163931 : static av_always_inline int isYUV(enum AVPixelFormat pix_fmt)
     666             : {
     667      163931 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     668      163931 :     av_assert0(desc);
     669      163931 :     return !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
     670             : }
     671             : 
     672      107281 : static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
     673             : {
     674      107281 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     675      107281 :     av_assert0(desc);
     676      107281 :     return ((desc->flags & AV_PIX_FMT_FLAG_PLANAR) && isYUV(pix_fmt));
     677             : }
     678             : 
     679         182 : static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
     680             : {
     681         182 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     682         182 :     av_assert0(desc);
     683         182 :     return (desc->flags & AV_PIX_FMT_FLAG_RGB);
     684             : }
     685             : 
     686      142370 : static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
     687             : {
     688      142370 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     689      142370 :     av_assert0(desc);
     690      280716 :     return !(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
     691      276678 :            !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
     692      147885 :            desc->nb_components <= 2 &&
     693      151728 :            pix_fmt != AV_PIX_FMT_MONOBLACK &&
     694             :            pix_fmt != AV_PIX_FMT_MONOWHITE;
     695             : }
     696             : 
     697        4607 : static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
     698             : {
     699        4603 :     return pix_fmt == AV_PIX_FMT_RGB48BE     ||
     700        4602 :            pix_fmt == AV_PIX_FMT_RGB48LE     ||
     701        3924 :            pix_fmt == AV_PIX_FMT_RGB32       ||
     702        3923 :            pix_fmt == AV_PIX_FMT_RGB32_1     ||
     703        1737 :            pix_fmt == AV_PIX_FMT_RGB24       ||
     704        1736 :            pix_fmt == AV_PIX_FMT_RGB565BE    ||
     705        1542 :            pix_fmt == AV_PIX_FMT_RGB565LE    ||
     706        1541 :            pix_fmt == AV_PIX_FMT_RGB555BE    ||
     707         442 :            pix_fmt == AV_PIX_FMT_RGB555LE    ||
     708         441 :            pix_fmt == AV_PIX_FMT_RGB444BE    ||
     709         440 :            pix_fmt == AV_PIX_FMT_RGB444LE    ||
     710         438 :            pix_fmt == AV_PIX_FMT_RGB8        ||
     711         437 :            pix_fmt == AV_PIX_FMT_RGB4        ||
     712         435 :            pix_fmt == AV_PIX_FMT_RGB4_BYTE   ||
     713         431 :            pix_fmt == AV_PIX_FMT_RGBA64BE    ||
     714         430 :            pix_fmt == AV_PIX_FMT_RGBA64LE    ||
     715        5036 :            pix_fmt == AV_PIX_FMT_MONOBLACK   ||
     716             :            pix_fmt == AV_PIX_FMT_MONOWHITE;
     717             : }
     718             : 
     719        2872 : static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
     720             : {
     721        2871 :     return pix_fmt == AV_PIX_FMT_BGR48BE     ||
     722        2870 :            pix_fmt == AV_PIX_FMT_BGR48LE     ||
     723        2861 :            pix_fmt == AV_PIX_FMT_BGR32       ||
     724        2854 :            pix_fmt == AV_PIX_FMT_BGR32_1     ||
     725        2773 :            pix_fmt == AV_PIX_FMT_BGR24       ||
     726        2772 :            pix_fmt == AV_PIX_FMT_BGR565BE    ||
     727        2771 :            pix_fmt == AV_PIX_FMT_BGR565LE    ||
     728        2770 :            pix_fmt == AV_PIX_FMT_BGR555BE    ||
     729        2415 :            pix_fmt == AV_PIX_FMT_BGR555LE    ||
     730        2414 :            pix_fmt == AV_PIX_FMT_BGR444BE    ||
     731        2413 :            pix_fmt == AV_PIX_FMT_BGR444LE    ||
     732        2410 :            pix_fmt == AV_PIX_FMT_BGR8        ||
     733        2409 :            pix_fmt == AV_PIX_FMT_BGR4        ||
     734        2407 :            pix_fmt == AV_PIX_FMT_BGR4_BYTE   ||
     735        2406 :            pix_fmt == AV_PIX_FMT_BGRA64BE    ||
     736        2405 :            pix_fmt == AV_PIX_FMT_BGRA64LE    ||
     737        5276 :            pix_fmt == AV_PIX_FMT_MONOBLACK   ||
     738             :            pix_fmt == AV_PIX_FMT_MONOWHITE;
     739             : }
     740             : 
     741       42722 : static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
     742             : {
     743       42722 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     744       42722 :     av_assert0(desc);
     745       42722 :     return !!(desc->flags & AV_PIX_FMT_FLAG_BAYER);
     746             : }
     747             : 
     748     5225651 : static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
     749             : {
     750     5225651 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     751     5225651 :     av_assert0(desc);
     752     6851298 :     return (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
     753     6850677 :             pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
     754             : }
     755             : 
     756      111700 : static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
     757             : {
     758      111700 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     759      111700 :     av_assert0(desc);
     760      111700 :     if (pix_fmt == AV_PIX_FMT_PAL8)
     761        4149 :         return 1;
     762      107551 :     return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
     763             : }
     764             : 
     765       30953 : static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
     766             : {
     767       30953 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     768       30953 :     av_assert0(desc);
     769       61291 :     return (desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
     770       25140 :             pix_fmt == AV_PIX_FMT_PAL8 ||
     771       56090 :             pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
     772             : }
     773             : 
     774      105945 : static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
     775             : {
     776      105945 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     777      105945 :     av_assert0(desc);
     778      105945 :     return (desc->nb_components >= 2 && (desc->flags & AV_PIX_FMT_FLAG_PLANAR));
     779             : }
     780             : 
     781        2227 : static av_always_inline int isPackedRGB(enum AVPixelFormat pix_fmt)
     782             : {
     783        2227 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     784        2227 :     av_assert0(desc);
     785        2227 :     return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) == AV_PIX_FMT_FLAG_RGB);
     786             : }
     787             : 
     788        3462 : static av_always_inline int isPlanarRGB(enum AVPixelFormat pix_fmt)
     789             : {
     790        3462 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     791        3462 :     av_assert0(desc);
     792        3462 :     return ((desc->flags & (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB)) ==
     793             :             (AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB));
     794             : }
     795             : 
     796       72912 : static av_always_inline int usePal(enum AVPixelFormat pix_fmt)
     797             : {
     798       72912 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     799       72912 :     av_assert0(desc);
     800       72912 :     return (desc->flags & AV_PIX_FMT_FLAG_PAL) || (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL);
     801             : }
     802             : 
     803             : extern const uint64_t ff_dither4[2];
     804             : extern const uint64_t ff_dither8[2];
     805             : 
     806             : extern const uint8_t ff_dither_2x2_4[3][8];
     807             : extern const uint8_t ff_dither_2x2_8[3][8];
     808             : extern const uint8_t ff_dither_4x4_16[5][8];
     809             : extern const uint8_t ff_dither_8x8_32[9][8];
     810             : extern const uint8_t ff_dither_8x8_73[9][8];
     811             : extern const uint8_t ff_dither_8x8_128[9][8];
     812             : extern const uint8_t ff_dither_8x8_220[9][8];
     813             : 
     814             : extern const int32_t ff_yuv2rgb_coeffs[11][4];
     815             : 
     816             : extern const AVClass ff_sws_context_class;
     817             : 
     818             : /**
     819             :  * Set c->swscale to an unscaled converter if one exists for the specific
     820             :  * source and destination formats, bit depths, flags, etc.
     821             :  */
     822             : void ff_get_unscaled_swscale(SwsContext *c);
     823             : void ff_get_unscaled_swscale_ppc(SwsContext *c);
     824             : void ff_get_unscaled_swscale_arm(SwsContext *c);
     825             : void ff_get_unscaled_swscale_aarch64(SwsContext *c);
     826             : 
     827             : /**
     828             :  * Return function pointer to fastest main scaler path function depending
     829             :  * on architecture and available optimizations.
     830             :  */
     831             : SwsFunc ff_getSwsFunc(SwsContext *c);
     832             : 
     833             : void ff_sws_init_input_funcs(SwsContext *c);
     834             : void ff_sws_init_output_funcs(SwsContext *c,
     835             :                               yuv2planar1_fn *yuv2plane1,
     836             :                               yuv2planarX_fn *yuv2planeX,
     837             :                               yuv2interleavedX_fn *yuv2nv12cX,
     838             :                               yuv2packed1_fn *yuv2packed1,
     839             :                               yuv2packed2_fn *yuv2packed2,
     840             :                               yuv2packedX_fn *yuv2packedX,
     841             :                               yuv2anyX_fn *yuv2anyX);
     842             : void ff_sws_init_swscale_ppc(SwsContext *c);
     843             : void ff_sws_init_swscale_x86(SwsContext *c);
     844             : void ff_sws_init_swscale_aarch64(SwsContext *c);
     845             : void ff_sws_init_swscale_arm(SwsContext *c);
     846             : 
     847             : void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
     848             :                        const uint8_t *src, int srcW, int xInc);
     849             : void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
     850             :                        int dstWidth, const uint8_t *src1,
     851             :                        const uint8_t *src2, int srcW, int xInc);
     852             : int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
     853             :                            int16_t *filter, int32_t *filterPos,
     854             :                            int numSplits);
     855             : void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
     856             :                             int dstWidth, const uint8_t *src,
     857             :                             int srcW, int xInc);
     858             : void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
     859             :                             int dstWidth, const uint8_t *src1,
     860             :                             const uint8_t *src2, int srcW, int xInc);
     861             : 
     862             : /**
     863             :  * Allocate and return an SwsContext.
     864             :  * This is like sws_getContext() but does not perform the init step, allowing
     865             :  * the user to set additional AVOptions.
     866             :  *
     867             :  * @see sws_getContext()
     868             :  */
     869             : struct SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
     870             :                                       int dstW, int dstH, enum AVPixelFormat dstFormat,
     871             :                                       int flags, const double *param);
     872             : 
     873             : int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[],
     874             :                           int srcStride[], int srcSliceY, int srcSliceH,
     875             :                           uint8_t *dst[], int dstStride[]);
     876             : 
     877         446 : static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
     878             :                                int alpha, int bits, const int big_endian)
     879             : {
     880             :     int i, j;
     881         446 :     uint8_t *ptr = plane + stride * y;
     882         446 :     int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
     883      128894 :     for (i = 0; i < height; i++) {
     884             : #define FILL(wfunc) \
     885             :         for (j = 0; j < width; j++) {\
     886             :             wfunc(ptr+2*j, v);\
     887             :         }
     888      128448 :         if (big_endian) {
     889       64512 :             FILL(AV_WB16);
     890             :         } else {
     891       63936 :             FILL(AV_WL16);
     892             :         }
     893      128448 :         ptr += stride;
     894             :     }
     895         446 : }
     896             : 
     897             : #define MAX_SLICE_PLANES 4
     898             : 
     899             : /// Slice plane
     900             : typedef struct SwsPlane
     901             : {
     902             :     int available_lines;    ///< max number of lines that can be hold by this plane
     903             :     int sliceY;             ///< index of first line
     904             :     int sliceH;             ///< number of lines
     905             :     uint8_t **line;         ///< line buffer
     906             :     uint8_t **tmp;          ///< Tmp line buffer used by mmx code
     907             : } SwsPlane;
     908             : 
     909             : /**
     910             :  * Struct which defines a slice of an image to be scaled or an output for
     911             :  * a scaled slice.
     912             :  * A slice can also be used as intermediate ring buffer for scaling steps.
     913             :  */
     914             : typedef struct SwsSlice
     915             : {
     916             :     int width;              ///< Slice line width
     917             :     int h_chr_sub_sample;   ///< horizontal chroma subsampling factor
     918             :     int v_chr_sub_sample;   ///< vertical chroma subsampling factor
     919             :     int is_ring;            ///< flag to identify if this slice is a ring buffer
     920             :     int should_free_lines;  ///< flag to identify if there are dynamic allocated lines
     921             :     enum AVPixelFormat fmt; ///< planes pixel format
     922             :     SwsPlane plane[MAX_SLICE_PLANES];   ///< color planes
     923             : } SwsSlice;
     924             : 
     925             : /**
     926             :  * Struct which holds all necessary data for processing a slice.
     927             :  * A processing step can be a color conversion or horizontal/vertical scaling.
     928             :  */
     929             : typedef struct SwsFilterDescriptor
     930             : {
     931             :     SwsSlice *src;  ///< Source slice
     932             :     SwsSlice *dst;  ///< Output slice
     933             : 
     934             :     int alpha;      ///< Flag for processing alpha channel
     935             :     void *instance; ///< Filter instance data
     936             : 
     937             :     /// Function for processing input slice sliceH lines starting from line sliceY
     938             :     int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
     939             : } SwsFilterDescriptor;
     940             : 
     941             : // warp input lines in the form (src + width*i + j) to slice format (line[i][j])
     942             : // relative=true means first line src[x][0] otherwise first line is src[x][lum/crh Y]
     943             : 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, int relative);
     944             : 
     945             : // Initialize scaler filter descriptor chain
     946             : int ff_init_filters(SwsContext *c);
     947             : 
     948             : // Free all filter data
     949             : int ff_free_filters(SwsContext *c);
     950             : 
     951             : /*
     952             :  function for applying ring buffer logic into slice s
     953             :  It checks if the slice can hold more @lum lines, if yes
     954             :  do nothing otherwise remove @lum least used lines.
     955             :  It applies the same procedure for @chr lines.
     956             : */
     957             : int ff_rotate_slice(SwsSlice *s, int lum, int chr);
     958             : 
     959             : /// initializes gamma conversion descriptor
     960             : int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice * src, uint16_t *table);
     961             : 
     962             : /// initializes lum pixel format conversion descriptor
     963             : int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal);
     964             : 
     965             : /// initializes lum horizontal scaling descriptor
     966             : int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
     967             : 
     968             : /// initializes chr pixel format conversion descriptor
     969             : int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal);
     970             : 
     971             : /// initializes chr horizontal scaling descriptor
     972             : int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
     973             : 
     974             : int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst);
     975             : 
     976             : /// initializes vertical scaling descriptors
     977             : int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst);
     978             : 
     979             : /// setup vertical scaler functions
     980             : void ff_init_vscale_pfn(SwsContext *c, yuv2planar1_fn yuv2plane1, yuv2planarX_fn yuv2planeX,
     981             :     yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
     982             :     yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx);
     983             : 
     984             : //number of extra lines to process
     985             : #define MAX_LINES_AHEAD 4
     986             : 
     987             : #endif /* SWSCALE_SWSCALE_INTERNAL_H */

Generated by: LCOV version 1.13