[libav.git] / libswscale / swscale_internal.h

/*
 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef SWSCALE_SWSCALE_INTERNAL_H
#define SWSCALE_SWSCALE_INTERNAL_H

#include "config.h"

#ifdef HAVE_ALTIVEC_H
#include <altivec.h>
#endif

#include "libavutil/avutil.h"

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

#define MAX_FILTER_SIZE 256

#define VOFW 2048
#define VOF  (VOFW*2)

#ifdef WORDS_BIGENDIAN
#define ALT32_CORR (-1)
#else
#define ALT32_CORR   1
#endif

#ifdef ARCH_X86_64
#   define APCK_PTR2 8
#   define APCK_COEF 16
#   define APCK_SIZE 24
#else
#   define APCK_PTR2 4
#   define APCK_COEF 8
#   define APCK_SIZE 16
#endif

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

/* This struct should be aligned on at least a 32-byte boundary. */
typedef struct SwsContext{
    /**
     * info on struct for av_log
     */
    const AVClass *av_class;

    /**
     * Note that src, dst, srcStride, dstStride will be copied in the
     * sws_scale() wrapper so they can be freely modified here.
     */
    SwsFunc swScale;
    int srcW, srcH, dstH;
    int chrSrcW, chrSrcH, chrDstW, chrDstH;
    int lumXInc, chrXInc;
    int lumYInc, chrYInc;
    enum PixelFormat dstFormat, srcFormat;  ///< format 4:2:0 type is always YV12
    int origDstFormat, origSrcFormat;       ///< format
    int chrSrcHSubSample, chrSrcVSubSample;
    int chrIntHSubSample, chrIntVSubSample;
    int chrDstHSubSample, chrDstVSubSample;
    int vChrDrop;
    int sliceDir;
    double param[2];

    uint32_t pal_yuv[256];
    uint32_t pal_rgb[256];

    int16_t **lumPixBuf;
    int16_t **chrPixBuf;
    int16_t *hLumFilter;
    int16_t *hLumFilterPos;
    int16_t *hChrFilter;
    int16_t *hChrFilterPos;
    int16_t *vLumFilter;
    int16_t *vLumFilterPos;
    int16_t *vChrFilter;
    int16_t *vChrFilterPos;

    uint8_t formatConvBuffer[VOF]; //FIXME dynamic allocation, but we have to change a lot of code for this to be useful

    int hLumFilterSize;
    int hChrFilterSize;
    int vLumFilterSize;
    int vChrFilterSize;
    int vLumBufSize;
    int vChrBufSize;

    uint8_t *funnyYCode;
    uint8_t *funnyUVCode;
    int32_t *lumMmx2FilterPos;
    int32_t *chrMmx2FilterPos;
    int16_t *lumMmx2Filter;
    int16_t *chrMmx2Filter;

    int canMMX2BeUsed;

    int lastInLumBuf;
    int lastInChrBuf;
    int lumBufIndex;
    int chrBufIndex;
    int dstY;
    int flags;
    void * yuvTable;            // pointer to the yuv->rgb table start so it can be freed()
    uint8_t * table_rV[256];
    uint8_t * table_gU[256];
    int    table_gV[256];
    uint8_t * table_bU[256];

    //Colorspace stuff
    int contrast, brightness, saturation;    // for sws_getColorspaceDetails
    int srcColorspaceTable[4];
    int dstColorspaceTable[4];
    int srcRange, dstRange;
    int yuv2rgb_y_offset;
    int yuv2rgb_y_coeff;
    int yuv2rgb_v2r_coeff;
    int yuv2rgb_v2g_coeff;
    int yuv2rgb_u2g_coeff;
    int yuv2rgb_u2b_coeff;

#define RED_DITHER            "0*8"
#define GREEN_DITHER          "1*8"
#define BLUE_DITHER           "2*8"
#define Y_COEFF               "3*8"
#define VR_COEFF              "4*8"
#define UB_COEFF              "5*8"
#define VG_COEFF              "6*8"
#define UG_COEFF              "7*8"
#define Y_OFFSET              "8*8"
#define U_OFFSET              "9*8"
#define V_OFFSET              "10*8"
#define LUM_MMX_FILTER_OFFSET "11*8"
#define CHR_MMX_FILTER_OFFSET "11*8+4*4*256"
#define DSTW_OFFSET           "11*8+4*4*256*2" //do not change, it is hardcoded in the ASM
#define ESP_OFFSET            "11*8+4*4*256*2+8"
#define VROUNDER_OFFSET       "11*8+4*4*256*2+16"
#define U_TEMP                "11*8+4*4*256*2+24"
#define V_TEMP                "11*8+4*4*256*2+32"

    uint64_t redDither   __attribute__((aligned(8)));
    uint64_t greenDither __attribute__((aligned(8)));
    uint64_t blueDither  __attribute__((aligned(8)));

    uint64_t yCoeff      __attribute__((aligned(8)));
    uint64_t vrCoeff     __attribute__((aligned(8)));
    uint64_t ubCoeff     __attribute__((aligned(8)));
    uint64_t vgCoeff     __attribute__((aligned(8)));
    uint64_t ugCoeff     __attribute__((aligned(8)));
    uint64_t yOffset     __attribute__((aligned(8)));
    uint64_t uOffset     __attribute__((aligned(8)));
    uint64_t vOffset     __attribute__((aligned(8)));
    int32_t  lumMmxFilter[4*MAX_FILTER_SIZE];
    int32_t  chrMmxFilter[4*MAX_FILTER_SIZE];
    int dstW;
    uint64_t esp          __attribute__((aligned(8)));
    uint64_t vRounder     __attribute__((aligned(8)));
    uint64_t u_temp       __attribute__((aligned(8)));
    uint64_t v_temp       __attribute__((aligned(8)));

#ifdef HAVE_ALTIVEC

  vector signed short   CY;
  vector signed short   CRV;
  vector signed short   CBU;
  vector signed short   CGU;
  vector signed short   CGV;
  vector signed short   OY;
  vector unsigned short CSHIFT;
  vector signed short   *vYCoeffsBank, *vCCoeffsBank;

#endif


#ifdef ARCH_BFIN
    uint32_t oy           __attribute__((aligned(4)));
    uint32_t oc           __attribute__((aligned(4)));
    uint32_t zero         __attribute__((aligned(4)));
    uint32_t cy           __attribute__((aligned(4)));
    uint32_t crv          __attribute__((aligned(4)));
    uint32_t rmask        __attribute__((aligned(4)));
    uint32_t cbu          __attribute__((aligned(4)));
    uint32_t bmask        __attribute__((aligned(4)));
    uint32_t cgu          __attribute__((aligned(4)));
    uint32_t cgv          __attribute__((aligned(4)));
    uint32_t gmask        __attribute__((aligned(4)));
#endif

#ifdef HAVE_VIS
    uint64_t sparc_coeffs[10] __attribute__((aligned(8)));
#endif

} SwsContext;
//FIXME check init (where 0)

