Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

general convolution filtering of the source picture

Browse Source 
dynamic memory allocation for the buffers (needed for the filter stuff)

Originally committed as revision 4291 to svn://svn.mplayerhq.hu/mplayer/trunk/postproc
pull/126/head
Michael Niedermayer 23 years ago
parent 635b3ec6dd
commit c7f822d95e
3 changed files with 408 additions and 116 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 452
      postproc/swscale.c
  2. 60
      postproc/swscale.h
  3. 12
      postproc/swscale_template.c

452
postproc/swscale.c
Unescape View File

@ -443,7 +443,7 @@ static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilt
// 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 @@ void SwScale_YV12slice(unsigned char* src[], int srcStride[], int srcSliceY ,
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 @@ void SwScale_YV12slice(unsigned char* src[], int srcStride[], int srcSliceY ,
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 @@ static inline void initFilter(int16_t *dstFilter, int16_t *filterPos, int *filte
{
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 @@ static inline void initFilter(int16_t *dstFilter, int16_t *filterPos, int *filte
}
// 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 @@ static inline void initFilter(int16_t *dstFilter, int16_t *filterPos, int *filte
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 @@ static inline void initFilter(int16_t *dstFilter, int16_t *filterPos, int *filte
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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
{
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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
/* 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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
// 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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
* 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 @@ double *getGaussian(double variance, double quality){
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;
}
double *conv(double *a, int aLength, double *b, int bLength){
int length= aLength + bLength - 1;
void scaleVec(SwsVector *a, double scalar){
int i;
for(i=0; i<a->length; i++)
a->coeff[i]*= scalar;
}
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);
}

60
postproc/swscale.h
Unescape View File

@ -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 @@ typedef struct{
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 @@ typedef struct{
} 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 SwScale_Init();
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 @@ SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH,
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);
double *conv(double *a, int aLength, double *b, int bLength);
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);
void printVec(SwsVector *a);
void freeVec(SwsVector *a);

12
postproc/swscale_template.c
Unescape View File

@ -1935,13 +1935,10 @@ static void RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int
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 @@ static void RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int
{
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)

Write Preview
Loading…
Cancel
Save