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

Generated by: LCOV version 1.12