SwsFunc yuv2rgb_get_func_ptr (SwsContext *c);
int yuv2rgb_c_init_tables (SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation);

void yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4],int brightness,int contrast, int saturation);
SwsFunc yuv2rgb_init_altivec (SwsContext *c);
void altivec_yuv2packedX (SwsContext *c,
                          int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
                          int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
                          uint8_t *dest, int dstW, int dstY);

const char *sws_format_name(int format);

//FIXME replace this with something faster
#define isPlanarYUV(x)  (           \
           (x)==PIX_FMT_YUV410P     \
        || (x)==PIX_FMT_YUV420P     \
        || (x)==PIX_FMT_YUV411P     \
        || (x)==PIX_FMT_YUV422P     \
        || (x)==PIX_FMT_YUV444P     \
        || (x)==PIX_FMT_YUV440P     \
        || (x)==PIX_FMT_NV12        \
        || (x)==PIX_FMT_NV21        \
    )
#define isYUV(x)        (           \
           (x)==PIX_FMT_UYVY422     \
        || (x)==PIX_FMT_YUYV422     \
        || isPlanarYUV(x)           \
    )
#define isGray(x)       (           \
           (x)==PIX_FMT_GRAY8       \
        || (x)==PIX_FMT_GRAY16BE    \
        || (x)==PIX_FMT_GRAY16LE    \
    )
#define isGray16(x)     (           \
           (x)==PIX_FMT_GRAY16BE    \
        || (x)==PIX_FMT_GRAY16LE    \
    )
