[Mplayer-cvslog] CVS: main/postproc swscale.c,1.54,1.55 swscale_template.c,1.58,1.59 swscale.h,1.6,1.7
Michael Niedermayer
michael at mplayer.dev.hu
Mon Jan 21 04:56:50 CET 2002
Update of /cvsroot/mplayer/main/postproc
In directory mplayer:/var/tmp.root/cvs-serv6889
Modified Files:
swscale.c swscale_template.c swscale.h
Log Message:
general convolution filtering of the source picture
dynamic memory allocation for the buffers (needed for the filter stuff)
Index: swscale.c
===================================================================
RCS file: /cvsroot/mplayer/main/postproc/swscale.c,v
retrieving revision 1.54
retrieving revision 1.55
diff -u -r1.54 -r1.55
--- swscale.c 20 Jan 2002 13:45:19 -0000 1.54
+++ swscale.c 21 Jan 2002 03:56:47 -0000 1.55
@@ -443,7 +443,7 @@
// minor note: the HAVE_xyz is messed up after that line so dont use it
-// old global scaler, dont use for new code
+// old global scaler, dont use for new code, unless it uses only the stuff from the command line
// will use sws_flags from the command line
void SwScale_YV12slice(unsigned char* src[], int srcStride[], int srcSliceY ,
int srcSliceH, uint8_t* dst[], int dstStride, int dstbpp,
@@ -454,11 +454,31 @@
int flags=0;
static int firstTime=1;
int dstStride3[3]= {dstStride, dstStride>>1, dstStride>>1};
+ static SwsFilter srcFilter={NULL, NULL, NULL, NULL};
if(firstTime)
{
flags= SWS_PRINT_INFO;
firstTime=0;
+{/*
+ SwsVector *g= getGaussianVec(1.7, 2);
+ SwsVector *id= getIdentityVec();
+ scaleVec(g, 0.2);
+
+
+// srcFilter.chrH= diffVec(id, g);
+// srcFilter.chrH= shiftVec(id, 20);
+ srcFilter.chrH= g;
+// freeVec(g);
+ freeVec(id);
+
+ normalizeVec(srcFilter.chrH, 1.0);
+ printVec(srcFilter.chrH);
+
+ srcFilter.lumV= srcFilter.lumH= srcFilter.chrV= srcFilter.chrH;
+ srcFilter.lumH = srcFilter.lumV = NULL;
+// srcFilter.chrH = srcFilter.chrV = NULL;
+*/}
}
switch(dstbpp)
@@ -481,32 +501,40 @@
default:flags|= SWS_BILINEAR; break;
}
- if(!context) context=getSwsContext(srcW, srcH, IMGFMT_YV12, dstW, dstH, dstFormat, flags, NULL, NULL);
+ if(!context) context=getSwsContext(srcW, srcH, IMGFMT_YV12, dstW, dstH, dstFormat, flags, &srcFilter, NULL);
swScale(context, src, srcStride, srcSliceY, srcSliceH, dst, dstStride3);
}
-static inline void initFilter(int16_t *dstFilter, int16_t *filterPos, int *filterSize, int xInc,
- int srcW, int dstW, int filterAlign, int one, int flags)
+static inline void initFilter(int16_t **outFilter, int16_t **filterPos, int *outFilterSize, int xInc,
+ int srcW, int dstW, int filterAlign, int one, int flags,
+ SwsVector *srcFilter, SwsVector *dstFilter)
{
int i;
- double filter[10000];
+ int filterSize;
+ int filter2Size;
+ int minFilterSize;
+ double *filter=NULL;
+ double *filter2=NULL;
#ifdef ARCH_X86
if(gCpuCaps.hasMMX)
asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
#endif
+ *filterPos = (int16_t*)memalign(8, dstW*sizeof(int16_t));
+
if(ABS(xInc - 0x10000) <10) // unscaled
{
int i;
- *filterSize= (1 +(filterAlign-1)) & (~(filterAlign-1)); // 1 or 4 normaly
- for(i=0; i<dstW*(*filterSize); i++) filter[i]=0;
+ filterSize= 1;
+ filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
+ for(i=0; i<dstW*filterSize; i++) filter[i]=0;
for(i=0; i<dstW; i++)
{
- filter[i*(*filterSize)]=1;
- filterPos[i]=i;
+ filter[i*filterSize]=1;
+ (*filterPos)[i]=i;
}
}
@@ -514,19 +542,19 @@
{
int i;
int xDstInSrc;
- if (flags&SWS_BICUBIC) *filterSize= 4;
- else if(flags&SWS_X ) *filterSize= 4;
- else *filterSize= 2;
+ if (flags&SWS_BICUBIC) filterSize= 4;
+ else if(flags&SWS_X ) filterSize= 4;
+ else filterSize= 2;
// printf("%d %d %d\n", filterSize, srcW, dstW);
- *filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1));
+ filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
xDstInSrc= xInc/2 - 0x8000;
for(i=0; i<dstW; i++)
{
- int xx= (xDstInSrc>>16) - (*filterSize>>1) + 1;
+ int xx= (xDstInSrc>>16) - (filterSize>>1) + 1;
int j;
- filterPos[i]= xx;
+ (*filterPos)[i]= xx;
if((flags & SWS_BICUBIC) || (flags & SWS_X))
{
double d= ABS(((xx+1)<<16) - xDstInSrc)/(double)(1<<16);
@@ -547,21 +575,21 @@
}
// printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
- filter[i*(*filterSize) + 0]= y1;
- filter[i*(*filterSize) + 1]= y2;
- filter[i*(*filterSize) + 2]= y3;
- filter[i*(*filterSize) + 3]= y4;
+ filter[i*filterSize + 0]= y1;
+ filter[i*filterSize + 1]= y2;
+ filter[i*filterSize + 2]= y3;
+ filter[i*filterSize + 3]= y4;
// printf("%1.3f %1.3f %1.3f %1.3f %1.3f\n",d , y1, y2, y3, y4);
}
else
{
- for(j=0; j<*filterSize; j++)
+ for(j=0; j<filterSize; j++)
{
double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16);
double coeff= 1.0 - d;
if(coeff<0) coeff=0;
// printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
- filter[i*(*filterSize) + j]= coeff;
+ filter[i*filterSize + j]= coeff;
xx++;
}
}
@@ -571,19 +599,19 @@
else // downscale
{
int xDstInSrc;
- if(flags&SWS_BICUBIC) *filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
- else if(flags&SWS_X) *filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
- else *filterSize= (int)ceil(1 + 2.0*srcW / (double)dstW);
+ if(flags&SWS_BICUBIC) filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
+ else if(flags&SWS_X) 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);
- *filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1));
+ filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
xDstInSrc= xInc/2 - 0x8000;
for(i=0; i<dstW; i++)
{
- int xx= (int)((double)xDstInSrc/(double)(1<<16) - ((*filterSize)-1)*0.5 + 0.5);
+ int xx= (int)((double)xDstInSrc/(double)(1<<16) - (filterSize-1)*0.5 + 0.5);
int j;
- filterPos[i]= xx;
- for(j=0; j<*filterSize; j++)
+ (*filterPos)[i]= xx;
+ for(j=0; j<filterSize; j++)
{
double d= ABS((xx<<16) - xDstInSrc)/(double)xInc;
double coeff;
@@ -608,62 +636,155 @@
if(coeff<0) coeff=0;
}
// printf("%1.3f %d %d \n", coeff, (int)d, xDstInSrc);
- filter[i*(*filterSize) + j]= coeff;
+ filter[i*filterSize + j]= coeff;
xx++;
}
xDstInSrc+= xInc;
}
}
+ /* apply src & dst Filter to filter -> filter2
+ free(filter);
+ */
+ filter2Size= filterSize;
+ if(srcFilter) filter2Size+= srcFilter->length - 1;
+ if(dstFilter) filter2Size+= dstFilter->length - 1;
+ filter2= (double*)memalign(8, filter2Size*dstW*sizeof(double));
+
+ for(i=0; i<dstW; i++)
+ {
+ int j;
+ SwsVector scaleFilter;
+ SwsVector *outVec;
+
+ scaleFilter.coeff= filter + i*filterSize;
+ scaleFilter.length= filterSize;
+
+ if(srcFilter) outVec= convVec(srcFilter, &scaleFilter);
+ else outVec= &scaleFilter;
+
+ ASSERT(outVec->length == filter2Size)
+ //FIXME dstFilter
+
+ for(j=0; j<outVec->length; j++)
+ {
+ filter2[i*filter2Size + j]= outVec->coeff[j];
+ }
+
+ (*filterPos)[i]+= (filterSize-1)/2 - (filter2Size-1)/2;
+
+ if(outVec != &scaleFilter) freeVec(outVec);
+ }
+ free(filter); filter=NULL;
+
+ /* try to reduce the filter-size (step1 find size and shift left) */
+ // Assume its near normalized (*0.5 or *2.0 is ok but * 0.001 is not)
+ minFilterSize= 0;
+ for(i=dstW-1; i>=0; i--)
+ {
+ int min= filter2Size;
+ int j;
+ double cutOff=0.0;
+
+ /* get rid off near zero elements on the left by shifting left */
+ for(j=0; j<filter2Size; j++)
+ {
+ int k;
+ cutOff += ABS(filter2[i*filter2Size]);
+
+ if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
+
+ /* preserve Monotonicity because the core cant 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;
+ (*filterPos)[i]++;
+ }
+
+ cutOff=0.0;
+ /* count near zeros on the right */
+ for(j=filter2Size-1; j>0; j--)
+ {
+ cutOff += ABS(filter2[i*filter2Size + j]);
+
+ if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
+ min--;
+ }
+
+ if(min>minFilterSize) minFilterSize= min;
+ }
+
+ /* try to reduce the filter-size (step2 reduce it) */
+ for(i=0; i<dstW; i++)
+ {
+ int j;
+
+ for(j=0; j<minFilterSize; j++)
+ filter2[i*minFilterSize + j]= filter2[i*filter2Size + j];
+ }
+ if((flags&SWS_PRINT_INFO) && verbose)
+ printf("SwScaler: reducing filtersize %d -> %d\n", filter2Size, minFilterSize);
+ filter2Size= minFilterSize;
+ ASSERT(filter2Size > 0)
+
+ //FIXME try to align filterpos if possible
+
//fix borders
for(i=0; i<dstW; i++)
{
int j;
- if(filterPos[i] < 0)
+ if((*filterPos)[i] < 0)
{
// Move filter coeffs left to compensate for filterPos
- for(j=1; j<*filterSize; j++)
+ for(j=1; j<filter2Size; j++)
{
- int left= MAX(j + filterPos[i], 0);
- filter[i*(*filterSize) + left] += filter[i*(*filterSize) + j];
- filter[i*(*filterSize) + j]=0;
+ int left= MAX(j + (*filterPos)[i], 0);
+ filter2[i*filter2Size + left] += filter2[i*filter2Size + j];
+ filter2[i*filter2Size + j]=0;
}
- filterPos[i]= 0;
+ (*filterPos)[i]= 0;
}
- if(filterPos[i] + (*filterSize) > srcW)
+ if((*filterPos)[i] + filter2Size > srcW)
{
- int shift= filterPos[i] + (*filterSize) - srcW;
+ int shift= (*filterPos)[i] + filter2Size - srcW;
// Move filter coeffs right to compensate for filterPos
- for(j=(*filterSize)-2; j>=0; j--)
+ for(j=filter2Size-2; j>=0; j--)
{
- int right= MIN(j + shift, (*filterSize)-1);
- filter[i*(*filterSize) +right] += filter[i*(*filterSize) +j];
- filter[i*(*filterSize) +j]=0;
+ int right= MIN(j + shift, filter2Size-1);
+ filter2[i*filter2Size +right] += filter2[i*filter2Size +j];
+ filter2[i*filter2Size +j]=0;
}
- filterPos[i]= srcW - (*filterSize);
+ (*filterPos)[i]= srcW - filter2Size;
}
}
- //FIXME try to align filterpos if possible / try to shift filterpos to put zeros at the end
- // and skip these than later
- //Normalize
+ *outFilterSize= (filter2Size +(filterAlign-1)) & (~(filterAlign-1));
+ *outFilter= (int16_t*)memalign(8, *outFilterSize*dstW*sizeof(int16_t));
+ memset(*outFilter, 0, *outFilterSize*dstW*sizeof(int16_t));
+
+ /* Normalize & Store in outFilter */
for(i=0; i<dstW; i++)
{
int j;
double sum=0;
double scale= one;
- for(j=0; j<*filterSize; j++)
+ for(j=0; j<filter2Size; j++)
{
- sum+= filter[i*(*filterSize) + j];
+ sum+= filter2[i*filter2Size + j];
}
scale/= sum;
- for(j=0; j<*filterSize; j++)
+ for(j=0; j<filter2Size; j++)
{
- dstFilter[i*(*filterSize) + j]= (int)(filter[i*(*filterSize) + j]*scale);
+ (*outFilter)[i*(*outFilterSize) + j]= (int)(filter2[i*filter2Size + j]*scale);
}
}
+
+ free(filter2);
}
#ifdef ARCH_X86
@@ -822,18 +943,12 @@
const int widthAlign= dstFormat==IMGFMT_YV12 ? 16 : 8;
SwsContext *c;
int i;
-//const int bytespp= (dstbpp+1)/8; //(12->1, 15&16->2, 24->3, 32->4)
-//const int over= dstFormat==IMGFMT_YV12 ? (((dstW+15)&(~15))) - dststride
-// : (((dstW+7)&(~7)))*bytespp - dststride;
+ SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
+
if(swScale==NULL) globalInit();
/* sanity check */
if(srcW<1 || srcH<1 || dstW<1 || dstH<1) return NULL;
- if(srcW>=SWS_MAX_SIZE || dstW>=SWS_MAX_SIZE || srcH>=SWS_MAX_SIZE || dstH>=SWS_MAX_SIZE)
- {
- fprintf(stderr, "size is too large, increase SWS_MAX_SIZE\n");
- return NULL;
- }
/* FIXME
if(dstStride[0]%widthAlign !=0 )
@@ -844,7 +959,11 @@
widthAlign);
}
*/
+ if(!dstFilter) dstFilter= &dummyFilter;
+ if(!srcFilter) srcFilter= &dummyFilter;
+
c= memalign(64, sizeof(SwsContext));
+ memset(c, 0, sizeof(SwsContext));
c->srcW= srcW;
c->srcH= srcH;
@@ -895,10 +1014,12 @@
{
const int filterAlign= cpuCaps.hasMMX ? 4 : 1;
- initFilter(c->hLumFilter, c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
- srcW , dstW, filterAlign, 1<<14, flags);
- initFilter(c->hChrFilter, c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
- (srcW+1)>>1, c->chrDstW, filterAlign, 1<<14, flags);
+ initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
+ srcW , dstW, filterAlign, 1<<14, flags,
+ srcFilter->lumH, dstFilter->lumH);
+ initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
+ (srcW+1)>>1, c->chrDstW, filterAlign, 1<<14, flags,
+ srcFilter->chrH, dstFilter->chrH);
#ifdef ARCH_X86
// cant downscale !!!
@@ -913,10 +1034,12 @@
/* precalculate vertical scaler filter coefficients */
- initFilter(c->vLumFilter, c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
- srcH , dstH, 1, (1<<12)-4, flags);
- initFilter(c->vChrFilter, c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
- (srcH+1)>>1, c->chrDstH, 1, (1<<12)-4, flags);
+ initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
+ srcH , dstH, 1, (1<<12)-4, flags,
+ srcFilter->lumV, dstFilter->lumV);
+ initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
+ (srcH+1)>>1, c->chrDstH, 1, (1<<12)-4, flags,
+ srcFilter->chrV, dstFilter->chrV);
// Calculate Buffer Sizes so that they wont run out while handling these damn slices
c->vLumBufSize= c->vLumFilterSize;
@@ -935,6 +1058,8 @@
// allocate pixbufs (we use dynamic allocation because otherwise we would need to
// allocate several megabytes to handle all possible cases)
+ c->lumPixBuf= (int16_t**)memalign(4, c->vLumBufSize*2*sizeof(int16_t*));
+ c->chrPixBuf= (int16_t**)memalign(4, c->vChrBufSize*2*sizeof(int16_t*));
for(i=0; i<c->vLumBufSize; i++)
c->lumPixBuf[i]= c->lumPixBuf[i+c->vLumBufSize]= (uint16_t*)memalign(8, 4000);
for(i=0; i<c->vChrBufSize; i++)
@@ -945,12 +1070,12 @@
for(i=0; i<c->vChrBufSize; i++) memset(c->chrPixBuf[i], 64, 8000);
ASSERT(c->chrDstH <= dstH)
- ASSERT(c->vLumFilterSize* dstH*4 <= SWS_MAX_SIZE*20)
- ASSERT(c->vChrFilterSize*c->chrDstH*4 <= SWS_MAX_SIZE*20)
// pack filter data for mmx code
if(cpuCaps.hasMMX)
{
+ c->lumMmxFilter= (int16_t*)memalign(8, c->vLumFilterSize* dstH*4*sizeof(int16_t));
+ c->chrMmxFilter= (int16_t*)memalign(8, c->vChrFilterSize*c->chrDstH*4*sizeof(int16_t));
for(i=0; i<c->vLumFilterSize*dstH; i++)
c->lumMmxFilter[4*i]=c->lumMmxFilter[4*i+1]=c->lumMmxFilter[4*i+2]=c->lumMmxFilter[4*i+3]=
c->vLumFilter[i];
@@ -1064,11 +1189,16 @@
* returns a normalized gaussian curve used to filter stuff
* quality=3 is high quality, lowwer is lowwer quality
*/
-double *getGaussian(double variance, double quality){
+
+SwsVector *getGaussianVec(double variance, double quality){
const int length= (int)(variance*quality + 0.5) | 1;
int i;
double *coeff= memalign(sizeof(double), length*sizeof(double));
double middle= (length-1)*0.5;
+ SwsVector *vec= malloc(sizeof(SwsVector));
+
+ vec->coeff= coeff;
+ vec->length= length;
for(i=0; i<length; i++)
{
@@ -1076,51 +1206,201 @@
coeff[i]= exp( -dist*dist/(2*variance*variance) ) / sqrt(2*variance*PI);
}
- normalize(coeff, length, 1.0);
- return coeff;
+ normalizeVec(vec, 1.0);
+
+ return vec;
}
-void normalize(double *coeff, int length, double height){
+SwsVector *getIdentityVec(void){
+ double *coeff= memalign(sizeof(double), sizeof(double));
+ SwsVector *vec= malloc(sizeof(SwsVector));
+ coeff[0]= 1.0;
+
+ vec->coeff= coeff;
+ vec->length= 1;
+
+ return vec;
+}
+
+void normalizeVec(SwsVector *a, double height){
int i;
double sum=0;
double inv;
- for(i=0; i<length; i++)
- sum+= coeff[i];
+ for(i=0; i<a->length; i++)
+ sum+= a->coeff[i];
inv= height/sum;
- for(i=0; i<length; i++)
- coeff[i]*= height;
+ for(i=0; i<a->length; i++)
+ a->coeff[i]*= height;
+}
+
+void scaleVec(SwsVector *a, double scalar){
+ int i;
+
+ for(i=0; i<a->length; i++)
+ a->coeff[i]*= scalar;
}
-double *conv(double *a, int aLength, double *b, int bLength){
- int length= aLength + bLength - 1;
+SwsVector *convVec(SwsVector *a, SwsVector *b){
+ int length= a->length + b->length - 1;
double *coeff= memalign(sizeof(double), length*sizeof(double));
int i, j;
+ SwsVector *vec= malloc(sizeof(SwsVector));
+
+ vec->coeff= coeff;
+ vec->length= length;
for(i=0; i<length; i++) coeff[i]= 0.0;
- for(i=0; i<aLength; i++)
+ for(i=0; i<a->length; i++)
{
- for(j=0; j<bLength; j++)
+ for(j=0; j<b->length; j++)
{
- coeff[i+j]+= a[i]*b[j];
+ coeff[i+j]+= a->coeff[i]*b->coeff[j];
}
}
- return coeff;
+ return vec;
}
-/*
-double *sum(double *a, int aLength, double *b, int bLength){
- int length= MAX(aLength, bLength);
+SwsVector *sumVec(SwsVector *a, SwsVector *b){
+ int length= MAX(a->length, b->length);
double *coeff= memalign(sizeof(double), length*sizeof(double));
int i;
+ SwsVector *vec= malloc(sizeof(SwsVector));
+
+ vec->coeff= coeff;
+ vec->length= length;
for(i=0; i<length; i++) coeff[i]= 0.0;
- for(i=0; i<aLength; i++) coeff[i]+= a[i];
+ for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
+ for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]+= b->coeff[i];
+
+ return vec;
}
-*/
+
+SwsVector *diffVec(SwsVector *a, SwsVector *b){
+ int length= MAX(a->length, b->length);
+ double *coeff= memalign(sizeof(double), length*sizeof(double));
+ int i;
+ SwsVector *vec= malloc(sizeof(SwsVector));
+
+ vec->coeff= coeff;
+ vec->length= length;
+
+ for(i=0; i<length; i++) coeff[i]= 0.0;
+
+ for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
+ for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]-= b->coeff[i];
+
+ return vec;
+}
+
+/* shift left / or right if "shift" is negative */
+SwsVector *shiftVec(SwsVector *a, int shift){
+ int length= a->length + ABS(shift)*2;
+ double *coeff= memalign(sizeof(double), length*sizeof(double));
+ int i, j;
+ SwsVector *vec= malloc(sizeof(SwsVector));
+
+ vec->coeff= coeff;
+ vec->length= length;
+
+ for(i=0; i<length; i++) coeff[i]= 0.0;
+
+ for(i=0; i<a->length; i++)
+ {
+ coeff[i + (length-1)/2 - (a->length-1)/2 - shift]= a->coeff[i];
+ }
+
+ return vec;
+}
+
+void printVec(SwsVector *a){
+ int i;
+ double max=0;
+ double min=0;
+ double range;
+
+ for(i=0; i<a->length; i++)
+ if(a->coeff[i]>max) max= a->coeff[i];
+
+ for(i=0; i<a->length; i++)
+ if(a->coeff[i]<min) min= a->coeff[i];
+
+ range= max - min;
+
+ for(i=0; i<a->length; i++)
+ {
+ int x= (int)((a->coeff[i]-min)*60.0/range +0.5);
+ printf("%1.3f ", a->coeff[i]);
+ for(;x>0; x--) printf(" ");
+ printf("|\n");
+ }
+}
+
+void freeVec(SwsVector *a){
+ if(!a) return;
+ if(a->coeff) free(a->coeff);
+ a->coeff=NULL;
+ a->length=0;
+ free(a);
+}
+
+void freeSwsContext(SwsContext *c){
+ int i;
+
+ if(!c) return;
+
+ if(c->lumPixBuf)
+ {
+ for(i=0; i<c->vLumBufSize*2; i++)
+ {
+ if(c->lumPixBuf[i]) free(c->lumPixBuf[i]);
+ c->lumPixBuf[i]=NULL;
+ }
+ free(c->lumPixBuf);
+ c->lumPixBuf=NULL;
+ }
+
+ if(c->chrPixBuf)
+ {
+ for(i=0; i<c->vChrBufSize*2; i++)
+ {
+ if(c->chrPixBuf[i]) free(c->chrPixBuf[i]);
+ c->chrPixBuf[i]=NULL;
+ }
+ free(c->chrPixBuf);
+ c->chrPixBuf=NULL;
+ }
+
+ if(c->vLumFilter) free(c->vLumFilter);
+ c->vLumFilter = NULL;
+ if(c->vChrFilter) free(c->vChrFilter);
+ c->vChrFilter = NULL;
+ if(c->hLumFilter) free(c->hLumFilter);
+ c->hLumFilter = NULL;
+ if(c->hChrFilter) free(c->hChrFilter);
+ c->hChrFilter = NULL;
+
+ if(c->vLumFilterPos) free(c->vLumFilterPos);
+ c->vLumFilterPos = NULL;
+ if(c->vChrFilterPos) free(c->vChrFilterPos);
+ c->vChrFilterPos = NULL;
+ if(c->hLumFilterPos) free(c->hLumFilterPos);
+ c->hLumFilterPos = NULL;
+ if(c->hChrFilterPos) free(c->hChrFilterPos);
+ c->hChrFilterPos = NULL;
+
+ if(c->lumMmxFilter) free(c->lumMmxFilter);
+ c->lumMmxFilter = NULL;
+ if(c->chrMmxFilter) free(c->chrMmxFilter);
+ c->chrMmxFilter = NULL;
+
+ free(c);
+}
+
Index: swscale_template.c
===================================================================
RCS file: /cvsroot/mplayer/main/postproc/swscale_template.c,v
retrieving revision 1.58
retrieving revision 1.59
diff -u -r1.58 -r1.59
--- swscale_template.c 20 Jan 2002 05:30:23 -0000 1.58
+++ swscale_template.c 21 Jan 2002 03:56:47 -0000 1.59
@@ -1935,13 +1935,10 @@
const int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input
const int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input
- if(flags&SWS_FAST_BILINEAR)
- {
- //handle holes
- if(firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;
- if(firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;
- }
-
+ //handle holes (FAST_BILINEAR & weird filters)
+ if(firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;
+ if(firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;
+//printf("%d %d %d\n", firstChrSrcY, lastInChrBuf, vChrBufSize);
ASSERT(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1)
ASSERT(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1)
@@ -1953,6 +1950,7 @@
{
uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];
lumBufIndex++;
+// printf("%d %d %d %d\n", lumBufIndex, vLumBufSize, lastInLumBuf, lastLumSrcY);
ASSERT(lumBufIndex < 2*vLumBufSize)
ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)
ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)
Index: swscale.h
===================================================================
RCS file: /cvsroot/mplayer/main/postproc/swscale.h,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- swscale.h 20 Jan 2002 05:30:23 -0000 1.6
+++ swscale.h 21 Jan 2002 03:56:47 -0000 1.7
@@ -7,7 +7,7 @@
#define SWS_FULL_UV_IPOL 0x100
#define SWS_PRINT_INFO 0x1000
-#define SWS_MAX_SIZE 2000
+#define SWS_MAX_REDUCE_CUTOFF 0.002
/* this struct should be aligned on at least 32-byte boundary */
typedef struct{
@@ -16,20 +16,21 @@
int lumXInc, chrXInc;
int lumYInc, chrYInc;
int dstFormat, srcFormat;
- int16_t __attribute__((aligned(8))) *lumPixBuf[SWS_MAX_SIZE];
- int16_t __attribute__((aligned(8))) *chrPixBuf[SWS_MAX_SIZE];
- int16_t __attribute__((aligned(8))) hLumFilter[SWS_MAX_SIZE*5];
- int16_t __attribute__((aligned(8))) hLumFilterPos[SWS_MAX_SIZE];
- int16_t __attribute__((aligned(8))) hChrFilter[SWS_MAX_SIZE*5];
- int16_t __attribute__((aligned(8))) hChrFilterPos[SWS_MAX_SIZE];
- int16_t __attribute__((aligned(8))) vLumFilter[SWS_MAX_SIZE*5];
- int16_t __attribute__((aligned(8))) vLumFilterPos[SWS_MAX_SIZE];
- int16_t __attribute__((aligned(8))) vChrFilter[SWS_MAX_SIZE*5];
- int16_t __attribute__((aligned(8))) vChrFilterPos[SWS_MAX_SIZE];
+
+ 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;
// Contain simply the values from v(Lum|Chr)Filter just nicely packed for mmx
- int16_t __attribute__((aligned(8))) lumMmxFilter[SWS_MAX_SIZE*20];
- int16_t __attribute__((aligned(8))) chrMmxFilter[SWS_MAX_SIZE*20];
+ int16_t *lumMmxFilter;
+ int16_t *chrMmxFilter;
int hLumFilterSize;
int hChrFilterSize;
@@ -52,12 +53,19 @@
} SwsContext;
//FIXME check init (where 0)
+// when used for filters they must have an odd number of elements
+// coeffs cannot be shared between vectors
typedef struct {
- double *lumH;
- double *lumV;
- double *chrH;
- double *chrV;
+ double *coeff;
int length;
+} SwsVector;
+
+// vectors can be shared
+typedef struct {
+ SwsVector *lumH;
+ SwsVector *lumV;
+ SwsVector *chrH;
+ SwsVector *chrV;
} SwsFilter;
@@ -74,7 +82,7 @@
-void freeSwsContext(SwsContext swsContext);
+void freeSwsContext(SwsContext *swsContext);
SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags,
SwsFilter *srcFilter, SwsFilter *dstFilter);
@@ -82,9 +90,15 @@
extern void (*swScale)(SwsContext *context, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[]);
-double *getGaussian(double variance, double quality);
-
-void normalize(double *coeff, int length, double height);
+SwsVector *getGaussianVec(double variance, double quality);
+SwsVector *getIdentityVec(void);
+void scaleVec(SwsVector *a, double scalar);
+void normalizeVec(SwsVector *a, double height);
+SwsVector *convVec(SwsVector *a, SwsVector *b);
+SwsVector *sumVec(SwsVector *a, SwsVector *b);
+SwsVector *diffVec(SwsVector *a, SwsVector *b);
+SwsVector *shiftVec(SwsVector *a, int shift);
-double *conv(double *a, int aLength, double *b, int bLength);
+void printVec(SwsVector *a);
+void freeVec(SwsVector *a);
More information about the MPlayer-cvslog
mailing list