From d8651ac9ff6c9fb670fa6c3f73c651fdc81b9dc0 Mon Sep 17 00:00:00 2001 From: michael Date: Thu, 6 Dec 2001 00:10:42 +0000 Subject: vertical cubic/linear scaling prints some info (MMX, dstbpp, ...) mainloop rewritten git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@3345 b3059339-0415-0410-9bf9-f77b7e298cf2 --- postproc/swscale.c | 77 ++- postproc/swscale.h | 2 +- postproc/swscale_template.c | 1242 ++++++++++++++++++++++++++++++++----------- 3 files changed, 994 insertions(+), 327 deletions(-) (limited to 'postproc') diff --git a/postproc/swscale.c b/postproc/swscale.c index 0383c37fc5..138f35891a 100644 --- a/postproc/swscale.c +++ b/postproc/swscale.c @@ -8,8 +8,11 @@ #include #include #include -//#include //FOR DEBUG ONLY +#include #include "../config.h" +#ifdef HAVE_MALLOC_H +#include +#endif #include "swscale.h" #include "../cpudetect.h" #undef MOVNTQ @@ -24,22 +27,28 @@ int fullUVIpol=0; int allwaysIpol=0; #define RET 0xC3 //near return opcode + +//#define ASSERT(x) if(!(x)) { printf("ASSERT " #x " failed\n"); *((int*)0)=0; } +#define ASSERT(x) ; + + /* NOTES known BUGS with known cause (no bugreports please!, but patches are welcome :) ) horizontal MMX2 scaler reads 1-7 samples too much (might cause a sig11) -Supported output formats BGR15 BGR16 BGR24 BGR32 +Supported output formats BGR15 BGR16 BGR24 BGR32, YV12 BGR15 & BGR16 MMX verions support dithering Special versions: fast Y 1:1 scaling (no interpolation in y direction) TODO more intelligent missalignment avoidance for the horizontal scaler -bicubic scaler dither in C change the distance of the u & v buffer -how to differenciate between x86 an C at runtime ?! (using C for now) +Move static / global vars into a struct so multiple scalers can be used +write special vertical cubic upscale version +Optimize C code (yv12 / minmax) */ #define ABS(a) ((a) > 0 ? (a) : (-(a))) @@ -94,21 +103,35 @@ static uint64_t __attribute__((aligned(8))) temp0; static uint64_t __attribute__((aligned(8))) asm_yalpha1; static uint64_t __attribute__((aligned(8))) asm_uvalpha1; -// temporary storage for 4 yuv lines: -// 16bit for now (mmx likes it more compact) -static uint16_t __attribute__((aligned(8))) pix_buf_y[4][2048]; -static uint16_t __attribute__((aligned(8))) pix_buf_uv[2][2048*2]; +static int16_t __attribute__((aligned(8))) *lumPixBuf[2000]; +static int16_t __attribute__((aligned(8))) *chrPixBuf[2000]; static int16_t __attribute__((aligned(8))) hLumFilter[8000]; static int16_t __attribute__((aligned(8))) hLumFilterPos[2000]; static int16_t __attribute__((aligned(8))) hChrFilter[8000]; static int16_t __attribute__((aligned(8))) hChrFilterPos[2000]; +static int16_t __attribute__((aligned(8))) vLumFilter[8000]; +static int16_t __attribute__((aligned(8))) vLumFilterPos[2000]; +static int16_t __attribute__((aligned(8))) vChrFilter[8000]; +static int16_t __attribute__((aligned(8))) vChrFilterPos[2000]; + +// Contain simply the values from v(Lum|Chr)Filter just nicely packed for mmx +//FIXME these are very likely too small / 8000 caused problems with 480x480 +static int16_t __attribute__((aligned(8))) lumMmxFilter[16000]; +static int16_t __attribute__((aligned(8))) chrMmxFilter[16000]; #else -static uint16_t pix_buf_y[4][2048]; -static uint16_t pix_buf_uv[2][2048*2]; +static int16_t *lumPixBuf[2000]; +static int16_t *chrPixBuf[2000]; static int16_t hLumFilter[8000]; static int16_t hLumFilterPos[2000]; static int16_t hChrFilter[8000]; static int16_t hChrFilterPos[2000]; +static int16_t vLumFilter[8000]; +static int16_t vLumFilterPos[2000]; +static int16_t vChrFilter[8000]; +static int16_t vChrFilterPos[2000]; +//FIXME just dummy vars +static int16_t lumMmxFilter[1]; +static int16_t chrMmxFilter[1]; #endif // clipping helper table for C implementations: @@ -127,9 +150,19 @@ static int yuvtab_3343[256]; static int yuvtab_0c92[256]; static int yuvtab_1a1e[256]; static int yuvtab_40cf[256]; - -static int hLumFilterSize; -static int hChrFilterSize; +// Needed for cubic scaler to catch overflows +static int clip_yuvtab_2568[768]; +static int clip_yuvtab_3343[768]; +static int clip_yuvtab_0c92[768]; +static int clip_yuvtab_1a1e[768]; +static int clip_yuvtab_40cf[768]; + +static int hLumFilterSize=0; +static int hChrFilterSize=0; +static int vLumFilterSize=0; +static int vChrFilterSize=0; +static int vLumBufSize=0; +static int vChrBufSize=0; int sws_flags=0; @@ -274,15 +307,14 @@ void SwScale_YV12slice(unsigned char* srcptr[],int stride[], int srcSliceY , void SwScale_Init(){ // generating tables: int i; - for(i=0;i<256;i++){ - clip_table[i]=0; - clip_table[i+256]=i; - clip_table[i+512]=255; - yuvtab_2568[i]=(0x2568*(i-16))+(256<<13); - yuvtab_3343[i]=0x3343*(i-128); - yuvtab_0c92[i]=-0x0c92*(i-128); - yuvtab_1a1e[i]=-0x1a1e*(i-128); - yuvtab_40cf[i]=0x40cf*(i-128); + for(i=0; i<768; i++){ + int c= MIN(MAX(i-256, 0), 255); + clip_table[i]=c; + yuvtab_2568[c]= clip_yuvtab_2568[i]=(0x2568*(c-16))+(256<<13); + yuvtab_3343[c]= clip_yuvtab_3343[i]=0x3343*(c-128); + yuvtab_0c92[c]= clip_yuvtab_0c92[i]=-0x0c92*(c-128); + yuvtab_1a1e[c]= clip_yuvtab_1a1e[i]=-0x1a1e*(c-128); + yuvtab_40cf[c]= clip_yuvtab_40cf[i]=0x40cf*(c-128); } for(i=0; i<768; i++) @@ -295,5 +327,6 @@ void SwScale_Init(){ clip_table15g[i]= (v<<2)&0x03E0; clip_table15r[i]= (v<<7)&0x7C00; } + } diff --git a/postproc/swscale.h b/postproc/swscale.h index 2c75a9007c..2757ba5f20 100644 --- a/postproc/swscale.h +++ b/postproc/swscale.h @@ -11,4 +11,4 @@ void SwScale_YV12slice(unsigned char* srcptr[],int stride[], int srcSliceY, int srcSliceH, uint8_t* dstptr[], int dststride, int dstbpp, int srcW, int srcH, int dstW, int dstH); // generating tables -void SwScale_Init(); +void SwScale_Init(); \ No newline at end of file diff --git a/postproc/swscale_template.c b/postproc/swscale_template.c index c7bb86e009..be0962495e 100644 --- a/postproc/swscale_template.c +++ b/postproc/swscale_template.c @@ -5,11 +5,6 @@ // current version mostly by Michael Niedermayer (michaelni@gmx.at) // the parts written by michael are under GNU GPL -/* TODO -Move static / global vars into a struct so multiple scalers can be used -write vertical cubic upscale / linear downscale stuff -*/ - #undef MOVNTQ #undef PAVGB #undef PREFETCH @@ -53,6 +48,129 @@ write vertical cubic upscale / linear downscale stuff #define MOVNTQ(a,b) "movq " #a ", " #b " \n\t" #endif + +#define YSCALEYUV2YV12X(x) \ + "xorl %%eax, %%eax \n\t"\ + "pxor %%mm3, %%mm3 \n\t"\ + "pxor %%mm4, %%mm4 \n\t"\ + "movl %0, %%edx \n\t"\ + ".balign 16 \n\t" /* FIXME Unroll? */\ + "1: \n\t"\ + "movl (%1, %%edx, 4), %%esi \n\t"\ + "movq (%2, %%edx, 8), %%mm0 \n\t" /* filterCoeff */\ + "movq " #x "(%%esi, %%eax, 2), %%mm2 \n\t" /* srcData */\ + "movq 8+" #x "(%%esi, %%eax, 2), %%mm5 \n\t" /* srcData */\ + "pmulhw %%mm0, %%mm2 \n\t"\ + "pmulhw %%mm0, %%mm5 \n\t"\ + "paddw %%mm2, %%mm3 \n\t"\ + "paddw %%mm5, %%mm4 \n\t"\ + "addl $1, %%edx \n\t"\ + " jnz 1b \n\t"\ + "psraw $3, %%mm3 \n\t"\ + "psraw $3, %%mm4 \n\t"\ + "packuswb %%mm4, %%mm3 \n\t"\ + MOVNTQ(%%mm3, (%3, %%eax))\ + "addl $8, %%eax \n\t"\ + "cmpl %4, %%eax \n\t"\ + "pxor %%mm3, %%mm3 \n\t"\ + "pxor %%mm4, %%mm4 \n\t"\ + "movl %0, %%edx \n\t"\ + "jb 1b \n\t" + +#define YSCALEYUV2YV121 \ + "movl %2, %%eax \n\t"\ + ".balign 16 \n\t" /* FIXME Unroll? */\ + "1: \n\t"\ + "movq (%0, %%eax, 2), %%mm0 \n\t"\ + "movq 8(%0, %%eax, 2), %%mm1 \n\t"\ + "psraw $7, %%mm0 \n\t"\ + "psraw $7, %%mm1 \n\t"\ + "packuswb %%mm1, %%mm0 \n\t"\ + MOVNTQ(%%mm0, (%1, %%eax))\ + "addl $8, %%eax \n\t"\ + "jnc 1b \n\t" + +/* + :: "m" (-lumFilterSize), "m" (-chrFilterSize), + "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4), + "r" (dest), "m" (dstW), + "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize) + : "%eax", "%ebx", "%ecx", "%edx", "%esi" +*/ +#define YSCALEYUV2RGBX \ + "xorl %%eax, %%eax \n\t"\ + ".balign 16 \n\t"\ + "1: \n\t"\ + "movl %1, %%edx \n\t" /* -chrFilterSize */\ + "movl %3, %%ebx \n\t" /* chrMmxFilter+lumFilterSize */\ + "movl %7, %%ecx \n\t" /* chrSrc+lumFilterSize */\ + "pxor %%mm3, %%mm3 \n\t"\ + "pxor %%mm4, %%mm4 \n\t"\ + "2: \n\t"\ + "movl (%%ecx, %%edx, 4), %%esi \n\t"\ + "movq (%%ebx, %%edx, 8), %%mm0 \n\t" /* filterCoeff */\ + "movq (%%esi, %%eax), %%mm2 \n\t" /* UsrcData */\ + "movq 4096(%%esi, %%eax), %%mm5 \n\t" /* VsrcData */\ + "pmulhw %%mm0, %%mm2 \n\t"\ + "pmulhw %%mm0, %%mm5 \n\t"\ + "paddw %%mm2, %%mm3 \n\t"\ + "paddw %%mm5, %%mm4 \n\t"\ + "addl $1, %%edx \n\t"\ + " jnz 2b \n\t"\ +\ + "movl %0, %%edx \n\t" /* -lumFilterSize */\ + "movl %2, %%ebx \n\t" /* lumMmxFilter+lumFilterSize */\ + "movl %6, %%ecx \n\t" /* lumSrc+lumFilterSize */\ + "pxor %%mm1, %%mm1 \n\t"\ + "pxor %%mm7, %%mm7 \n\t"\ + "2: \n\t"\ + "movl (%%ecx, %%edx, 4), %%esi \n\t"\ + "movq (%%ebx, %%edx, 8), %%mm0 \n\t" /* filterCoeff */\ + "movq (%%esi, %%eax, 2), %%mm2 \n\t" /* Y1srcData */\ + "movq 8(%%esi, %%eax, 2), %%mm5 \n\t" /* Y2srcData */\ + "pmulhw %%mm0, %%mm2 \n\t"\ + "pmulhw %%mm0, %%mm5 \n\t"\ + "paddw %%mm2, %%mm1 \n\t"\ + "paddw %%mm5, %%mm7 \n\t"\ + "addl $1, %%edx \n\t"\ + " jnz 2b \n\t"\ +\ + "psubw w400, %%mm3 \n\t" /* (U-128)8*/\ + "psubw w400, %%mm4 \n\t" /* (V-128)8*/\ + "movq %%mm3, %%mm2 \n\t" /* (U-128)8*/\ + "movq %%mm4, %%mm5 \n\t" /* (V-128)8*/\ + "pmulhw ugCoeff, %%mm3 \n\t"\ + "pmulhw vgCoeff, %%mm4 \n\t"\ + /* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\ + "pmulhw ubCoeff, %%mm2 \n\t"\ + "pmulhw vrCoeff, %%mm5 \n\t"\ + "psubw w80, %%mm1 \n\t" /* 8(Y-16)*/\ + "psubw w80, %%mm7 \n\t" /* 8(Y-16)*/\ + "pmulhw yCoeff, %%mm1 \n\t"\ + "pmulhw yCoeff, %%mm7 \n\t"\ + /* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\ + "paddw %%mm3, %%mm4 \n\t"\ + "movq %%mm2, %%mm0 \n\t"\ + "movq %%mm5, %%mm6 \n\t"\ + "movq %%mm4, %%mm3 \n\t"\ + "punpcklwd %%mm2, %%mm2 \n\t"\ + "punpcklwd %%mm5, %%mm5 \n\t"\ + "punpcklwd %%mm4, %%mm4 \n\t"\ + "paddw %%mm1, %%mm2 \n\t"\ + "paddw %%mm1, %%mm5 \n\t"\ + "paddw %%mm1, %%mm4 \n\t"\ + "punpckhwd %%mm0, %%mm0 \n\t"\ + "punpckhwd %%mm6, %%mm6 \n\t"\ + "punpckhwd %%mm3, %%mm3 \n\t"\ + "paddw %%mm7, %%mm0 \n\t"\ + "paddw %%mm7, %%mm6 \n\t"\ + "paddw %%mm7, %%mm3 \n\t"\ + /* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\ + "packuswb %%mm0, %%mm2 \n\t"\ + "packuswb %%mm6, %%mm5 \n\t"\ + "packuswb %%mm3, %%mm4 \n\t"\ + "pxor %%mm7, %%mm7 \n\t" + #define FULL_YSCALEYUV2RGB \ "pxor %%mm7, %%mm7 \n\t"\ "movd %6, %%mm6 \n\t" /*yalpha1*/\ @@ -238,8 +356,8 @@ write vertical cubic upscale / linear downscale stuff "movq 4096(%3, %%eax), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\ "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\ "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\ - "psrlw $5, %%mm3 \n\t"\ - "psrlw $5, %%mm4 \n\t"\ + "psrlw $5, %%mm3 \n\t" /*FIXME might overflow*/\ + "psrlw $5, %%mm4 \n\t" /*FIXME might overflow*/\ "psubw w400, %%mm3 \n\t" /* (U-128)8*/\ "psubw w400, %%mm4 \n\t" /* (V-128)8*/\ "movq %%mm3, %%mm2 \n\t" /* (U-128)8*/\ @@ -524,36 +642,366 @@ write vertical cubic upscale / linear downscale stuff #define WRITEBGR24 WRITEBGR24MMX #endif -static inline void RENAME(yuv2yuv)(uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1, - uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int yalpha, int uvalpha) +static inline void RENAME(yuv2yuvX)(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize, + int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize, + uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, + int16_t * lumMmxFilter, int16_t * chrMmxFilter) { - int yalpha1=yalpha^4095; - int uvalpha1=uvalpha^4095; +#ifdef HAVE_MMX + if(uDest != NULL) + { + asm volatile( + YSCALEYUV2YV12X(0) + :: "m" (-chrFilterSize), "r" (chrSrc+chrFilterSize), + "r" (chrMmxFilter+chrFilterSize*4), "r" (uDest), "m" (dstW>>1) + : "%eax", "%edx", "%esi" + ); + + asm volatile( + YSCALEYUV2YV12X(4096) + :: "m" (-chrFilterSize), "r" (chrSrc+chrFilterSize), + "r" (chrMmxFilter+chrFilterSize*4), "r" (vDest), "m" (dstW>>1) + : "%eax", "%edx", "%esi" + ); + } + + asm volatile( + YSCALEYUV2YV12X(0) + :: "m" (-lumFilterSize), "r" (lumSrc+lumFilterSize), + "r" (lumMmxFilter+lumFilterSize*4), "r" (dest), "m" (dstW) + : "%eax", "%edx", "%esi" + ); +#else + //FIXME Optimize (just quickly writen not opti..) int i; + for(i=0; i>19, 0), 255); + } + + if(uDest != NULL) + for(i=0; i<(dstW>>1); i++) + { + int u=0; + int v=0; + int j; + for(j=0; j>19, 0), 255); + vDest[i]= MIN(MAX(v>>19, 0), 255); + } #endif +} - for(i=0;i>19; + asm volatile( + YSCALEYUV2YV121 + :: "r" (chrSrc + (dstW>>1)), "r" (uDest + (dstW>>1)), + "g" (-(dstW>>1)) + : "%eax" + ); + + asm volatile( + YSCALEYUV2YV121 + :: "r" (chrSrc + 2048 + (dstW>>1)), "r" (vDest + (dstW>>1)), + "g" (-(dstW>>1)) + : "%eax" + ); } - if(uvalpha != -1) + asm volatile( + YSCALEYUV2YV121 + :: "r" (lumSrc + dstW), "r" (dest + dstW), + "g" (-dstW) + : "%eax" + ); +#else + //FIXME Optimize (just quickly writen not opti..) + //FIXME replace MINMAX with LUTs + int i; + for(i=0; i>7; + + dest[i]= MIN(MAX(val>>19, 0), 255); + } + + if(uDest != NULL) for(i=0; i<(dstW>>1); i++) { - ((uint8_t*)uDest)[i] = (uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>19; - ((uint8_t*)vDest)[i] = (uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19; + int u=chrSrc[i]>>7; + int v=chrSrc[i + 2048]>>7; + + uDest[i]= MIN(MAX(u>>19, 0), 255); + vDest[i]= MIN(MAX(v>>19, 0), 255); } - } +#endif } + /** * vertical scale YV12 to RGB */ -static inline void RENAME(yuv2rgbX)(uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1, +static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize, + int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize, + uint8_t *dest, int dstW, int dstbpp, int16_t * lumMmxFilter, int16_t * chrMmxFilter) +{ + if(fullUVIpol) + { +//FIXME + }//FULL_UV_IPOL + else + { +#ifdef HAVE_MMX + if(dstbpp == 32) //FIXME untested + { + asm volatile( + YSCALEYUV2RGBX + WRITEBGR32 + + :: "m" (-lumFilterSize), "m" (-chrFilterSize), + "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4), + "r" (dest), "m" (dstW), + "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize) + : "%eax", "%ebx", "%ecx", "%edx", "%esi" + ); + } + else if(dstbpp==24) //FIXME untested + { + asm volatile( + YSCALEYUV2RGBX + "leal (%%eax, %%eax, 2), %%ebx \n\t" //FIXME optimize + "addl %4, %%ebx \n\t" + WRITEBGR24 + + :: "m" (-lumFilterSize), "m" (-chrFilterSize), + "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4), + "r" (dest), "m" (dstW), + "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize) + : "%eax", "%ebx", "%ecx", "%edx", "%esi" + ); + } + else if(dstbpp==15) + { + asm volatile( + YSCALEYUV2RGBX + /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */ +#ifdef DITHER1XBPP + "paddusb b5Dither, %%mm2 \n\t" + "paddusb g5Dither, %%mm4 \n\t" + "paddusb r5Dither, %%mm5 \n\t" +#endif + + WRITEBGR15 + + :: "m" (-lumFilterSize), "m" (-chrFilterSize), + "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4), + "r" (dest), "m" (dstW), + "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize) + : "%eax", "%ebx", "%ecx", "%edx", "%esi" + ); + } + else if(dstbpp==16) + { + asm volatile( + YSCALEYUV2RGBX + /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */ +#ifdef DITHER1XBPP + "paddusb b5Dither, %%mm2 \n\t" + "paddusb g6Dither, %%mm4 \n\t" + "paddusb r5Dither, %%mm5 \n\t" +#endif + + WRITEBGR16 + + :: "m" (-lumFilterSize), "m" (-chrFilterSize), + "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4), + "r" (dest), "m" (dstW), + "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize) + : "%eax", "%ebx", "%ecx", "%edx", "%esi" + ); + } +#else + if(dstbpp==32) + { + int i; + for(i=0; i<(dstW>>1); i++){ + int j; + int Y1=0; + int Y2=0; + int U=0; + int V=0; + int Cb, Cr, Cg; + for(j=0; j>19) + 256 ]; + Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ]; + U >>= 19; + V >>= 19; + + Cb= clip_yuvtab_40cf[U+ 256]; + Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256]; + Cr= clip_yuvtab_3343[V+ 256]; + + dest[8*i+0]=clip_table[((Y1 + Cb) >>13)]; + dest[8*i+1]=clip_table[((Y1 + Cg) >>13)]; + dest[8*i+2]=clip_table[((Y1 + Cr) >>13)]; + + dest[8*i+4]=clip_table[((Y2 + Cb) >>13)]; + dest[8*i+5]=clip_table[((Y2 + Cg) >>13)]; + dest[8*i+6]=clip_table[((Y2 + Cr) >>13)]; + } + } + else if(dstbpp==24) + { + int i; + for(i=0; i<(dstW>>1); i++){ + int j; + int Y1=0; + int Y2=0; + int U=0; + int V=0; + int Cb, Cr, Cg; + for(j=0; j>19) + 256 ]; + Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ]; + U >>= 19; + V >>= 19; + + Cb= clip_yuvtab_40cf[U+ 256]; + Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256]; + Cr= clip_yuvtab_3343[V+ 256]; + + dest[0]=clip_table[((Y1 + Cb) >>13)]; + dest[1]=clip_table[((Y1 + Cg) >>13)]; + dest[2]=clip_table[((Y1 + Cr) >>13)]; + + dest[3]=clip_table[((Y2 + Cb) >>13)]; + dest[4]=clip_table[((Y2 + Cg) >>13)]; + dest[5]=clip_table[((Y2 + Cr) >>13)]; + dest+=6; + } + } + else if(dstbpp==16) + { + int i; + for(i=0; i<(dstW>>1); i++){ + int j; + int Y1=0; + int Y2=0; + int U=0; + int V=0; + int Cb, Cr, Cg; + for(j=0; j>19) + 256 ]; + Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ]; + U >>= 19; + V >>= 19; + + Cb= clip_yuvtab_40cf[U+ 256]; + Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256]; + Cr= clip_yuvtab_3343[V+ 256]; + + ((uint16_t*)dest)[2*i] = + clip_table16b[(Y1 + Cb) >>13] | + clip_table16g[(Y1 + Cg) >>13] | + clip_table16r[(Y1 + Cr) >>13]; + + ((uint16_t*)dest)[2*i+1] = + clip_table16b[(Y2 + Cb) >>13] | + clip_table16g[(Y2 + Cg) >>13] | + clip_table16r[(Y2 + Cr) >>13]; + } + } + else if(dstbpp==15) + { + int i; + for(i=0; i<(dstW>>1); i++){ + int j; + int Y1=0; + int Y2=0; + int U=0; + int V=0; + int Cb, Cr, Cg; + for(j=0; j>19) + 256 ]; + Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ]; + U >>= 19; + V >>= 19; + + Cb= clip_yuvtab_40cf[U+ 256]; + Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256]; + Cr= clip_yuvtab_3343[V+ 256]; + + ((uint16_t*)dest)[2*i] = + clip_table15b[(Y1 + Cb) >>13] | + clip_table15g[(Y1 + Cg) >>13] | + clip_table15r[(Y1 + Cr) >>13]; + + ((uint16_t*)dest)[2*i+1] = + clip_table15b[(Y2 + Cb) >>13] | + clip_table15g[(Y2 + Cg) >>13] | + clip_table15r[(Y2 + Cr) >>13]; + } + } +#endif + } //!FULL_UV_IPOL +} + + +/** + * vertical bilinear scale YV12 to RGB + */ +static inline void RENAME(yuv2rgb2)(uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1, uint8_t *dest, int dstW, int yalpha, int uvalpha, int dstbpp) { int yalpha1=yalpha^4095; @@ -708,8 +1156,6 @@ FULL_YSCALEYUV2RGB ); } #else - asm volatile ("\n\t"::: "memory"); - if(dstbpp==32 || dstbpp==24) { int i; @@ -819,8 +1265,6 @@ FULL_YSCALEYUV2RGB ); } #else - asm volatile ("\n\t"::: "memory"); - if(dstbpp==32) { int i; @@ -844,7 +1288,7 @@ FULL_YSCALEYUV2RGB dest[4*i+6]=clip_table[((Y2 + Cr) >>13)]; } } - if(dstbpp==24) + else if(dstbpp==24) { int i; for(i=0; i 2048 ) buf0 = buf1; #ifdef HAVE_MMX if( uvalpha < 2048 ) // note this is not correct (shifts chrominance by 0.5 pixels) but its a bit faster @@ -948,7 +1390,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv asm volatile( YSCALEYUV2RGB1 WRITEBGR32 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax" ); @@ -959,7 +1401,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv "movl %4, %%ebx \n\t" YSCALEYUV2RGB1 WRITEBGR24 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax", "%ebx" ); @@ -975,7 +1417,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv "paddusb r5Dither, %%mm5 \n\t" #endif WRITEBGR15 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax" ); @@ -992,7 +1434,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv #endif WRITEBGR16 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax" ); @@ -1005,7 +1447,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv asm volatile( YSCALEYUV2RGB1b WRITEBGR32 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax" ); @@ -1016,7 +1458,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv "movl %4, %%ebx \n\t" YSCALEYUV2RGB1b WRITEBGR24 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax", "%ebx" ); @@ -1032,7 +1474,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv "paddusb r5Dither, %%mm5 \n\t" #endif WRITEBGR15 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax" ); @@ -1049,7 +1491,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv #endif WRITEBGR16 - :: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), + :: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW), "m" (yalpha1), "m" (uvalpha1) : "%eax" ); @@ -1057,7 +1499,6 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv } #else //FIXME write 2 versions (for even & odd lines) - asm volatile ("\n\t"::: "memory"); if(dstbpp==32) { @@ -1082,7 +1523,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *buf1, uint16_t *uv dest[4*i+6]=clip_table[((Y2 + Cr) >>13)]; } } - if(dstbpp==24) + else if(dstbpp==24) { int i; for(i=0; i>16 >=srcW/2-1; i--) + for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) { - dst[i] = src1[srcW/2-1]*128; - dst[i+2048] = src2[srcW/2-1]*128; +// printf("%d %d %d\n", dstWidth, i, srcW); + dst[i] = src1[srcW-1]*128; + dst[i+2048] = src2[srcW-1]*128; } } else @@ -1584,33 +2026,45 @@ FUNNYUVCODE } } -static void inline RENAME(initFilter)(int16_t *filter, int16_t *filterPos, int *filterSize, int xInc, - int srcW, int dstW) +static inline void RENAME(initFilter)(int16_t *filter, int16_t *filterPos, int *filterSize, int xInc, + int srcW, int dstW, int filterAlign, int one) { int i; #ifdef HAVE_MMX - asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS + asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions) #endif - - if(xInc <= (1<<16)) // upscale / cubic interpolate + + if(ABS(xInc - 0x10000) <10) // unscaled + { + int i; + *filterSize= (1 +(filterAlign-1)) & (~(filterAlign-1)); // 1 or 4 normaly + for(i=0; i *filterSize %4 == 0 -#endif + *filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1)); + xDstInSrc= xInc - 0x8000; for(i=0; i>16) - (*filterSize>>1) + 1; int j; - + filterPos[i]= xx; if(sws_flags == SWS_BICUBIC) - { + { double d= ABS(((xx+1)<<16) - xDstInSrc)/(double)(1<<16); // int coeff; int y1,y2,y3,y4; @@ -1620,7 +2074,7 @@ static void inline RENAME(initFilter)(int16_t *filter, int16_t *filterPos, int * y2 = (int)floor(0.5 + (+ 1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d) * 16384.0); y3 = (int)floor(0.5 + ( - A*d + (2.0*A+3.0)*d*d - (A+2.0)*d*d*d) * 16384.0); y4 = (int)floor(0.5 + ( + A*d*d - A*d*d*d) * 16384.0); - + // printf("%d %d %d \n", coeff, (int)d, xDstInSrc); filter[i*(*filterSize) + 0]= y1; filter[i*(*filterSize) + 1]= y2; @@ -1628,20 +2082,20 @@ static void inline RENAME(initFilter)(int16_t *filter, int16_t *filterPos, int * filter[i*(*filterSize) + 3]= y4; // printf("%1.3f %d, %d, %d, %d\n",d , y1, y2, y3, y4); } - else + else { for(j=0; j<*filterSize; j++) { double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16); int coeff; coeff= (int)(0.5 + (1.0 - d)*(1<<14)); - if(coeff<0) coeff=0; + if(coeff<0) coeff=0; // printf("%d %d %d \n", coeff, (int)d, xDstInSrc); filter[i*(*filterSize) + j]= coeff; xx++; } - } - xDstInSrc+= xInc; + } + xDstInSrc+= xInc; } } else // downscale @@ -1650,47 +2104,46 @@ static void inline RENAME(initFilter)(int16_t *filter, int16_t *filterPos, int * if(sws_flags==SWS_BICUBIC) *filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW); else *filterSize= (int)ceil(1 + 2.0*srcW / (double)dstW); // printf("%d %d %d\n", *filterSize, srcW, dstW); -#ifdef HAVE_MMX - *filterSize= (*filterSize +3) & (~3); // -> *filterSize %4 == 0 -#endif + *filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1)); + xDstInSrc= xInc - 0x8000; for(i=0; i>16 + carry + "pshufw $0xFF, %%mm0, %%mm0 \n\t" + "2: \n\t" + "psrlw $9, %%mm3 \n\t" + "psubw %%mm1, %%mm0 \n\t" + "pmullw %%mm3, %%mm0 \n\t" + "paddw %%mm6, %%mm2 \n\t" // 2*alpha += xpos&0xFFFF + "psllw $7, %%mm1 \n\t" + "paddw %%mm1, %%mm0 \n\t" + + "movq %%mm0, (%%edi, %%eax) \n\t" + + "addl $8, %%eax \n\t" + // End + "9: \n\t" +// "int $3\n\t" + "leal 0b, %0 \n\t" + "leal 1b, %1 \n\t" + "leal 2b, %2 \n\t" + "decl %1 \n\t" + "decl %2 \n\t" + "subl %0, %1 \n\t" + "subl %0, %2 \n\t" + "leal 9b, %3 \n\t" + "subl %0, %3 \n\t" + :"=r" (fragment), "=r" (imm8OfPShufW1), "=r" (imm8OfPShufW2), + "=r" (fragmentLength) + ); + + xpos= 0; //lumXInc/2 - 0x8000; // difference between pixel centers + + for(i=0; i>16; + + if((i&3) == 0) + { + int a=0; + int b=((xpos+xInc)>>16) - xx; + int c=((xpos+xInc*2)>>16) - xx; + int d=((xpos+xInc*3)>>16) - xx; + + memcpy(funnyCode + fragmentLength*i/4, fragment, fragmentLength); + + funnyCode[fragmentLength*i/4 + imm8OfPShufW1]= + funnyCode[fragmentLength*i/4 + imm8OfPShufW2]= + a | (b<<2) | (c<<4) | (d<<6); + + // if we dont need to read 8 bytes than dont :), reduces the chance of + // crossing a cache line + if(d<3) funnyCode[fragmentLength*i/4 + 1]= 0x6E; + + funnyCode[fragmentLength*(i+4)/4]= RET; + } + xpos+=xInc; + } +/* + xpos= 0; //chrXInc/2 - 0x10000; // difference between centers of chrom samples + for(i=0; i>16; + + if((i&3) == 0) + { + int a=0; + int b=((xpos+chrXInc)>>16) - xx; + int c=((xpos+chrXInc*2)>>16) - xx; + int d=((xpos+chrXInc*3)>>16) - xx; + + memcpy(funnyUVCode + fragmentLength*i/4, fragment, fragmentLength); + + funnyUVCode[fragmentLength*i/4 + imm8OfPShufW1]= + funnyUVCode[fragmentLength*i/4 + imm8OfPShufW2]= + a | (b<<2) | (c<<4) | (d<<6); + + // if we dont need to read 8 bytes than dont :), reduces the chance of + // crossing a cache line + if(d<3) funnyUVCode[fragmentLength*i/4 + 1]= 0x6E; + + funnyUVCode[fragmentLength*(i+4)/4]= RET; + } + xpos+=chrXInc; + } +*/ +// funnyCode[0]= RET; +} +#endif // HAVE_MMX2 + static void RENAME(SwScale_YV12slice)(unsigned char* srcptr[],int stride[], int srcSliceY , int srcSliceH, uint8_t* dstptr[], int dststride, int dstbpp, int srcW, int srcH, int dstW, int dstH){ -unsigned int s_xinc2; -//FIXME do we need th +-2 stuff? -unsigned int s_xinc= (srcW << 16) / dstW - 2; -unsigned int s_yinc= (srcH << 16) / dstH + 2; - -static int lumDstYInSrc; // points to the dst Pixels center in the source (0 is the center of pixel 0,0 in src) -static int dstY; +unsigned int lumXInc= (srcW << 16) / dstW; +unsigned int lumYInc= (srcH << 16) / dstH; +unsigned int chrXInc; +unsigned int chrYInc; -// last horzontally interpolated lines, used to avoid unnecessary calculations -static int lastLumSrcY; -static int lastChrSrcY; +static int dstY; +// used to detect a size change static int oldDstW= -1; static int oldSrcW= -1; +static int oldDstH= -1; +static int oldSrcH= -1; +static int oldFlags=-1; -int dstUVw; -int i; +static int lastInLumBuf; +static int lastInChrBuf; -if(((dstW + 7)&(~7)) >= dststride) dstW&= ~7; +int chrDstW, chrDstH; -dstUVw= fullUVIpol ? dstW : dstW/2; +static int lumBufIndex=0; +static int chrBufIndex=0; + +static int firstTime=1; + +int widthAlign= dstbpp==12 ? 16 : 8; +if(((dstW + widthAlign-1)&(~(widthAlign-1))) > dststride) +{ + dstW&= ~(widthAlign-1); + if(firstTime) + fprintf(stderr, "SwScaler: Warning: dstStride is not a multiple of %d!\n" + "SwScaler: ->lowering width to compensate, new width=%d\n" + "SwScaler: ->cannot do aligned memory acesses anymore\n", + widthAlign, dstW); +} //printf("%d %d %d %d\n", srcW, srcH, dstW, dstH); -//printf("%d %d %d %d\n", s_xinc, s_yinc, srcSliceY, srcSliceH); +//printf("%d %d %d %d\n", lumXInc, lumYInc, srcSliceY, srcSliceH); #ifdef HAVE_MMX2 -canMMX2BeUsed= (s_xinc <= 0x10000 && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0; +canMMX2BeUsed= (lumXInc <= 0x10000 && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0; +if(!canMMX2BeUsed && lumXInc <= 0x10000 && (srcW&15)==0 && sws_flags==SWS_FAST_BILINEAR) +{ + if(firstTime) //FIXME only if verbose ? + fprintf(stderr, "SwScaler: output Width is not a multiple of 32 -> no MMX2 scaler\n"); +} +#endif + +if(firstTime) +{ +#ifdef DITHER1X + char *dither= "dithered"; +#else + char *dither= ""; #endif + if(sws_flags==SWS_FAST_BILINEAR) + fprintf(stderr, "SwScaler: FAST_BILINEAR scaler "); + else if(sws_flags==SWS_BILINEAR) + fprintf(stderr, "SwScaler: BILINEAR scaler "); + else if(sws_flags==SWS_BICUBIC) + fprintf(stderr, "SwScaler: BICUBIC scaler "); + else + fprintf(stderr, "SwScaler: ehh flags invalid?! "); + + if(dstbpp==15) + fprintf(stderr, "with %s BGR15 output ", dither); + else if(dstbpp==16) + fprintf(stderr, "with %s BGR16 output ", dither); + else if(dstbpp==24) + fprintf(stderr, "with BGR24 output "); + else if(dstbpp==32) + fprintf(stderr, "with BGR32 output "); + else if(dstbpp==12) + fprintf(stderr, "with YV12 output "); + else + fprintf(stderr, "without output "); + +#ifdef HAVE_MMX2 + fprintf(stderr, "using MMX2\n"); +#elif defined (HAVE_3DNOW) + fprintf(stderr, "using 3DNOW\n"); +#elif defined (HAVE_MMX) + fprintf(stderr, "using MMX\n"); +#elif defined (ARCH_X86) + fprintf(stderr, "using X86 ASM2\n"); +#else + fprintf(stderr, "using C\n"); +#endif +} + // match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst // n-2 is the last chrominance sample available -// FIXME this is not perfect, but noone shuld notice the difference, the more correct variant +// this is not perfect, but noone shuld notice the difference, the more correct variant // would be like the vertical one, but that would require some special code for the // first and last pixel -if(canMMX2BeUsed) s_xinc+= 20; -else s_xinc = ((srcW-2)<<16)/(dstW-2) - 20; +if(sws_flags==SWS_FAST_BILINEAR) +{ + if(canMMX2BeUsed) lumXInc+= 20; + else lumXInc = ((srcW-2)<<16)/(dstW-2) - 20; +} + +if(fullUVIpol && !(dstbpp==12)) chrXInc= lumXInc>>1, chrDstW= dstW; +else chrXInc= lumXInc, chrDstW= dstW>>1; + +if(dstbpp==12) chrYInc= lumYInc, chrDstH= dstH>>1; +else chrYInc= lumYInc>>1, chrDstH= dstH; -if(fullUVIpol && !(dstbpp==12)) s_xinc2= s_xinc>>1; -else s_xinc2= s_xinc; // force calculation of the horizontal interpolation of the first line if(srcSliceY ==0){ // printf("dstW %d, srcw %d, mmx2 %d\n", dstW, srcW, canMMX2BeUsed); - lastLumSrcY=-99; - lastChrSrcY=-99; - lumDstYInSrc= s_yinc/2 - 0x8000; + lumBufIndex=0; + chrBufIndex=0; dstY=0; - // clean the buffers so that no green stuff is drawen if the width is not sane (%8=0) - for(i=dstW-2; i>1, chrDstW, filterAlign, 1<<14); + } - RENAME(initFilter)(hLumFilter, hLumFilterPos, &hLumFilterSize, s_xinc, srcW, dstW); - RENAME(initFilter)(hChrFilter, hChrFilterPos, &hChrFilterSize, s_xinc2, srcW, dstW); - #ifdef HAVE_MMX2 // cant downscale !!! - if(canMMX2BeUsed) - { - uint8_t *fragment; - int imm8OfPShufW1; - int imm8OfPShufW2; - int fragmentLength; + if(canMMX2BeUsed && sws_flags == SWS_FAST_BILINEAR) + { + initMMX2HScaler(dstW , lumXInc, funnyYCode); + initMMX2HScaler(chrDstW, chrXInc, funnyUVCode); + } +#endif + } // Init Horizontal stuff - int xpos, i; + if(oldDstH!=dstH || oldSrcH!=srcH || oldFlags!=sws_flags) + { + int i; + oldDstH= dstH; oldSrcH= srcH; oldFlags= sws_flags; //FIXME swsflags conflict with x check - // create an optimized horizontal scaling routine + // deallocate pixbufs + for(i=0; i>1, chrDstH, 1, (1<<12)-4); - asm volatile( - "jmp 9f \n\t" - // Begin - "0: \n\t" - "movq (%%esi), %%mm0 \n\t" //FIXME Alignment - "movq %%mm0, %%mm1 \n\t" - "psrlq $8, %%mm0 \n\t" - "punpcklbw %%mm7, %%mm1 \n\t" - "movq %%mm2, %%mm3 \n\t" - "punpcklbw %%mm7, %%mm0 \n\t" - "addw %%bx, %%cx \n\t" //2*xalpha += (4*s_xinc)&0xFFFF - "pshufw $0xFF, %%mm1, %%mm1 \n\t" - "1: \n\t" - "adcl %%edx, %%esi \n\t" //xx+= (4*s_xinc)>>16 + carry - "pshufw $0xFF, %%mm0, %%mm0 \n\t" - "2: \n\t" - "psrlw $9, %%mm3 \n\t" - "psubw %%mm1, %%mm0 \n\t" - "pmullw %%mm3, %%mm0 \n\t" - "paddw %%mm6, %%mm2 \n\t" // 2*alpha += xpos&0xFFFF - "psllw $7, %%mm1 \n\t" - "paddw %%mm1, %%mm0 \n\t" - - "movq %%mm0, (%%edi, %%eax) \n\t" - - "addl $8, %%eax \n\t" - // End - "9: \n\t" -// "int $3\n\t" - "leal 0b, %0 \n\t" - "leal 1b, %1 \n\t" - "leal 2b, %2 \n\t" - "decl %1 \n\t" - "decl %2 \n\t" - "subl %0, %1 \n\t" - "subl %0, %2 \n\t" - "leal 9b, %3 \n\t" - "subl %0, %3 \n\t" - :"=r" (fragment), "=r" (imm8OfPShufW1), "=r" (imm8OfPShufW2), - "=r" (fragmentLength) - ); + // Calculate Buffer Sizes so that they wont run out while handling these damn slices + vLumBufSize= vLumFilterSize; vChrBufSize= vChrFilterSize; + for(i=0; i>1)) + vChrBufSize= (nextSlice>>1) - vChrFilterPos[chrI]; + } - xpos= 0; //s_xinc/2 - 0x8000; // difference between pixel centers + // allocate pixbufs (we use dynamic allocation because otherwise we would need to + // allocate several megabytes to handle all possible cases) + for(i=0; i>16; + //try to avoid drawing green stuff between the right end and the stride end + for(i=0; i>16) - xx; - int c=((xpos+s_xinc*2)>>16) - xx; - int d=((xpos+s_xinc*3)>>16) - xx; +#ifdef HAVE_MMX + // pack filter data for mmx code + for(i=0; i>1)*(dstY>>1); + unsigned char *vDest=dstptr[2]+(dststride>>1)*(dstY>>1); + const int chrDstY= dstbpp==12 ? (dstY>>1) : dstY; - // if we dont need to read 8 bytes than dont :), reduces the chance of - // crossing a cache line - if(d<3) funnyYCode[fragmentLength*i/4 + 1]= 0x6E; + const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input + const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input + const int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input + const int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input - funnyYCode[fragmentLength*(i+4)/4]= RET; - } - xpos+=s_xinc; + if(sws_flags == SWS_FAST_BILINEAR) + { + //handle holes + if(firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1; + if(firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1; } - xpos= 0; //s_xinc2/2 - 0x10000; // difference between centers of chrom samples - for(i=0; i>16; + ASSERT(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1) + ASSERT(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1) - if((i&3) == 0) + // Do we have enough lines in this slice to output the dstY line + if(lastLumSrcY < srcSliceY + srcSliceH && lastChrSrcY < ((srcSliceY + srcSliceH)>>1)) + { + //Do horizontal scaling + while(lastInLumBuf < lastLumSrcY) { - int a=0; - int b=((xpos+s_xinc2)>>16) - xx; - int c=((xpos+s_xinc2*2)>>16) - xx; - int d=((xpos+s_xinc2*3)>>16) - xx; - - memcpy(funnyUVCode + fragmentLength*i/4, fragment, fragmentLength); - - funnyUVCode[fragmentLength*i/4 + imm8OfPShufW1]= - funnyUVCode[fragmentLength*i/4 + imm8OfPShufW2]= - a | (b<<2) | (c<<4) | (d<<6); - - // if we dont need to read 8 bytes than dont :), reduces the chance of - // crossing a cache line - if(d<3) funnyUVCode[fragmentLength*i/4 + 1]= 0x6E; - - funnyUVCode[fragmentLength*(i+4)/4]= RET; + uint8_t *src= srcptr[0]+(lastInLumBuf + 1 - srcSliceY)*stride[0]; + lumBufIndex++; + ASSERT(lumBufIndex < 2*vLumBufSize) + ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH) + ASSERT(lastInLumBuf + 1 - srcSliceY >= 0) +// printf("%d %d\n", lumBufIndex, vLumBufSize); + RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, src, srcW, lumXInc); + lastInLumBuf++; + } + while(lastInChrBuf < lastChrSrcY) + { + uint8_t *src1= srcptr[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[1]; + uint8_t *src2= srcptr[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[2]; + chrBufIndex++; + ASSERT(chrBufIndex < 2*vChrBufSize) + ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) < (srcSliceH>>1)) + ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) >= 0) + RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, srcW>>1, chrXInc); + lastInChrBuf++; } - xpos+=s_xinc2; + //wrap buf index around to stay inside the ring buffer + if(lumBufIndex >= vLumBufSize ) lumBufIndex-= vLumBufSize; + if(chrBufIndex >= vChrBufSize ) chrBufIndex-= vChrBufSize; } -// funnyCode[0]= RET; - } - -#endif // HAVE_MMX2 - } // Init stuff - } // reset counters - - while(1){ - unsigned char *dest =dstptr[0]+dststride*dstY; - unsigned char *uDest=dstptr[1]+(dststride>>1)*(dstY>>1); - unsigned char *vDest=dstptr[2]+(dststride>>1)*(dstY>>1); - - int lumSrcY=(lumDstYInSrc + 0xFFFF)>>16; // first luminance source line number below the dst line - // points to the dst Pixels center in the source (0 is the center of pixel 0,0 in src) - int chrDstYInSrc= dstbpp==12 ? lumDstYInSrc + s_yinc/2 - 0x8000 : - lumDstYInSrc - 0x8000; - int chrSrcY=(chrDstYInSrc + 0x1FFFF)>>17; // first chrominance source line number below the dst line - int yalpha= ((lumDstYInSrc-1)&0xFFFF )>>4; - int uvalpha=((chrDstYInSrc-1)&0x1FFFF)>>5; - uint16_t *buf0=pix_buf_y[ lumSrcY &1]; // top line of the interpolated slice - uint16_t *buf1=pix_buf_y[(lumSrcY+1)&1]; // bottom line of the interpolated slice - uint16_t *uvbuf0=pix_buf_uv[ chrSrcY &1]; // top line of the interpolated slice - uint16_t *uvbuf1=pix_buf_uv[(chrSrcY+1)&1]; // bottom line of the interpolated slice - - if(lumSrcY>=srcSliceY + srcSliceH && srcSliceY + srcSliceH < srcH) break; - if(dstY >= dstH) break; - -// printf("lumSrcY:%d, dstY:%d, yalpha:%d\n", lumSrcY, dstY, yalpha*100/0x1000); - - if((dstY&1) && dstbpp==12) uvalpha=-1; - - dstY++; lumDstYInSrc+=s_yinc; - - //only interpolate the src line horizontally if we didnt do it allready - if(lastLumSrcY!=lumSrcY) - { - unsigned char *src; - - // skip if first line has been horiz scaled alleady - if(lastLumSrcY != lumSrcY-1) + else // not enough lines left in this slice -> load the rest in the buffer { - // check if first line is before any available src lines - if(lumSrcY-1 < srcSliceY ) src=srcptr[0]+(0 )*stride[0]; - else src=srcptr[0]+(lumSrcY-srcSliceY -1)*stride[0]; - - RENAME(hyscale)(buf0, dstW, src, srcW, s_xinc); +/* printf("%d %d Last:%d %d LastInBuf:%d %d Index:%d %d Y:%d FSize: %d %d BSize: %d %d\n", + firstChrSrcY,firstLumSrcY,lastChrSrcY,lastLumSrcY, + lastInChrBuf,lastInLumBuf,chrBufIndex,lumBufIndex,dstY,vChrFilterSize,vLumFilterSize, + vChrBufSize, vLumBufSize); +*/ + //Do horizontal scaling + while(lastInLumBuf+1 < srcSliceY + srcSliceH) + { + uint8_t *src= srcptr[0]+(lastInLumBuf + 1 - srcSliceY)*stride[0]; + lumBufIndex++; + ASSERT(lumBufIndex < 2*vLumBufSize) + ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH) + ASSERT(lastInLumBuf + 1 - srcSliceY >= 0) + RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, src, srcW, lumXInc); + lastInLumBuf++; + } + while(lastInChrBuf+1 < ((srcSliceY + srcSliceH)>>1)) + { + uint8_t *src1= srcptr[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[1]; + uint8_t *src2= srcptr[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[2]; + chrBufIndex++; + ASSERT(chrBufIndex < 2*vChrBufSize) + ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) < (srcSliceH>>1)) + ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) >= 0) + RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, srcW>>1, chrXInc); + lastInChrBuf++; + } + //wrap buf index around to stay inside the ring buffer + if(lumBufIndex >= vLumBufSize ) lumBufIndex-= vLumBufSize; + if(chrBufIndex >= vChrBufSize ) chrBufIndex-= vChrBufSize; + break; //we cant output a dstY line so lets try with the next slice } - // check if second line is after any available src lines - if(lumSrcY-srcSliceY >= srcSliceH) src=srcptr[0]+(srcSliceH-1 )*stride[0]; - else src=srcptr[0]+(lumSrcY-srcSliceY )*stride[0]; - // the min() is required to avoid reuseing lines which where not available - lastLumSrcY= MIN(lumSrcY, srcSliceY +srcSliceH-1); - RENAME(hyscale)(buf1, dstW, src, srcW, s_xinc); - } -// printf("%d %d %d %d\n", y, chrSrcY, lastChrSrcY, h); - // *** horizontal scale U and V lines to temp buffer - if(lastChrSrcY!=chrSrcY) - { - uint8_t *src1, *src2; - // skip if first line has been horiz scaled alleady - if(lastChrSrcY != chrSrcY-1) +#ifdef HAVE_MMX + b5Dither= dither8[dstY&1]; + g6Dither= dither4[dstY&1]; + g5Dither= dither8[dstY&1]; + r5Dither= dither8[(dstY+1)&1]; +#endif + + if(dstbpp==12) //YV12 { - // check if first line is before any available src lines - if(chrSrcY-srcSliceY /2-1 < 0) + if(dstY&1) uDest=vDest= NULL; //FIXME split functions in lumi / chromi + if(vLumFilterSize == 1 && vChrFilterSize == 1) // Unscaled YV12 { - src1= srcptr[1]+(0)*stride[1]; - src2= srcptr[2]+(0)*stride[2]; - }else{ - src1= srcptr[1]+(chrSrcY-srcSliceY /2-1)*stride[1]; - src2= srcptr[2]+(chrSrcY-srcSliceY /2-1)*stride[2]; + int16_t *lumBuf = lumPixBuf[0]; + int16_t *chrBuf= chrPixBuf[0]; + RENAME(yuv2yuv1)(lumBuf, chrBuf, dest, uDest, vDest, dstW); + } + else //General YV12 + { + int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize; + int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize; + RENAME(yuv2yuvX)( + vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize, + vChrFilter+(dstY>>1)*vChrFilterSize, chrSrcPtr, vChrFilterSize, + dest, uDest, vDest, dstW, + lumMmxFilter+dstY*vLumFilterSize*4, chrMmxFilter+(dstY>>1)*vChrFilterSize*4); } - RENAME(hcscale)(uvbuf0, dstUVw, src1, src2, srcW, s_xinc2); } - - // check if second line is after any available src lines - if(chrSrcY - srcSliceY /2 >= srcSliceH/2) + else { - src1= srcptr[1]+(srcSliceH/2-1)*stride[1]; - src2= srcptr[2]+(srcSliceH/2-1)*stride[2]; - }else{ - src1= srcptr[1]+(chrSrcY-srcSliceY /2)*stride[1]; - src2= srcptr[2]+(chrSrcY-srcSliceY /2)*stride[2]; - } - RENAME(hcscale)(uvbuf1, dstUVw, src1, src2, srcW, s_xinc2); + int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize; + int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize; - // the min() is required to avoid reuseing lines which where not available - lastChrSrcY= MIN(chrSrcY, srcSliceY /2+srcSliceH/2-1); - } -#ifdef HAVE_MMX - b5Dither= dither8[dstY&1]; - g6Dither= dither4[dstY&1]; - g5Dither= dither8[dstY&1]; - r5Dither= dither8[(dstY+1)&1]; -#endif + ASSERT(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2); + ASSERT(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2); + if(vLumFilterSize == 1 && vChrFilterSize == 2) //Unscaled RGB + { + int chrAlpha= vChrFilter[2*dstY+1]; - if(dstbpp==12) //YV12 - RENAME(yuv2yuv)(buf0, buf1, uvbuf0, uvbuf1, dest, uDest, vDest, dstW, yalpha, uvalpha); - else if(ABS(s_yinc - 0x10000) < 10) - RENAME(yuv2rgb1)(buf0, buf1, uvbuf0, uvbuf1, dest, dstW, yalpha, uvalpha, dstbpp); - else - RENAME(yuv2rgbX)(buf0, buf1, uvbuf0, uvbuf1, dest, dstW, yalpha, uvalpha, dstbpp); - } + RENAME(yuv2rgb1)(*lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1), + dest, dstW, chrAlpha, dstbpp); + } + else if(vLumFilterSize == 2 && vChrFilterSize == 2) //BiLinear Upscale RGB + { + int lumAlpha= vLumFilter[2*dstY+1]; + int chrAlpha= vChrFilter[2*dstY+1]; + + RENAME(yuv2rgb2)(*lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1), + dest, dstW, lumAlpha, chrAlpha, dstbpp); + } + else //General RGB + { + RENAME(yuv2rgbX)( + vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize, + vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize, + dest, dstW, dstbpp, + lumMmxFilter+dstY*vLumFilterSize*4, chrMmxFilter+dstY*vChrFilterSize*4); + } + } + } #ifdef HAVE_MMX __asm __volatile(SFENCE:::"memory"); __asm __volatile(EMMS:::"memory"); #endif -} + firstTime=0; +} \ No newline at end of file -- cgit v1.2.3