#define isRGB(x)        (           \
           (x)==PIX_FMT_RGB32       \
        || (x)==PIX_FMT_RGB32_1     \
        || (x)==PIX_FMT_RGB24       \
        || (x)==PIX_FMT_RGB565      \
        || (x)==PIX_FMT_RGB555      \
        || (x)==PIX_FMT_RGB8        \
        || (x)==PIX_FMT_RGB4        \
        || (x)==PIX_FMT_RGB4_BYTE   \
        || (x)==PIX_FMT_MONOBLACK   \
        || (x)==PIX_FMT_MONOWHITE   \
    )
#define isBGR(x)        (           \
           (x)==PIX_FMT_BGR32       \
        || (x)==PIX_FMT_BGR32_1     \
        || (x)==PIX_FMT_BGR24       \
        || (x)==PIX_FMT_BGR565      \
        || (x)==PIX_FMT_BGR555      \
        || (x)==PIX_FMT_BGR8        \
        || (x)==PIX_FMT_BGR4        \
        || (x)==PIX_FMT_BGR4_BYTE   \
        || (x)==PIX_FMT_MONOBLACK   \
        || (x)==PIX_FMT_MONOWHITE   \
    )

static inline int fmt_depth(int fmt)
{
    switch(fmt) {
        case PIX_FMT_BGRA:
        case PIX_FMT_ABGR:
        case PIX_FMT_RGBA:
        case PIX_FMT_ARGB:
            return 32;
        case PIX_FMT_BGR24:
        case PIX_FMT_RGB24:
            return 24;
        case PIX_FMT_BGR565:
        case PIX_FMT_RGB565:
        case PIX_FMT_GRAY16BE:
        case PIX_FMT_GRAY16LE:
            return 16;
        case PIX_FMT_BGR555:
        case PIX_FMT_RGB555:
            return 15;
        case PIX_FMT_BGR8:
        case PIX_FMT_RGB8:
            return 8;
        case PIX_FMT_BGR4:
        case PIX_FMT_RGB4:
        case PIX_FMT_BGR4_BYTE:
        case PIX_FMT_RGB4_BYTE:
            return 4;
        case PIX_FMT_MONOBLACK:
        case PIX_FMT_MONOWHITE:
            return 1;
        default:
            return 0;
    }
}

extern const DECLARE_ALIGNED(8, uint64_t, ff_dither4[2]);
extern const DECLARE_ALIGNED(8, uint64_t, ff_dither8[2]);

extern const AVClass sws_context_class;

#endif /* SWSCALE_SWSCALE_INTERNAL_H */
Commit	Line	Data
5427e242	1	/*
d026b45e DB	2	* Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
	3	*
	4	* This file is part of FFmpeg.
	5	*
807e0c66 LA	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.
d026b45e DB	10	*
	11	* FFmpeg is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
807e0c66 LA	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
807e0c66 LA	14	* Lesser General Public License for more details.
d026b45e	15	*
807e0c66 LA	16	* You should have received a copy of the GNU Lesser General Public
807e0c66 LA	17	* License along with FFmpeg; if not, write to the Free Software
b19bcbaa	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
d026b45e	19	*/
5427e242	20
0eaf5235 SS	21	#ifndef SWSCALE_SWSCALE_INTERNAL_H
0eaf5235 SS	22	#define SWSCALE_SWSCALE_INTERNAL_H
5427e242	23
4706949c DB	24	#include "config.h"
4706949c DB	25
f2015f0c AB	26	#ifdef HAVE_ALTIVEC_H
	27	#include <altivec.h>
	28	#endif
	29
83da2c6f	30	#include "libavutil/avutil.h"
94c4def2	31
59ded10c	32	#define STR(s) AV_TOSTRING(s) //AV_STRINGIFY is too long
1625216e	33
5427e242 MN	34	#define MAX_FILTER_SIZE 256
5427e242 MN	35
8b2fce0d	36	#define VOFW 2048
710af50e	37	#define VOF (VOFW*2)
8b2fce0d	38
9990e426 MN	39	#ifdef WORDS_BIGENDIAN
	40	#define ALT32_CORR (-1)
	41	#else
	42	#define ALT32_CORR 1
1625216e MN	43	#endif
	44
	45	#ifdef ARCH_X86_64
	46	# define APCK_PTR2 8
	47	# define APCK_COEF 16
	48	# define APCK_SIZE 24
	49	#else
	50	# define APCK_PTR2 4
	51	# define APCK_COEF 8
	52	# define APCK_SIZE 16
