*/
/*
- supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8/Y800, YVU9/IF09, PAL8
+ supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR32_1, BGR24, BGR16, BGR15, RGB32, RGB32_1, RGB24, Y8/Y800, YVU9/IF09, PAL8
supported output formats: YV12, I420/IYUV, YUY2, UYVY, {BGR,RGB}{1,4,8,15,16,24,32}, Y8/Y800, YVU9/IF09
{BGR,RGB}{1,4,8,15,16} support dithering
BGR24 -> YV12
*/
+#define _SVID_SOURCE //needed for MAP_ANONYMOUS
#include <inttypes.h>
#include <string.h>
#include <math.h>
#include "rgb2rgb.h"
#include "libavutil/x86_cpu.h"
#include "libavutil/bswap.h"
-#include "libavcodec/opt.h"
+
+unsigned swscale_version(void)
+{
+ return LIBSWSCALE_VERSION_INT;
+}
#undef MOVNTQ
#undef PAVGB
|| (x)==PIX_FMT_YUYV422 \
|| (x)==PIX_FMT_UYVY422 \
|| (x)==PIX_FMT_RGB32 \
+ || (x)==PIX_FMT_RGB32_1 \
|| (x)==PIX_FMT_BGR24 \
|| (x)==PIX_FMT_BGR565 \
|| (x)==PIX_FMT_BGR555 \
|| (x)==PIX_FMT_BGR32 \
+ || (x)==PIX_FMT_BGR32_1 \
|| (x)==PIX_FMT_RGB24 \
|| (x)==PIX_FMT_RGB565 \
|| (x)==PIX_FMT_RGB555 \
|| (x)==PIX_FMT_GRAY8 \
|| (x)==PIX_FMT_YUV410P \
+ || (x)==PIX_FMT_YUV440P \
|| (x)==PIX_FMT_GRAY16BE \
|| (x)==PIX_FMT_GRAY16LE \
|| (x)==PIX_FMT_YUV444P \
|| (x)==PIX_FMT_BGR4_BYTE \
|| (x)==PIX_FMT_RGB4_BYTE \
|| (x)==PIX_FMT_YUV440P \
+ || (x)==PIX_FMT_MONOWHITE \
+ || (x)==PIX_FMT_MONOBLACK \
)
#define isSupportedOut(x) ( \
(x)==PIX_FMT_YUV420P \
|| (x)==PIX_FMT_GRAY16LE \
|| (x)==PIX_FMT_GRAY8 \
|| (x)==PIX_FMT_YUV410P \
+ || (x)==PIX_FMT_YUV440P \
)
#define isPacked(x) ( \
(x)==PIX_FMT_PAL8 \
|| isBGR(x) \
)
-#define RGB2YUV_SHIFT 16
-#define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
-#define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
-#define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
-#define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
-#define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
-#define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
-#define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
-#define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
-#define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
+#define RGB2YUV_SHIFT 15
+#define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
+#define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))
extern const int32_t Inverse_Table_6_9[8][4];
+static const double rgb2yuv_table[8][9]={
+ {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5},
+ {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5},
+ {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5},
+ {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5},
+ {0.59 , 0.11 , 0.30 , -0.331, 0.5, -0.169, -0.421, -0.079, 0.5}, //FCC
+ {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5},
+ {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //SMPTE 170M
+ {0.701 , 0.087 , 0.212 , -0.384, 0.5 -0.116, -0.445, -0.055, 0.5}, //SMPTE 240M
+};
+
/*
NOTES
Special versions: fast Y 1:1 scaling (no interpolation in y direction)
DECLARE_ALIGNED(8, const uint64_t, ff_bgr2YOffset) = 0x1010101010101010ULL;
DECLARE_ALIGNED(8, const uint64_t, ff_bgr2UVOffset) = 0x8080808080808080ULL;
DECLARE_ALIGNED(8, const uint64_t, ff_w1111) = 0x0001000100010001ULL;
+
+DECLARE_ALIGNED(8, const uint64_t, ff_bgr24toY1Coeff) = 0x0C88000040870C88ULL;
+DECLARE_ALIGNED(8, const uint64_t, ff_bgr24toY2Coeff) = 0x20DE4087000020DEULL;
+DECLARE_ALIGNED(8, const uint64_t, ff_rgb24toY1Coeff) = 0x20DE0000408720DEULL;
+DECLARE_ALIGNED(8, const uint64_t, ff_rgb24toY2Coeff) = 0x0C88408700000C88ULL;
+DECLARE_ALIGNED(8, const uint64_t, ff_bgr24toYOffset) = 0x0008400000084000ULL;
+
+DECLARE_ALIGNED(8, const uint64_t, ff_bgr24toUV[2][4]) = {
+ {0x38380000DAC83838ULL, 0xECFFDAC80000ECFFULL, 0xF6E40000D0E3F6E4ULL, 0x3838D0E300003838ULL},
+ {0xECFF0000DAC8ECFFULL, 0x3838DAC800003838ULL, 0x38380000D0E33838ULL, 0xF6E4D0E30000F6E4ULL},
+};
+
+DECLARE_ALIGNED(8, const uint64_t, ff_bgr24toUVOffset)= 0x0040400000404000ULL;
+
#endif /* defined(ARCH_X86) */
// clipping helper table for C implementations:
static SwsVector *sws_getConvVec(SwsVector *a, SwsVector *b);
-extern const uint8_t dither_2x2_4[2][8];
-extern const uint8_t dither_2x2_8[2][8];
-extern const uint8_t dither_8x8_32[8][8];
-extern const uint8_t dither_8x8_73[8][8];
-extern const uint8_t dither_8x8_220[8][8];
+const uint8_t __attribute__((aligned(8))) dither_2x2_4[2][8]={
+{ 1, 3, 1, 3, 1, 3, 1, 3, },
+{ 2, 0, 2, 0, 2, 0, 2, 0, },
+};
-static const char * sws_context_to_name(void * ptr) {
- return "swscaler";
-}
+const uint8_t __attribute__((aligned(8))) dither_2x2_8[2][8]={
+{ 6, 2, 6, 2, 6, 2, 6, 2, },
+{ 0, 4, 0, 4, 0, 4, 0, 4, },
+};
+
+const uint8_t __attribute__((aligned(8))) dither_8x8_32[8][8]={
+{ 17, 9, 23, 15, 16, 8, 22, 14, },
+{ 5, 29, 3, 27, 4, 28, 2, 26, },
+{ 21, 13, 19, 11, 20, 12, 18, 10, },
+{ 0, 24, 6, 30, 1, 25, 7, 31, },
+{ 16, 8, 22, 14, 17, 9, 23, 15, },
+{ 4, 28, 2, 26, 5, 29, 3, 27, },
+{ 20, 12, 18, 10, 21, 13, 19, 11, },
+{ 1, 25, 7, 31, 0, 24, 6, 30, },
+};
+
+#if 0
+const uint8_t __attribute__((aligned(8))) dither_8x8_64[8][8]={
+{ 0, 48, 12, 60, 3, 51, 15, 63, },
+{ 32, 16, 44, 28, 35, 19, 47, 31, },
+{ 8, 56, 4, 52, 11, 59, 7, 55, },
+{ 40, 24, 36, 20, 43, 27, 39, 23, },
+{ 2, 50, 14, 62, 1, 49, 13, 61, },
+{ 34, 18, 46, 30, 33, 17, 45, 29, },
+{ 10, 58, 6, 54, 9, 57, 5, 53, },
+{ 42, 26, 38, 22, 41, 25, 37, 21, },
+};
+#endif
-#define OFFSET(x) offsetof(SwsContext, x)
-#define DEFAULT 0
-#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
-
-static const AVOption options[] = {
- { "sws_flags", "scaler/cpu flags", OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, 0, UINT_MAX, VE, "sws_flags" },
- { "fast_bilinear", "fast bilinear", 0, FF_OPT_TYPE_CONST, SWS_FAST_BILINEAR, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "bilinear", "bilinear", 0, FF_OPT_TYPE_CONST, SWS_BILINEAR, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "bicubic", "bicubic", 0, FF_OPT_TYPE_CONST, SWS_BICUBIC, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "experimental", "experimental", 0, FF_OPT_TYPE_CONST, SWS_X, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "neighbor", "nearest neighbor", 0, FF_OPT_TYPE_CONST, SWS_POINT, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "area", "averaging area", 0, FF_OPT_TYPE_CONST, SWS_AREA, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "bicublin", "luma bicubic, chroma bilinear", 0, FF_OPT_TYPE_CONST, SWS_BICUBLIN, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "gauss", "gaussian", 0, FF_OPT_TYPE_CONST, SWS_GAUSS, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "sinc", "sinc", 0, FF_OPT_TYPE_CONST, SWS_SINC, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "lanczos", "lanczos", 0, FF_OPT_TYPE_CONST, SWS_LANCZOS, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "spline", "natural bicubic spline", 0, FF_OPT_TYPE_CONST, SWS_SPLINE, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "print_info", "print info", 0, FF_OPT_TYPE_CONST, SWS_PRINT_INFO, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "accurate_rnd", "accurate rounding", 0, FF_OPT_TYPE_CONST, SWS_ACCURATE_RND, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "mmx", "MMX SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_MMX, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "mmx2", "MMX2 SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_MMX2, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "3dnow", "3DNOW SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_3DNOW, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "altivec", "AltiVec SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_ALTIVEC, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "bfin", "Blackfin SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_BFIN, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "full_chroma_int", "full chroma interpolation", 0 , FF_OPT_TYPE_CONST, SWS_FULL_CHR_H_INT, INT_MIN, INT_MAX, VE, "sws_flags" },
- { "full_chroma_inp", "full chroma input", 0 , FF_OPT_TYPE_CONST, SWS_FULL_CHR_H_INP, INT_MIN, INT_MAX, VE, "sws_flags" },
- { NULL }
+const uint8_t __attribute__((aligned(8))) dither_8x8_73[8][8]={
+{ 0, 55, 14, 68, 3, 58, 17, 72, },
+{ 37, 18, 50, 32, 40, 22, 54, 35, },
+{ 9, 64, 5, 59, 13, 67, 8, 63, },
+{ 46, 27, 41, 23, 49, 31, 44, 26, },
+{ 2, 57, 16, 71, 1, 56, 15, 70, },
+{ 39, 21, 52, 34, 38, 19, 51, 33, },
+{ 11, 66, 7, 62, 10, 65, 6, 60, },
+{ 48, 30, 43, 25, 47, 29, 42, 24, },
};
-#undef VE
-#undef DEFAULT
+#if 0
+const uint8_t __attribute__((aligned(8))) dither_8x8_128[8][8]={
+{ 68, 36, 92, 60, 66, 34, 90, 58, },
+{ 20, 116, 12, 108, 18, 114, 10, 106, },
+{ 84, 52, 76, 44, 82, 50, 74, 42, },
+{ 0, 96, 24, 120, 6, 102, 30, 126, },
+{ 64, 32, 88, 56, 70, 38, 94, 62, },
+{ 16, 112, 8, 104, 22, 118, 14, 110, },
+{ 80, 48, 72, 40, 86, 54, 78, 46, },
+{ 4, 100, 28, 124, 2, 98, 26, 122, },
+};
+#endif
-static const AVClass sws_context_class = { "SWScaler", sws_context_to_name, options };
+#if 1
+const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={
+{117, 62, 158, 103, 113, 58, 155, 100, },
+{ 34, 199, 21, 186, 31, 196, 17, 182, },
+{144, 89, 131, 76, 141, 86, 127, 72, },
+{ 0, 165, 41, 206, 10, 175, 52, 217, },
+{110, 55, 151, 96, 120, 65, 162, 107, },
+{ 28, 193, 14, 179, 38, 203, 24, 189, },
+{138, 83, 124, 69, 148, 93, 134, 79, },
+{ 7, 172, 48, 213, 3, 168, 45, 210, },
+};
+#elif 1
+// tries to correct a gamma of 1.5
+const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={
+{ 0, 143, 18, 200, 2, 156, 25, 215, },
+{ 78, 28, 125, 64, 89, 36, 138, 74, },
+{ 10, 180, 3, 161, 16, 195, 8, 175, },
+{109, 51, 93, 38, 121, 60, 105, 47, },
+{ 1, 152, 23, 210, 0, 147, 20, 205, },
+{ 85, 33, 134, 71, 81, 30, 130, 67, },
+{ 14, 190, 6, 171, 12, 185, 5, 166, },
+{117, 57, 101, 44, 113, 54, 97, 41, },
+};
+#elif 1
+// tries to correct a gamma of 2.0
+const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={
+{ 0, 124, 8, 193, 0, 140, 12, 213, },
+{ 55, 14, 104, 42, 66, 19, 119, 52, },
+{ 3, 168, 1, 145, 6, 187, 3, 162, },
+{ 86, 31, 70, 21, 99, 39, 82, 28, },
+{ 0, 134, 11, 206, 0, 129, 9, 200, },
+{ 62, 17, 114, 48, 58, 16, 109, 45, },
+{ 5, 181, 2, 157, 4, 175, 1, 151, },
+{ 95, 36, 78, 26, 90, 34, 74, 24, },
+};
+#else
+// tries to correct a gamma of 2.5
+const uint8_t __attribute__((aligned(8))) dither_8x8_220[8][8]={
+{ 0, 107, 3, 187, 0, 125, 6, 212, },
+{ 39, 7, 86, 28, 49, 11, 102, 36, },
+{ 1, 158, 0, 131, 3, 180, 1, 151, },
+{ 68, 19, 52, 12, 81, 25, 64, 17, },
+{ 0, 119, 5, 203, 0, 113, 4, 195, },
+{ 45, 9, 96, 33, 42, 8, 91, 30, },
+{ 2, 172, 1, 144, 2, 165, 0, 137, },
+{ 77, 23, 60, 15, 72, 21, 56, 14, },
+};
+#endif
const char *sws_format_name(enum PixelFormat format)
{
}
}
-#define YSCALE_YUV_2_PACKEDX_C(type) \
+#define YSCALE_YUV_2_PACKEDX_NOCLIP_C(type) \
for (i=0; i<(dstW>>1); i++){\
int j;\
int Y1 = 1<<18;\
Y2>>=19;\
U >>=19;\
V >>=19;\
+
+#define YSCALE_YUV_2_PACKEDX_C(type) \
+ YSCALE_YUV_2_PACKEDX_NOCLIP_C(type)\
if ((Y1|Y2|U|V)&256)\
{\
if (Y1>255) Y1=255; \
else if (V<0) V=0; \
}
+#define YSCALE_YUV_2_PACKEDX_FULL_C \
+ for (i=0; i<dstW; i++){\
+ int j;\
+ int Y = 0;\
+ int U = -128<<19;\
+ int V = -128<<19;\
+ int R,G,B;\
+ \
+ for (j=0; j<lumFilterSize; j++){\
+ Y += lumSrc[j][i ] * lumFilter[j];\
+ }\
+ for (j=0; j<chrFilterSize; j++){\
+ U += chrSrc[j][i ] * chrFilter[j];\
+ V += chrSrc[j][i+VOFW] * chrFilter[j];\
+ }\
+ Y >>=10;\
+ U >>=10;\
+ V >>=10;\
+
+#define YSCALE_YUV_2_RGBX_FULL_C(rnd) \
+ YSCALE_YUV_2_PACKEDX_FULL_C\
+ Y-= c->yuv2rgb_y_offset;\
+ Y*= c->yuv2rgb_y_coeff;\
+ Y+= rnd;\
+ R= Y + V*c->yuv2rgb_v2r_coeff;\
+ G= Y + V*c->yuv2rgb_v2g_coeff + U*c->yuv2rgb_u2g_coeff;\
+ B= Y + U*c->yuv2rgb_u2b_coeff;\
+ if ((R|G|B)&(0xC0000000)){\
+ if (R>=(256<<22)) R=(256<<22)-1; \
+ else if (R<0)R=0; \
+ if (G>=(256<<22)) G=(256<<22)-1; \
+ else if (G<0)G=0; \
+ if (B>=(256<<22)) B=(256<<22)-1; \
+ else if (B<0)B=0; \
+ }\
+
+
+#define YSCALE_YUV_2_GRAY16_C \
+ for (i=0; i<(dstW>>1); i++){\
+ int j;\
+ int Y1 = 1<<18;\
+ int Y2 = 1<<18;\
+ int U = 1<<18;\
+ int V = 1<<18;\
+ \
+ const int i2= 2*i;\
+ \
+ for (j=0; j<lumFilterSize; j++)\
+ {\
+ Y1 += lumSrc[j][i2] * lumFilter[j];\
+ Y2 += lumSrc[j][i2+1] * lumFilter[j];\
+ }\
+ Y1>>=11;\
+ Y2>>=11;\
+ if ((Y1|Y2|U|V)&65536)\
+ {\
+ if (Y1>65535) Y1=65535; \
+ else if (Y1<0)Y1=0; \
+ if (Y2>65535) Y2=65535; \
+ else if (Y2<0)Y2=0; \
+ }
+
#define YSCALE_YUV_2_RGBX_C(type) \
- YSCALE_YUV_2_PACKEDX_C(type) \
+ YSCALE_YUV_2_PACKEDX_C(type) /* FIXME fix tables so that cliping is not needed and then use _NOCLIP*/\
r = (type *)c->table_rV[V]; \
g = (type *)(c->table_gU[U] + c->table_gV[V]); \
b = (type *)c->table_bU[U]; \
int U= (uvbuf0[i ]*uvalpha1+uvbuf1[i ]*uvalpha)>>19; \
int V= (uvbuf0[i+VOFW]*uvalpha1+uvbuf1[i+VOFW]*uvalpha)>>19; \
+#define YSCALE_YUV_2_GRAY16_2_C \
+ for (i=0; i<(dstW>>1); i++){ \
+ const int i2= 2*i; \
+ int Y1= (buf0[i2 ]*yalpha1+buf1[i2 ]*yalpha)>>11; \
+ int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>11; \
+
#define YSCALE_YUV_2_RGB2_C(type) \
YSCALE_YUV_2_PACKED2_C\
type *r, *b, *g;\
int U= (uvbuf1[i ])>>7;\
int V= (uvbuf1[i+VOFW])>>7;\
+#define YSCALE_YUV_2_GRAY16_1_C \
+ for (i=0; i<(dstW>>1); i++){\
+ const int i2= 2*i;\
+ int Y1= buf0[i2 ]<<1;\
+ int Y2= buf0[i2+1]<<1;\
+
#define YSCALE_YUV_2_RGB1_C(type) \
YSCALE_YUV_2_PACKED1_C\
type *r, *b, *g;\
g = (type *)(c->table_gU[U] + c->table_gV[V]);\
b = (type *)c->table_bU[U];\
-#define YSCALE_YUV_2_ANYRGB_C(func, func2)\
+#define YSCALE_YUV_2_MONO2_C \
+ const uint8_t * const d128=dither_8x8_220[y&7];\
+ uint8_t *g= c->table_gU[128] + c->table_gV[128];\
+ for (i=0; i<dstW-7; i+=8){\
+ int acc;\
+ acc = g[((buf0[i ]*yalpha1+buf1[i ]*yalpha)>>19) + d128[0]];\
+ acc+= acc + g[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19) + d128[1]];\
+ acc+= acc + g[((buf0[i+2]*yalpha1+buf1[i+2]*yalpha)>>19) + d128[2]];\
+ acc+= acc + g[((buf0[i+3]*yalpha1+buf1[i+3]*yalpha)>>19) + d128[3]];\
+ acc+= acc + g[((buf0[i+4]*yalpha1+buf1[i+4]*yalpha)>>19) + d128[4]];\
+ acc+= acc + g[((buf0[i+5]*yalpha1+buf1[i+5]*yalpha)>>19) + d128[5]];\
+ acc+= acc + g[((buf0[i+6]*yalpha1+buf1[i+6]*yalpha)>>19) + d128[6]];\
+ acc+= acc + g[((buf0[i+7]*yalpha1+buf1[i+7]*yalpha)>>19) + d128[7]];\
+ ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
+ dest++;\
+ }\
+
+
+#define YSCALE_YUV_2_MONOX_C \
+ const uint8_t * const d128=dither_8x8_220[y&7];\
+ uint8_t *g= c->table_gU[128] + c->table_gV[128];\
+ int acc=0;\
+ for (i=0; i<dstW-1; i+=2){\
+ int j;\
+ int Y1=1<<18;\
+ int Y2=1<<18;\
+\
+ for (j=0; j<lumFilterSize; j++)\
+ {\
+ Y1 += lumSrc[j][i] * lumFilter[j];\
+ Y2 += lumSrc[j][i+1] * lumFilter[j];\
+ }\
+ Y1>>=19;\
+ Y2>>=19;\
+ if ((Y1|Y2)&256)\
+ {\
+ if (Y1>255) Y1=255;\
+ else if (Y1<0)Y1=0;\
+ if (Y2>255) Y2=255;\
+ else if (Y2<0)Y2=0;\
+ }\
+ acc+= acc + g[Y1+d128[(i+0)&7]];\
+ acc+= acc + g[Y2+d128[(i+1)&7]];\
+ if ((i&7)==6){\
+ ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
+ dest++;\
+ }\
+ }
+
+
+#define YSCALE_YUV_2_ANYRGB_C(func, func2, func_g16, func_monoblack)\
switch(c->dstFormat)\
{\
case PIX_FMT_RGB32:\
case PIX_FMT_BGR32:\
+ case PIX_FMT_RGB32_1:\
+ case PIX_FMT_BGR32_1:\
func(uint32_t)\
((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
}\
break;\
case PIX_FMT_MONOBLACK:\
+ case PIX_FMT_MONOWHITE:\
{\
- const uint8_t * const d128=dither_8x8_220[y&7];\
- uint8_t *g= c->table_gU[128] + c->table_gV[128];\
- for (i=0; i<dstW-7; i+=8){\
- int acc;\
- acc = g[((buf0[i ]*yalpha1+buf1[i ]*yalpha)>>19) + d128[0]];\
- acc+= acc + g[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19) + d128[1]];\
- acc+= acc + g[((buf0[i+2]*yalpha1+buf1[i+2]*yalpha)>>19) + d128[2]];\
- acc+= acc + g[((buf0[i+3]*yalpha1+buf1[i+3]*yalpha)>>19) + d128[3]];\
- acc+= acc + g[((buf0[i+4]*yalpha1+buf1[i+4]*yalpha)>>19) + d128[4]];\
- acc+= acc + g[((buf0[i+5]*yalpha1+buf1[i+5]*yalpha)>>19) + d128[5]];\
- acc+= acc + g[((buf0[i+6]*yalpha1+buf1[i+6]*yalpha)>>19) + d128[6]];\
- acc+= acc + g[((buf0[i+7]*yalpha1+buf1[i+7]*yalpha)>>19) + d128[7]];\
- ((uint8_t*)dest)[0]= acc;\
- dest++;\
- }\
-\
-/*\
-((uint8_t*)dest)-= dstW>>4;\
-{\
- int acc=0;\
- int left=0;\
- static int top[1024];\
- static int last_new[1024][1024];\
- static int last_in3[1024][1024];\
- static int drift[1024][1024];\
- int topLeft=0;\
- int shift=0;\
- int count=0;\
- const uint8_t * const d128=dither_8x8_220[y&7];\
- int error_new=0;\
- int error_in3=0;\
- int f=0;\
- \
- for (i=dstW>>1; i<dstW; i++){\
- int in= ((buf0[i ]*yalpha1+buf1[i ]*yalpha)>>19);\
- int in2 = (76309 * (in - 16) + 32768) >> 16;\
- int in3 = (in2 < 0) ? 0 : ((in2 > 255) ? 255 : in2);\
- int old= (left*7 + topLeft + top[i]*5 + top[i+1]*3)/20 + in3\
- + (last_new[y][i] - in3)*f/256;\
- int new= old> 128 ? 255 : 0;\
-\
- error_new+= FFABS(last_new[y][i] - new);\
- error_in3+= FFABS(last_in3[y][i] - in3);\
- f= error_new - error_in3*4;\
- if (f<0) f=0;\
- if (f>256) f=256;\
-\
- topLeft= top[i];\
- left= top[i]= old - new;\
- last_new[y][i]= new;\
- last_in3[y][i]= in3;\
-\
- acc+= acc + (new&1);\
- if ((i&7)==6){\
- ((uint8_t*)dest)[0]= acc;\
- ((uint8_t*)dest)++;\
- }\
- }\
-}\
-*/\
+ func_monoblack\
}\
break;\
case PIX_FMT_YUYV422:\
((uint8_t*)dest)[2*i2+3]= Y2;\
} \
break;\
+ case PIX_FMT_GRAY16BE:\
+ func_g16\
+ ((uint8_t*)dest)[2*i2+0]= Y1>>8;\
+ ((uint8_t*)dest)[2*i2+1]= Y1;\
+ ((uint8_t*)dest)[2*i2+2]= Y2>>8;\
+ ((uint8_t*)dest)[2*i2+3]= Y2;\
+ } \
+ break;\
+ case PIX_FMT_GRAY16LE:\
+ func_g16\
+ ((uint8_t*)dest)[2*i2+0]= Y1;\
+ ((uint8_t*)dest)[2*i2+1]= Y1>>8;\
+ ((uint8_t*)dest)[2*i2+2]= Y2;\
+ ((uint8_t*)dest)[2*i2+3]= Y2>>8;\
+ } \
+ break;\
}\
uint8_t *dest, int dstW, int y)
{
int i;
- switch(c->dstFormat)
- {
- case PIX_FMT_BGR32:
- case PIX_FMT_RGB32:
- YSCALE_YUV_2_RGBX_C(uint32_t)
- ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];
- ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];
- }
- break;
+ YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGBX_C, YSCALE_YUV_2_PACKEDX_C(void), YSCALE_YUV_2_GRAY16_C, YSCALE_YUV_2_MONOX_C)
+}
+
+static inline void yuv2rgbXinC_full(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
+ int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
+ uint8_t *dest, int dstW, int y)
+{
+ int i;
+ int step= fmt_depth(c->dstFormat)/8;
+ int aidx= 3;
+
+ switch(c->dstFormat){
+ case PIX_FMT_ARGB:
+ dest++;
+ aidx= 0;
case PIX_FMT_RGB24:
- YSCALE_YUV_2_RGBX_C(uint8_t)
- ((uint8_t*)dest)[0]= r[Y1];
- ((uint8_t*)dest)[1]= g[Y1];
- ((uint8_t*)dest)[2]= b[Y1];
- ((uint8_t*)dest)[3]= r[Y2];
- ((uint8_t*)dest)[4]= g[Y2];
- ((uint8_t*)dest)[5]= b[Y2];
- dest+=6;
+ aidx--;
+ case PIX_FMT_RGBA:
+ YSCALE_YUV_2_RGBX_FULL_C(1<<21)
+ dest[aidx]= 0;
+ dest[0]= R>>22;
+ dest[1]= G>>22;
+ dest[2]= B>>22;
+ dest+= step;
}
break;
+ case PIX_FMT_ABGR:
+ dest++;
+ aidx= 0;
case PIX_FMT_BGR24:
- YSCALE_YUV_2_RGBX_C(uint8_t)
- ((uint8_t*)dest)[0]= b[Y1];
- ((uint8_t*)dest)[1]= g[Y1];
- ((uint8_t*)dest)[2]= r[Y1];
- ((uint8_t*)dest)[3]= b[Y2];
- ((uint8_t*)dest)[4]= g[Y2];
- ((uint8_t*)dest)[5]= r[Y2];
- dest+=6;
- }
- break;
- case PIX_FMT_RGB565:
- case PIX_FMT_BGR565:
- {
- const int dr1= dither_2x2_8[y&1 ][0];
- const int dg1= dither_2x2_4[y&1 ][0];
- const int db1= dither_2x2_8[(y&1)^1][0];
- const int dr2= dither_2x2_8[y&1 ][1];
- const int dg2= dither_2x2_4[y&1 ][1];
- const int db2= dither_2x2_8[(y&1)^1][1];
- YSCALE_YUV_2_RGBX_C(uint16_t)
- ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];
- ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];
- }
- }
- break;
- case PIX_FMT_RGB555:
- case PIX_FMT_BGR555:
- {
- const int dr1= dither_2x2_8[y&1 ][0];
- const int dg1= dither_2x2_8[y&1 ][1];
- const int db1= dither_2x2_8[(y&1)^1][0];
- const int dr2= dither_2x2_8[y&1 ][1];
- const int dg2= dither_2x2_8[y&1 ][0];
- const int db2= dither_2x2_8[(y&1)^1][1];
- YSCALE_YUV_2_RGBX_C(uint16_t)
- ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];
- ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];
- }
- }
- break;
- case PIX_FMT_RGB8:
- case PIX_FMT_BGR8:
- {
- const uint8_t * const d64= dither_8x8_73[y&7];
- const uint8_t * const d32= dither_8x8_32[y&7];
- YSCALE_YUV_2_RGBX_C(uint8_t)
- ((uint8_t*)dest)[i2+0]= r[Y1+d32[(i2+0)&7]] + g[Y1+d32[(i2+0)&7]] + b[Y1+d64[(i2+0)&7]];
- ((uint8_t*)dest)[i2+1]= r[Y2+d32[(i2+1)&7]] + g[Y2+d32[(i2+1)&7]] + b[Y2+d64[(i2+1)&7]];
- }
- }
- break;
- case PIX_FMT_RGB4:
- case PIX_FMT_BGR4:
- {
- const uint8_t * const d64= dither_8x8_73 [y&7];
- const uint8_t * const d128=dither_8x8_220[y&7];
- YSCALE_YUV_2_RGBX_C(uint8_t)
- ((uint8_t*)dest)[i]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]]
- +((r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]])<<4);
- }
- }
- break;
- case PIX_FMT_RGB4_BYTE:
- case PIX_FMT_BGR4_BYTE:
- {
- const uint8_t * const d64= dither_8x8_73 [y&7];
- const uint8_t * const d128=dither_8x8_220[y&7];
- YSCALE_YUV_2_RGBX_C(uint8_t)
- ((uint8_t*)dest)[i2+0]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]];
- ((uint8_t*)dest)[i2+1]= r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]];
- }
- }
- break;
- case PIX_FMT_MONOBLACK:
- {
- const uint8_t * const d128=dither_8x8_220[y&7];
- uint8_t *g= c->table_gU[128] + c->table_gV[128];
- int acc=0;
- for (i=0; i<dstW-1; i+=2){
- int j;
- int Y1=1<<18;
- int Y2=1<<18;
-
- for (j=0; j<lumFilterSize; j++)
- {
- Y1 += lumSrc[j][i] * lumFilter[j];
- Y2 += lumSrc[j][i+1] * lumFilter[j];
- }
- Y1>>=19;
- Y2>>=19;
- if ((Y1|Y2)&256)
- {
- if (Y1>255) Y1=255;
- else if (Y1<0)Y1=0;
- if (Y2>255) Y2=255;
- else if (Y2<0)Y2=0;
- }
- acc+= acc + g[Y1+d128[(i+0)&7]];
- acc+= acc + g[Y2+d128[(i+1)&7]];
- if ((i&7)==6){
- ((uint8_t*)dest)[0]= acc;
- dest++;
- }
- }
- }
- break;
- case PIX_FMT_YUYV422:
- YSCALE_YUV_2_PACKEDX_C(void)
- ((uint8_t*)dest)[2*i2+0]= Y1;
- ((uint8_t*)dest)[2*i2+1]= U;
- ((uint8_t*)dest)[2*i2+2]= Y2;
- ((uint8_t*)dest)[2*i2+3]= V;
- }
- break;
- case PIX_FMT_UYVY422:
- YSCALE_YUV_2_PACKEDX_C(void)
- ((uint8_t*)dest)[2*i2+0]= U;
- ((uint8_t*)dest)[2*i2+1]= Y1;
- ((uint8_t*)dest)[2*i2+2]= V;
- ((uint8_t*)dest)[2*i2+3]= Y2;
+ aidx--;
+ case PIX_FMT_BGRA:
+ YSCALE_YUV_2_RGBX_FULL_C(1<<21)
+ dest[aidx]= 0;
+ dest[0]= B>>22;
+ dest[1]= G>>22;
+ dest[2]= R>>22;
+ dest+= step;
}
break;
+ default:
+ assert(0);
}
}
-
//Note: we have C, X86, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
//Plain C versions
#if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT) || !defined(CONFIG_GPL)
int filterSize;
int filter2Size;
int minFilterSize;
- double *filter=NULL;
- double *filter2=NULL;
+ int64_t *filter=NULL;
+ int64_t *filter2=NULL;
+ const int64_t fone= 1LL<<54;
+ int ret= -1;
#if defined(ARCH_X86)
if (flags & SWS_CPU_CAPS_MMX)
asm volatile("emms\n\t"::: "memory"); //FIXME this should not be required but it IS (even for non-MMX versions)
{
int i;
filterSize= 1;
- filter= av_malloc(dstW*sizeof(double)*filterSize);
- for (i=0; i<dstW*filterSize; i++) filter[i]=0;
+ filter= av_mallocz(dstW*sizeof(*filter)*filterSize);
for (i=0; i<dstW; i++)
{
- filter[i*filterSize]=1;
+ filter[i*filterSize]= fone;
(*filterPos)[i]=i;
}
int i;
int xDstInSrc;
filterSize= 1;
- filter= av_malloc(dstW*sizeof(double)*filterSize);
+ filter= av_malloc(dstW*sizeof(*filter)*filterSize);
xDstInSrc= xInc/2 - 0x8000;
for (i=0; i<dstW; i++)
int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
(*filterPos)[i]= xx;
- filter[i]= 1.0;
+ filter[i]= fone;
xDstInSrc+= xInc;
}
}
if (flags&SWS_BICUBIC) filterSize= 4;
else if (flags&SWS_X ) filterSize= 4;
else filterSize= 2; // SWS_BILINEAR / SWS_AREA
- filter= av_malloc(dstW*sizeof(double)*filterSize);
+ filter= av_malloc(dstW*sizeof(*filter)*filterSize);
xDstInSrc= xInc/2 - 0x8000;
for (i=0; i<dstW; i++)
//Bilinear upscale / linear interpolate / Area averaging
for (j=0; j<filterSize; j++)
{
- double d= FFABS((xx<<16) - xDstInSrc)/(double)(1<<16);
- double coeff= 1.0 - d;
+ int64_t coeff= fone - FFABS((xx<<16) - xDstInSrc)*(fone>>16);
if (coeff<0) coeff=0;
filter[i*filterSize + j]= coeff;
xx++;
}
else
{
- double xDstInSrc;
- double sizeFactor, filterSizeInSrc;
- const double xInc1= (double)xInc / (double)(1<<16);
-
- if (flags&SWS_BICUBIC) sizeFactor= 4.0;
- else if (flags&SWS_X) sizeFactor= 8.0;
- else if (flags&SWS_AREA) sizeFactor= 1.0; //downscale only, for upscale it is bilinear
- else if (flags&SWS_GAUSS) sizeFactor= 8.0; // infinite ;)
- else if (flags&SWS_LANCZOS) sizeFactor= param[0] != SWS_PARAM_DEFAULT ? 2.0*param[0] : 6.0;
- else if (flags&SWS_SINC) sizeFactor= 20.0; // infinite ;)
- else if (flags&SWS_SPLINE) sizeFactor= 20.0; // infinite ;)
- else if (flags&SWS_BILINEAR) sizeFactor= 2.0;
+ int xDstInSrc;
+ int sizeFactor;
+
+ if (flags&SWS_BICUBIC) sizeFactor= 4;
+ else if (flags&SWS_X) sizeFactor= 8;
+ else if (flags&SWS_AREA) sizeFactor= 1; //downscale only, for upscale it is bilinear
+ else if (flags&SWS_GAUSS) sizeFactor= 8; // infinite ;)
+ else if (flags&SWS_LANCZOS) sizeFactor= param[0] != SWS_PARAM_DEFAULT ? ceil(2*param[0]) : 6;
+ else if (flags&SWS_SINC) sizeFactor= 20; // infinite ;)
+ else if (flags&SWS_SPLINE) sizeFactor= 20; // infinite ;)
+ else if (flags&SWS_BILINEAR) sizeFactor= 2;
else {
- sizeFactor= 0.0; //GCC warning killer
+ sizeFactor= 0; //GCC warning killer
assert(0);
}
- if (xInc1 <= 1.0) filterSizeInSrc= sizeFactor; // upscale
- else filterSizeInSrc= sizeFactor*srcW / (double)dstW;
+ if (xInc <= 1<<16) filterSize= 1 + sizeFactor; // upscale
+ else filterSize= 1 + (sizeFactor*srcW + dstW - 1)/ dstW;
- filterSize= (int)ceil(1 + filterSizeInSrc); // will be reduced later if possible
if (filterSize > srcW-2) filterSize=srcW-2;
- filter= av_malloc(dstW*sizeof(double)*filterSize);
+ filter= av_malloc(dstW*sizeof(*filter)*filterSize);
- xDstInSrc= xInc1 / 2.0 - 0.5;
+ xDstInSrc= xInc - 0x10000;
for (i=0; i<dstW; i++)
{
- int xx= (int)(xDstInSrc - (filterSize-1)*0.5 + 0.5);
+ int xx= (xDstInSrc - ((filterSize-2)<<16)) / (1<<17);
int j;
(*filterPos)[i]= xx;
for (j=0; j<filterSize; j++)
{
- double d= FFABS(xx - xDstInSrc)/filterSizeInSrc*sizeFactor;
- double coeff;
+ int64_t d= ((int64_t)FFABS((xx<<17) - xDstInSrc))<<13;
+ double floatd;
+ int64_t coeff;
+
+ if (xInc > 1<<16)
+ d= d*dstW/srcW;
+ floatd= d * (1.0/(1<<30));
+
if (flags & SWS_BICUBIC)
{
- double B= param[0] != SWS_PARAM_DEFAULT ? param[0] : 0.0;
- double C= param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6;
-
- if (d<1.0)
- coeff = (12-9*B-6*C)*d*d*d + (-18+12*B+6*C)*d*d + 6-2*B;
- else if (d<2.0)
- coeff = (-B-6*C)*d*d*d + (6*B+30*C)*d*d + (-12*B-48*C)*d +8*B+24*C;
+ int64_t B= (param[0] != SWS_PARAM_DEFAULT ? param[0] : 0) * (1<<24);
+ int64_t C= (param[1] != SWS_PARAM_DEFAULT ? param[1] : 0.6) * (1<<24);
+ int64_t dd = ( d*d)>>30;
+ int64_t ddd= (dd*d)>>30;
+
+ if (d < 1LL<<30)
+ coeff = (12*(1<<24)-9*B-6*C)*ddd + (-18*(1<<24)+12*B+6*C)*dd + (6*(1<<24)-2*B)*(1<<30);
+ else if (d < 1LL<<31)
+ coeff = (-B-6*C)*ddd + (6*B+30*C)*dd + (-12*B-48*C)*d + (8*B+24*C)*(1<<30);
else
coeff=0.0;
+ coeff *= fone>>(30+24);
}
/* else if (flags & SWS_X)
{
else if (flags & SWS_X)
{
double A= param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
+ double c;
- if (d<1.0)
- coeff = cos(d*PI);
+ if (floatd<1.0)
+ c = cos(floatd*PI);
else
- coeff=-1.0;
- if (coeff<0.0) coeff= -pow(-coeff, A);
- else coeff= pow( coeff, A);
- coeff= coeff*0.5 + 0.5;
+ c=-1.0;
+ if (c<0.0) c= -pow(-c, A);
+ else c= pow( c, A);
+ coeff= (c*0.5 + 0.5)*fone;
}
else if (flags & SWS_AREA)
{
- double srcPixelSize= 1.0/xInc1;
- if (d + srcPixelSize/2 < 0.5) coeff= 1.0;
- else if (d - srcPixelSize/2 < 0.5) coeff= (0.5-d)/srcPixelSize + 0.5;
+ int64_t d2= d - (1<<29);
+ if (d2*xInc < -(1LL<<(29+16))) coeff= 1.0 * (1LL<<(30+16));
+ else if (d2*xInc < (1LL<<(29+16))) coeff= -d2*xInc + (1LL<<(29+16));
else coeff=0.0;
+ coeff *= fone>>(30+16);
}
else if (flags & SWS_GAUSS)
{
double p= param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
- coeff = pow(2.0, - p*d*d);
+ coeff = (pow(2.0, - p*floatd*floatd))*fone;
}
else if (flags & SWS_SINC)
{
- coeff = d ? sin(d*PI)/(d*PI) : 1.0;
+ coeff = (d ? sin(floatd*PI)/(floatd*PI) : 1.0)*fone;
}
else if (flags & SWS_LANCZOS)
{
double p= param[0] != SWS_PARAM_DEFAULT ? param[0] : 3.0;
- coeff = d ? sin(d*PI)*sin(d*PI/p)/(d*d*PI*PI/p) : 1.0;
- if (d>p) coeff=0;
+ coeff = (d ? sin(floatd*PI)*sin(floatd*PI/p)/(floatd*floatd*PI*PI/p) : 1.0)*fone;
+ if (floatd>p) coeff=0;
}
else if (flags & SWS_BILINEAR)
{
- coeff= 1.0 - d;
+ coeff= (1<<30) - d;
if (coeff<0) coeff=0;
+ coeff *= fone >> 30;
}
else if (flags & SWS_SPLINE)
{
double p=-2.196152422706632;
- coeff = getSplineCoeff(1.0, 0.0, p, -p-1.0, d);
+ coeff = getSplineCoeff(1.0, 0.0, p, -p-1.0, d) * fone;
}
else {
coeff= 0.0; //GCC warning killer
filter[i*filterSize + j]= coeff;
xx++;
}
- xDstInSrc+= xInc1;
+ xDstInSrc+= 2*xInc;
}
}
if (srcFilter) filter2Size+= srcFilter->length - 1;
if (dstFilter) filter2Size+= dstFilter->length - 1;
assert(filter2Size>0);
- filter2= av_malloc(filter2Size*dstW*sizeof(double));
+ filter2= av_mallocz(filter2Size*dstW*sizeof(*filter2));
for (i=0; i<dstW; i++)
{
- int j;
- SwsVector scaleFilter;
- SwsVector *outVec;
-
- scaleFilter.coeff= filter + i*filterSize;
- scaleFilter.length= filterSize;
-
- if (srcFilter) outVec= sws_getConvVec(srcFilter, &scaleFilter);
- else outVec= &scaleFilter;
+ int j, k;
- assert(outVec->length == filter2Size);
- //FIXME dstFilter
-
- for (j=0; j<outVec->length; j++)
- {
- filter2[i*filter2Size + j]= outVec->coeff[j];
+ if(srcFilter){
+ for (k=0; k<srcFilter->length; k++){
+ for (j=0; j<filterSize; j++)
+ filter2[i*filter2Size + k + j] += srcFilter->coeff[k]*filter[i*filterSize + j];
+ }
+ }else{
+ for (j=0; j<filterSize; j++)
+ filter2[i*filter2Size + j]= filter[i*filterSize + j];
}
+ //FIXME dstFilter
(*filterPos)[i]+= (filterSize-1)/2 - (filter2Size-1)/2;
-
- if (outVec != &scaleFilter) sws_freeVec(outVec);
}
- av_free(filter); filter=NULL;
+ av_freep(&filter);
/* try to reduce the filter-size (step1 find size and shift left) */
// Assume it is near normalized (*0.5 or *2.0 is OK but * 0.001 is not).
{
int min= filter2Size;
int j;
- double cutOff=0.0;
+ int64_t cutOff=0.0;
/* get rid off near zero elements on the left by shifting left */
for (j=0; j<filter2Size; j++)
int k;
cutOff += FFABS(filter2[i*filter2Size]);
- if (cutOff > SWS_MAX_REDUCE_CUTOFF) break;
+ if (cutOff > SWS_MAX_REDUCE_CUTOFF*fone) break;
/* preserve monotonicity because the core can't handle the filter otherwise */
if (i<dstW-1 && (*filterPos)[i] >= (*filterPos)[i+1]) break;
// Move filter coeffs left
for (k=1; k<filter2Size; k++)
filter2[i*filter2Size + k - 1]= filter2[i*filter2Size + k];
- filter2[i*filter2Size + k - 1]= 0.0;
+ filter2[i*filter2Size + k - 1]= 0;
(*filterPos)[i]++;
}
- cutOff=0.0;
+ cutOff=0;
/* count near zeros on the right */
for (j=filter2Size-1; j>0; j--)
{
cutOff += FFABS(filter2[i*filter2Size + j]);
- if (cutOff > SWS_MAX_REDUCE_CUTOFF) break;
+ if (cutOff > SWS_MAX_REDUCE_CUTOFF*fone) break;
min--;
}
assert(minFilterSize > 0);
filterSize= (minFilterSize +(filterAlign-1)) & (~(filterAlign-1));
assert(filterSize > 0);
- filter= av_malloc(filterSize*dstW*sizeof(double));
- if (filterSize >= MAX_FILTER_SIZE)
- return -1;
+ filter= av_malloc(filterSize*dstW*sizeof(*filter));
+ if (filterSize >= MAX_FILTER_SIZE*16/((flags&SWS_ACCURATE_RND) ? APCK_SIZE : 16) || !filter)
+ goto error;
*outFilterSize= filterSize;
if (flags&SWS_PRINT_INFO)
for (j=0; j<filterSize; j++)
{
- if (j>=filter2Size) filter[i*filterSize + j]= 0.0;
+ if (j>=filter2Size) filter[i*filterSize + j]= 0;
else filter[i*filterSize + j]= filter2[i*filter2Size + j];
+ if((flags & SWS_BITEXACT) && j>=minFilterSize)
+ filter[i*filterSize + j]= 0;
}
}
- av_free(filter2); filter2=NULL;
//FIXME try to align filterpos if possible
for (i=0; i<dstW; i++)
{
int j;
- double error=0;
- double sum=0;
- double scale= one;
+ int64_t error=0;
+ int64_t sum=0;
for (j=0; j<filterSize; j++)
{
sum+= filter[i*filterSize + j];
}
- scale/= sum;
+ sum= (sum + one/2)/ one;
for (j=0; j<*outFilterSize; j++)
{
- double v= filter[i*filterSize + j]*scale + error;
- int intV= floor(v + 0.5);
+ int64_t v= filter[i*filterSize + j] + error;
+ int intV= ROUNDED_DIV(v, sum);
(*outFilter)[i*(*outFilterSize) + j]= intV;
- error = v - intV;
+ error= v - intV*sum;
}
}
(*outFilter)[j + i]= (*outFilter)[j + i - (*outFilterSize)];
}
+ ret=0;
+error:
av_free(filter);
- return 0;
+ av_free(filter2);
+ return ret;
}
#ifdef COMPILE_MMX2
return srcSliceH;
}
-/* {RGB,BGR}{15,16,24,32} -> {RGB,BGR}{15,16,24,32} */
+static int YUV422PToYuy2Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
+ int srcSliceH, uint8_t* dstParam[], int dstStride[]){
+ uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
+
+ yuv422ptoyuy2(src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0]);
+
+ return srcSliceH;
+}
+
+static int YUV422PToUyvyWrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
+ int srcSliceH, uint8_t* dstParam[], int dstStride[]){
+ uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
+
+ yuv422ptouyvy(src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0]);
+
+ return srcSliceH;
+}
+
+/* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
static int rgb2rgbWrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[]){
const int srcFormat= c->srcFormat;
if(conv)
{
+ uint8_t *srcPtr= src[0];
+ if(srcFormat == PIX_FMT_RGB32_1 || srcFormat == PIX_FMT_BGR32_1)
+ srcPtr += ALT32_CORR;
+
if (dstStride[0]*srcBpp == srcStride[0]*dstBpp && srcStride[0] > 0)
- conv(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
+ conv(srcPtr, dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
else
{
int i;
- uint8_t *srcPtr= src[0];
uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
for (i=0; i<srcSliceH; i++)
int64_t cy = 1<<16;
int64_t oy = 0;
- if (isYUV(c->dstFormat) || isGray(c->dstFormat)) return -1;
memcpy(c->srcColorspaceTable, inv_table, sizeof(int)*4);
memcpy(c->dstColorspaceTable, table, sizeof(int)*4);
c->saturation= saturation;
c->srcRange = srcRange;
c->dstRange = dstRange;
+ if (isYUV(c->dstFormat) || isGray(c->dstFormat)) return 0;
c->uOffset= 0x0400040004000400LL;
c->vOffset= 0x0400040004000400LL;
c->ugCoeff= roundToInt16(cgu*8192) * 0x0001000100010001ULL;
c->yOffset= roundToInt16(oy * 8) * 0x0001000100010001ULL;
+ c->yuv2rgb_y_coeff = (int16_t)roundToInt16(cy <<13);
+ c->yuv2rgb_y_offset = (int16_t)roundToInt16(oy << 9);
+ c->yuv2rgb_v2r_coeff= (int16_t)roundToInt16(crv<<13);
+ c->yuv2rgb_v2g_coeff= (int16_t)roundToInt16(cgv<<13);
+ c->yuv2rgb_u2g_coeff= (int16_t)roundToInt16(cgu<<13);
+ c->yuv2rgb_u2b_coeff= (int16_t)roundToInt16(cbu<<13);
+
yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, contrast, saturation);
//FIXME factorize
return NULL;
}
+ i= flags & ( SWS_POINT
+ |SWS_AREA
+ |SWS_BILINEAR
+ |SWS_FAST_BILINEAR
+ |SWS_BICUBIC
+ |SWS_X
+ |SWS_GAUSS
+ |SWS_LANCZOS
+ |SWS_SINC
+ |SWS_SPLINE
+ |SWS_BICUBLIN);
+ if(!i || (i & (i-1)))
+ {
+ av_log(NULL, AV_LOG_ERROR, "swScaler: Exactly one scaler algorithm must be choosen\n");
+ return NULL;
+ }
+
/* sanity check */
if (srcW<4 || srcH<1 || dstW<8 || dstH<1) //FIXME check if these are enough and try to lowwer them after fixing the relevant parts of the code
{
if ((isBGR(srcFormat) || isRGB(srcFormat)) && !(flags&SWS_FULL_CHR_H_INP)
&& srcFormat!=PIX_FMT_RGB8 && srcFormat!=PIX_FMT_BGR8
&& srcFormat!=PIX_FMT_RGB4 && srcFormat!=PIX_FMT_BGR4
- && srcFormat!=PIX_FMT_RGB4_BYTE && srcFormat!=PIX_FMT_BGR4_BYTE)
+ && srcFormat!=PIX_FMT_RGB4_BYTE && srcFormat!=PIX_FMT_BGR4_BYTE
+ && ((dstW>>c->chrDstHSubSample) <= (srcW>>1) || (flags&(SWS_FAST_BILINEAR|SWS_POINT))))
c->chrSrcHSubSample=1;
if (param){
sws_setColorspaceDetails(c, Inverse_Table_6_9[SWS_CS_DEFAULT], srcRange, Inverse_Table_6_9[SWS_CS_DEFAULT] /* FIXME*/, dstRange, 0, 1<<16, 1<<16);
/* unscaled special Cases */
- if (unscaled && !usesHFilter && !usesVFilter)
+ if (unscaled && !usesHFilter && !usesVFilter && (srcRange == dstRange || isBGR(dstFormat) || isRGB(dstFormat)))
{
/* yv12_to_nv12 */
if (srcFormat == PIX_FMT_YUV420P && (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21))
}
#ifdef CONFIG_GPL
/* yuv2bgr */
- if ((srcFormat==PIX_FMT_YUV420P || srcFormat==PIX_FMT_YUV422P) && (isBGR(dstFormat) || isRGB(dstFormat)))
+ if ((srcFormat==PIX_FMT_YUV420P || srcFormat==PIX_FMT_YUV422P) && (isBGR(dstFormat) || isRGB(dstFormat))
+ && !(flags & SWS_ACCURATE_RND))
{
c->swScale= yuv2rgb_get_func_ptr(c);
}
#endif
- if (srcFormat==PIX_FMT_YUV410P && dstFormat==PIX_FMT_YUV420P)
+ if (srcFormat==PIX_FMT_YUV410P && dstFormat==PIX_FMT_YUV420P && !(flags & SWS_BITEXACT))
{
c->swScale= yvu9toyv12Wrapper;
}
/* bgr24toYV12 */
- if (srcFormat==PIX_FMT_BGR24 && dstFormat==PIX_FMT_YUV420P)
+ if (srcFormat==PIX_FMT_BGR24 && dstFormat==PIX_FMT_YUV420P && !(flags & SWS_ACCURATE_RND))
c->swScale= bgr24toyv12Wrapper;
/* rgb/bgr -> rgb/bgr (no dither needed forms) */
&& srcFormat != PIX_FMT_BGR4_BYTE && dstFormat != PIX_FMT_BGR4_BYTE
&& srcFormat != PIX_FMT_RGB4_BYTE && dstFormat != PIX_FMT_RGB4_BYTE
&& srcFormat != PIX_FMT_MONOBLACK && dstFormat != PIX_FMT_MONOBLACK
- && !needsDither)
+ && srcFormat != PIX_FMT_MONOWHITE && dstFormat != PIX_FMT_MONOWHITE
+ && dstFormat != PIX_FMT_RGB32_1
+ && dstFormat != PIX_FMT_BGR32_1
+ && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
c->swScale= rgb2rgbWrapper;
+ if (srcFormat == PIX_FMT_YUV422P)
+ {
+ if (dstFormat == PIX_FMT_YUYV422)
+ c->swScale= YUV422PToYuy2Wrapper;
+ else if (dstFormat == PIX_FMT_UYVY422)
+ c->swScale= YUV422PToUyvyWrapper;
+ }
+
/* LQ converters if -sws 0 or -sws 4*/
if (c->flags&(SWS_FAST_BILINEAR|SWS_POINT)){
- /* rgb/bgr -> rgb/bgr (dither needed forms) */
- if ( (isBGR(srcFormat) || isRGB(srcFormat))
- && (isBGR(dstFormat) || isRGB(dstFormat))
- && needsDither)
- c->swScale= rgb2rgbWrapper;
-
/* yv12_to_yuy2 */
- if (srcFormat == PIX_FMT_YUV420P &&
- (dstFormat == PIX_FMT_YUYV422 || dstFormat == PIX_FMT_UYVY422))
+ if (srcFormat == PIX_FMT_YUV420P)
{
if (dstFormat == PIX_FMT_YUYV422)
c->swScale= PlanarToYuy2Wrapper;
- else
+ else if (dstFormat == PIX_FMT_UYVY422)
c->swScale= PlanarToUyvyWrapper;
}
}
#ifdef COMPILE_ALTIVEC
if ((c->flags & SWS_CPU_CAPS_ALTIVEC) &&
- ((srcFormat == PIX_FMT_YUV420P &&
- (dstFormat == PIX_FMT_YUYV422 || dstFormat == PIX_FMT_UYVY422)))) {
+ srcFormat == PIX_FMT_YUV420P) {
// unscaled YV12 -> packed YUV, we want speed
if (dstFormat == PIX_FMT_YUYV422)
c->swScale= yv12toyuy2_unscaled_altivec;
- else
+ else if (dstFormat == PIX_FMT_UYVY422)
c->swScale= yv12touyvy_unscaled_altivec;
}
#endif
1;
initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
- srcH , dstH, filterAlign, (1<<12)-4,
+ srcH , dstH, filterAlign, (1<<12),
(flags&SWS_BICUBLIN) ? (flags|SWS_BICUBIC) : flags,
srcFilter->lumV, dstFilter->lumV, c->param);
initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
- c->chrSrcH, c->chrDstH, filterAlign, (1<<12)-4,
+ c->chrSrcH, c->chrDstH, filterAlign, (1<<12),
(flags&SWS_BICUBLIN) ? (flags|SWS_BILINEAR) : flags,
srcFilter->chrV, dstFilter->chrV, c->param);
int i;
uint8_t* src2[4]= {src[0], src[1], src[2]};
uint32_t pal[256];
+ int use_pal= c->srcFormat == PIX_FMT_PAL8
+ || c->srcFormat == PIX_FMT_BGR4_BYTE
+ || c->srcFormat == PIX_FMT_RGB4_BYTE
+ || c->srcFormat == PIX_FMT_BGR8
+ || c->srcFormat == PIX_FMT_RGB8;
+
if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
return 0;
if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
}
- if (c->srcFormat == PIX_FMT_PAL8){
+ if (use_pal){
for (i=0; i<256; i++){
- int p= ((uint32_t*)(src[1]))[i];
- int r= (p>>16)&0xFF;
- int g= (p>> 8)&0xFF;
- int b= p &0xFF;
- int y= av_clip_uint8(((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16 );
- int u= av_clip_uint8(((RU*r + GU*g + BU*b)>>RGB2YUV_SHIFT) + 128);
- int v= av_clip_uint8(((RV*r + GV*g + BV*b)>>RGB2YUV_SHIFT) + 128);
+ int p, r, g, b,y,u,v;
+ if(c->srcFormat == PIX_FMT_PAL8){
+ p=((uint32_t*)(src[1]))[i];
+ r= (p>>16)&0xFF;
+ g= (p>> 8)&0xFF;
+ b= p &0xFF;
+ }else if(c->srcFormat == PIX_FMT_RGB8){
+ r= (i>>5 )*36;
+ g= ((i>>2)&7)*36;
+ b= (i&3 )*85;
+ }else if(c->srcFormat == PIX_FMT_BGR8){
+ b= (i>>6 )*85;
+ g= ((i>>3)&7)*36;
+ r= (i&7 )*36;
+ }else if(c->srcFormat == PIX_FMT_RGB4_BYTE){
+ r= (i>>3 )*255;
+ g= ((i>>1)&3)*85;
+ b= (i&1 )*255;
+ }else if(c->srcFormat == PIX_FMT_BGR4_BYTE){
+ b= (i>>3 )*255;
+ g= ((i>>1)&3)*85;
+ r= (i&1 )*255;
+ }
+ y= av_clip_uint8((RY*r + GY*g + BY*b + ( 33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
+ u= av_clip_uint8((RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
+ v= av_clip_uint8((RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
pal[i]= y + (u<<8) + (v<<16);
}
src2[1]= (uint8_t*)pal;
int dstStride2[4]= {-dstStride[0], -dstStride[1], -dstStride[2]};
src2[0] += (srcSliceH-1)*srcStride[0];
- if (c->srcFormat != PIX_FMT_PAL8)
+ if (!use_pal)
src2[1] += ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[1];
src2[2] += ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[2];
void sws_freeVec(SwsVector *a){
if (!a) return;
- av_free(a->coeff);
- a->coeff=NULL;
+ av_freep(&a->coeff);
a->length=0;
av_free(a);
}
if (c->lumPixBuf)
{
for (i=0; i<c->vLumBufSize; i++)
- {
- av_free(c->lumPixBuf[i]);
- c->lumPixBuf[i]=NULL;
- }
- av_free(c->lumPixBuf);
- c->lumPixBuf=NULL;
+ av_freep(&c->lumPixBuf[i]);
+ av_freep(&c->lumPixBuf);
}
if (c->chrPixBuf)
{
for (i=0; i<c->vChrBufSize; i++)
- {
- av_free(c->chrPixBuf[i]);
- c->chrPixBuf[i]=NULL;
- }
- av_free(c->chrPixBuf);
- c->chrPixBuf=NULL;
+ av_freep(&c->chrPixBuf[i]);
+ av_freep(&c->chrPixBuf);
}
- av_free(c->vLumFilter);
- c->vLumFilter = NULL;
- av_free(c->vChrFilter);
- c->vChrFilter = NULL;
- av_free(c->hLumFilter);
- c->hLumFilter = NULL;
- av_free(c->hChrFilter);
- c->hChrFilter = NULL;
+ av_freep(&c->vLumFilter);
+ av_freep(&c->vChrFilter);
+ av_freep(&c->hLumFilter);
+ av_freep(&c->hChrFilter);
#ifdef HAVE_ALTIVEC
- av_free(c->vYCoeffsBank);
- c->vYCoeffsBank = NULL;
- av_free(c->vCCoeffsBank);
- c->vCCoeffsBank = NULL;
+ av_freep(&c->vYCoeffsBank);
+ av_freep(&c->vCCoeffsBank);
#endif
- av_free(c->vLumFilterPos);
- c->vLumFilterPos = NULL;
- av_free(c->vChrFilterPos);
- c->vChrFilterPos = NULL;
- av_free(c->hLumFilterPos);
- c->hLumFilterPos = NULL;
- av_free(c->hChrFilterPos);
- c->hChrFilterPos = NULL;
+ av_freep(&c->vLumFilterPos);
+ av_freep(&c->vChrFilterPos);
+ av_freep(&c->hLumFilterPos);
+ av_freep(&c->hChrFilterPos);
#if defined(ARCH_X86) && defined(CONFIG_GPL)
#ifdef MAP_ANONYMOUS
c->funnyUVCode=NULL;
#endif /* defined(ARCH_X86) */
- av_free(c->lumMmx2Filter);
- c->lumMmx2Filter=NULL;
- av_free(c->chrMmx2Filter);
- c->chrMmx2Filter=NULL;
- av_free(c->lumMmx2FilterPos);
- c->lumMmx2FilterPos=NULL;
- av_free(c->chrMmx2FilterPos);
- c->chrMmx2FilterPos=NULL;
- av_free(c->yuvTable);
- c->yuvTable=NULL;
+ av_freep(&c->lumMmx2Filter);
+ av_freep(&c->chrMmx2Filter);
+ av_freep(&c->lumMmx2FilterPos);
+ av_freep(&c->chrMmx2FilterPos);
+ av_freep(&c->yuvTable);
av_free(c);
}