9990e426 MN	53	#endif
9990e426 MN	54
d4e24275	55	typedef int (SwsFunc)(struct SwsContext context, uint8_t* src[], int srcStride[], int srcSliceY,
5427e242 MN	56	int srcSliceH, uint8_t* dst[], int dstStride[]);
5427e242 MN	57
8a322796	58	/* This struct should be aligned on at least a 32-byte boundary. */
5427e242	59	typedef struct SwsContext{
221b804f DB	60	/**
	61	* info on struct for av_log
	62	*/
635a8cd2	63	const AVClass *av_class;
221b804f DB	64
221b804f DB	65	/**
56b69633 DB	66	* Note that src, dst, srcStride, dstStride will be copied in the
56b69633 DB	67	* sws_scale() wrapper so they can be freely modified here.
221b804f DB	68	*/
	69	SwsFunc swScale;
	70	int srcW, srcH, dstH;
	71	int chrSrcW, chrSrcH, chrDstW, chrDstH;
	72	int lumXInc, chrXInc;
	73	int lumYInc, chrYInc;
58e4b706	74	enum PixelFormat dstFormat, srcFormat; ///< format 4:2:0 type is always YV12
221b804f DB	75	int origDstFormat, origSrcFormat; ///< format
	76	int chrSrcHSubSample, chrSrcVSubSample;
	77	int chrIntHSubSample, chrIntVSubSample;
	78	int chrDstHSubSample, chrDstVSubSample;
	79	int vChrDrop;
	80	int sliceDir;
	81	double param[2];
	82
49004617 VS	83	uint32_t pal_yuv[256];
	84	uint32_t pal_rgb[256];
	85
221b804f DB	86	int16_t **lumPixBuf;
	87	int16_t **chrPixBuf;
	88	int16_t *hLumFilter;
	89	int16_t *hLumFilterPos;
	90	int16_t *hChrFilter;
	91	int16_t *hChrFilterPos;
	92	int16_t *vLumFilter;
	93	int16_t *vLumFilterPos;
	94	int16_t *vChrFilter;
	95	int16_t *vChrFilterPos;
	96
8a322796	97	uint8_t formatConvBuffer[VOF]; //FIXME dynamic allocation, but we have to change a lot of code for this to be useful
221b804f DB	98
	99	int hLumFilterSize;
	100	int hChrFilterSize;
	101	int vLumFilterSize;
	102	int vChrFilterSize;
	103	int vLumBufSize;
	104	int vChrBufSize;
	105
	106	uint8_t *funnyYCode;
	107	uint8_t *funnyUVCode;
	108	int32_t *lumMmx2FilterPos;
	109	int32_t *chrMmx2FilterPos;
	110	int16_t *lumMmx2Filter;
	111	int16_t *chrMmx2Filter;
	112
	113	int canMMX2BeUsed;
	114
	115	int lastInLumBuf;
	116	int lastInChrBuf;
	117	int lumBufIndex;
	118	int chrBufIndex;
	119	int dstY;
	120	int flags;
	121	void * yuvTable; // pointer to the yuv->rgb table start so it can be freed()
	122	uint8_t * table_rV[256];
	123	uint8_t * table_gU[256];
	124	int table_gV[256];
	125	uint8_t * table_bU[256];
	126
	127	//Colorspace stuff
	128	int contrast, brightness, saturation; // for sws_getColorspaceDetails
	129	int srcColorspaceTable[4];
	130	int dstColorspaceTable[4];
	131	int srcRange, dstRange;
43c16478 MN	132	int yuv2rgb_y_offset;
	133	int yuv2rgb_y_coeff;
	134	int yuv2rgb_v2r_coeff;
	135	int yuv2rgb_v2g_coeff;
	136	int yuv2rgb_u2g_coeff;
	137	int yuv2rgb_u2b_coeff;
221b804f DB	138
	139	#define RED_DITHER "0*8"
	140	#define GREEN_DITHER "1*8"
	141	#define BLUE_DITHER "2*8"
	142	#define Y_COEFF "3*8"
	143	#define VR_COEFF "4*8"
	144	#define UB_COEFF "5*8"
	145	#define VG_COEFF "6*8"
	146	#define UG_COEFF "7*8"
	147	#define Y_OFFSET "8*8"
	148	#define U_OFFSET "9*8"
	149	#define V_OFFSET "10*8"
8bae9ddc MN	150	#define LUM_MMX_FILTER_OFFSET "11*8"
8bae9ddc MN	151	#define CHR_MMX_FILTER_OFFSET "118+44*256"
8a322796	152	#define DSTW_OFFSET "118+442562" //do not change, it is hardcoded in the ASM
221b804f DB	153	#define ESP_OFFSET "118+442562+8"
	154	#define VROUNDER_OFFSET "118+442562+16"
	155	#define U_TEMP "118+442562+24"
	156	#define V_TEMP "118+442562+32"
	157
	158	uint64_t redDither __attribute__((aligned(8)));
	159	uint64_t greenDither __attribute__((aligned(8)));
	160	uint64_t blueDither __attribute__((aligned(8)));
	161
	162	uint64_t yCoeff __attribute__((aligned(8)));
	163	uint64_t vrCoeff __attribute__((aligned(8)));
	164	uint64_t ubCoeff __attribute__((aligned(8)));
	165	uint64_t vgCoeff __attribute__((aligned(8)));
	166	uint64_t ugCoeff __attribute__((aligned(8)));
	167	uint64_t yOffset __attribute__((aligned(8)));
	168	uint64_t uOffset __attribute__((aligned(8)));
	169	uint64_t vOffset __attribute__((aligned(8)));
	170	int32_t lumMmxFilter[4*MAX_FILTER_SIZE];
	171	int32_t chrMmxFilter[4*MAX_FILTER_SIZE];
	172	int dstW;
	173	uint64_t esp __attribute__((aligned(8)));
	174	uint64_t vRounder __attribute__((aligned(8)));
	175	uint64_t u_temp __attribute__((aligned(8)));
	176	uint64_t v_temp __attribute__((aligned(8)));
a31de956 MN	177
	178	#ifdef HAVE_ALTIVEC
	179
	180	vector signed short CY;
	181	vector signed short CRV;
	182	vector signed short CBU;
	183	vector signed short CGU;
	184	vector signed short CGV;
	185	vector signed short OY;
	186	vector unsigned short CSHIFT;
221b804f	187	vector signed short vYCoeffsBank, vCCoeffsBank;
a31de956 MN	188
	189	#endif
	190
d3f3eea9	191
721d5e3b	192	#ifdef ARCH_BFIN
d3f3eea9 MH	193	uint32_t oy __attribute__((aligned(4)));
	194	uint32_t oc __attribute__((aligned(4)));
	195	uint32_t zero __attribute__((aligned(4)));
	196	uint32_t cy __attribute__((aligned(4)));
	197	uint32_t crv __attribute__((aligned(4)));
	198	uint32_t rmask __attribute__((aligned(4)));
	199	uint32_t cbu __attribute__((aligned(4)));
	200	uint32_t bmask __attribute__((aligned(4)));
	201	uint32_t cgu __attribute__((aligned(4)));
	202	uint32_t cgv __attribute__((aligned(4)));
	203	uint32_t gmask __attribute__((aligned(4)));
	204	#endif
	205
90c1d7b4 DB	206	#ifdef HAVE_VIS
	207	uint64_t sparc_coeffs[10] __attribute__((aligned(8)));
	208	#endif
d3f3eea9	209
5427e242 MN	210	} SwsContext;
5427e242 MN	211	//FIXME check init (where 0)
5427e242	212
5427e242 MN	213	SwsFunc yuv2rgb_get_func_ptr (SwsContext *c);
	214	int yuv2rgb_c_init_tables (SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation);
	215
c95a3a9f DB	216	void yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4],int brightness,int contrast, int saturation);
	217	SwsFunc yuv2rgb_init_altivec (SwsContext *c);
	218	void altivec_yuv2packedX (SwsContext *c,
	219	int16_t lumFilter, int16_t *lumSrc, int lumFilterSize,
	220	int16_t chrFilter, int16_t *chrSrc, int chrFilterSize,
	221	uint8_t *dest, int dstW, int dstY);
	222
8055ede6	223	const char *sws_format_name(int format);
94c4def2	224
e9e12f0e	225	//FIXME replace this with something faster
9d9de37d IP	226	#define isPlanarYUV(x) ( \
	227	(x)==PIX_FMT_YUV410P \
	228	\|\| (x)==PIX_FMT_YUV420P \
	229	\|\| (x)==PIX_FMT_YUV411P \
	230	\|\| (x)==PIX_FMT_YUV422P \
	231	\|\| (x)==PIX_FMT_YUV444P \
9ba7fe6d	232	\|\| (x)==PIX_FMT_YUV440P \
9d9de37d IP	233	\|\| (x)==PIX_FMT_NV12 \
	234	\|\| (x)==PIX_FMT_NV21 \
	235	)
	236	#define isYUV(x) ( \
	237	(x)==PIX_FMT_UYVY422 \
	238	\|\| (x)==PIX_FMT_YUYV422 \
	239	\|\| isPlanarYUV(x) \
	240	)
	241	#define isGray(x) ( \
	242	(x)==PIX_FMT_GRAY8 \
	243	\|\| (x)==PIX_FMT_GRAY16BE \
	244	\|\| (x)==PIX_FMT_GRAY16LE \
	245	)
	246	#define isGray16(x) ( \
	247	(x)==PIX_FMT_GRAY16BE \
	248	\|\| (x)==PIX_FMT_GRAY16LE \
	249	)
	250	#define isRGB(x) ( \
d52337af	251	(x)==PIX_FMT_RGB32 \
9990e426	252	\|\| (x)==PIX_FMT_RGB32_1 \
9d9de37d IP	253	\|\| (x)==PIX_FMT_RGB24 \
	254	\|\| (x)==PIX_FMT_RGB565 \
	255	\|\| (x)==PIX_FMT_RGB555 \
	256	\|\| (x)==PIX_FMT_RGB8 \
	257	\|\| (x)==PIX_FMT_RGB4 \
	258	\|\| (x)==PIX_FMT_RGB4_BYTE \
	259	\|\| (x)==PIX_FMT_MONOBLACK \
ec1bca2a	260	\|\| (x)==PIX_FMT_MONOWHITE \
9d9de37d IP	261	)
9d9de37d IP	262	#define isBGR(x) ( \
d52337af	263	(x)==PIX_FMT_BGR32 \
9990e426	264	\|\| (x)==PIX_FMT_BGR32_1 \
9d9de37d IP	265	\|\| (x)==PIX_FMT_BGR24 \
	266	\|\| (x)==PIX_FMT_BGR565 \
	267	\|\| (x)==PIX_FMT_BGR555 \
	268	\|\| (x)==PIX_FMT_BGR8 \
	269	\|\| (x)==PIX_FMT_BGR4 \
	270	\|\| (x)==PIX_FMT_BGR4_BYTE \
	271	\|\| (x)==PIX_FMT_MONOBLACK \
ec1bca2a	272	\|\| (x)==PIX_FMT_MONOWHITE \
9d9de37d	273	)
e9e12f0e LA	274
	275	static inline int fmt_depth(int fmt)
	276	{
	277	switch(fmt) {
	278	case PIX_FMT_BGRA:
	279	case PIX_FMT_ABGR:
	280	case PIX_FMT_RGBA:
	281	case PIX_FMT_ARGB:
	282	return 32;
	283	case PIX_FMT_BGR24:
	284	case PIX_FMT_RGB24:
	285	return 24;
	286	case PIX_FMT_BGR565:
	287	case PIX_FMT_RGB565:
4884b9e5 KS	288	case PIX_FMT_GRAY16BE:
4884b9e5 KS	289	case PIX_FMT_GRAY16LE:
e9e12f0e LA	290	return 16;
	291	case PIX_FMT_BGR555:
	292	case PIX_FMT_RGB555:
	293	return 15;
	294	case PIX_FMT_BGR8:
	295	case PIX_FMT_RGB8:
	296	return 8;
	297	case PIX_FMT_BGR4:
	298	case PIX_FMT_RGB4:
	299	case PIX_FMT_BGR4_BYTE:
	300	case PIX_FMT_RGB4_BYTE:
	301	return 4;
	302	case PIX_FMT_MONOBLACK:
ec1bca2a	303	case PIX_FMT_MONOWHITE:
e9e12f0e LA	304	return 1;
	305	default:
	306	return 0;
	307	}
	308	}
	309
0cb25594 CEH	310	extern const DECLARE_ALIGNED(8, uint64_t, ff_dither4[2]);
	311	extern const DECLARE_ALIGNED(8, uint64_t, ff_dither8[2]);
	312
e40b183d LB	313	extern const AVClass sws_context_class;
e40b183d LB	314
0eaf5235	315	#endif /* SWSCALE_SWSCALE_INTERNAL_H */