X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fh.263%2Fmkvideo.c;h=83f67c3f56b4198a167dda011fcc8507be50b166;hb=e6e33b2e3b1e1277aef488b9c2e39394b7830db7;hp=fda9044e825879a6e7c6b8f2b4cd228a90541cb8;hpb=ca5db7757597507d121d6500724e0ee208f20b46;p=swftools.git diff --git a/lib/h.263/mkvideo.c b/lib/h.263/mkvideo.c index fda9044..83f67c3 100644 --- a/lib/h.263/mkvideo.c +++ b/lib/h.263/mkvideo.c @@ -9,18 +9,9 @@ #include #include #include -#include "../lib/rfxswf.h" -#include "png.h" +#include "../rfxswf.h" #include "h263tables.c" - -typedef struct _VIDEOSTREAM -{ - int width; - int height; - int frame; - RGBA*oldpic; - RGBA*current; -} VIDEOSTREAM; +#include "swfvideo.h" void swf_SetVideoStreamDefine(TAG*tag, VIDEOSTREAM*stream, U16 frames, U16 width, U16 height) { @@ -32,11 +23,29 @@ void swf_SetVideoStreamDefine(TAG*tag, VIDEOSTREAM*stream, U16 frames, U16 width swf_SetU8(tag, 2); /* codec = h.263 sorenson spark */ memset(stream, 0, sizeof(VIDEOSTREAM)); - stream->width = width&~15; - stream->height = height&~15; - stream->oldpic = (RGBA*)malloc(width*height*sizeof(RGBA)); - - memset(stream->oldpic, 0, width*height*sizeof(RGBA)); + stream->olinex = width; + width+=15;width&=~15; + height+=15;height&=~15; + stream->linex = width; + stream->width = width; + stream->height = height; + stream->bbx = width/16; + stream->bby = height/16; + stream->current = (YUV*)malloc(width*height*sizeof(YUV)); + stream->oldpic = (YUV*)malloc(width*height*sizeof(YUV)); + stream->mvdx = (int*)malloc(stream->bbx*stream->bby*sizeof(int)); + stream->mvdy = (int*)malloc(stream->bbx*stream->bby*sizeof(int)); + stream->do_motion = 0; + + memset(stream->oldpic, 0, width*height*sizeof(YUV)); + memset(stream->current, 0, width*height*sizeof(YUV)); +} +void swf_VideoStreamClear(VIDEOSTREAM*stream) +{ + free(stream->oldpic);stream->oldpic = 0; + free(stream->current);stream->current = 0; + free(stream->mvdx);stream->mvdx=0; + free(stream->mvdy);stream->mvdy=0; } typedef struct _block_t @@ -59,22 +68,23 @@ typedef struct _fblock_t double v[64]; } fblock_t; +static int zigzagtable[64] = { + 0, 1, 5, 6, 14, 15, 27, 28, + 2, 4, 7, 13, 16, 26, 29, 42, + 3, 8, 12, 17, 25, 30, 41, 43, + 9, 11, 18, 24, 31, 40, 44, 53, + 10, 19, 23, 32, 39, 45, 52, 54, + 20, 22, 33, 38, 46, 51, 55, 60, + 21, 34, 37, 47, 50, 56, 59, 61, + 35, 36, 48, 49, 57, 58, 62, 63}; + static void fzigzag(double*src) { - int table[64] = { - 0, 1, 5, 6, 14, 15, 27, 28, - 2, 4, 7, 13, 16, 26, 29, 42, - 3, 8, 12, 17, 25, 30, 41, 43, - 9, 11, 18, 24, 31, 40, 44, 53, - 10, 19, 23, 32, 39, 45, 52, 54, - 20, 22, 33, 38, 46, 51, 55, 60, - 21, 34, 37, 47, 50, 56, 59, 61, - 35, 36, 48, 49, 57, 58, 62, 63}; double tmp[64]; int t; for(t=0;t<64;t++) { - ((int*)&tmp[table[t]])[0] = ((int*)&src[t])[0]; - ((int*)&tmp[table[t]])[1] = ((int*)&src[t])[1]; + ((int*)&tmp[zigzagtable[t]])[0] = ((int*)&src[t])[0]; + ((int*)&tmp[zigzagtable[t]])[1] = ((int*)&src[t])[1]; } memcpy(src, tmp, sizeof(double)*64); } @@ -148,66 +158,219 @@ static void idct(double*src) } } -static void getregion(fblock_t* bb, RGBA*pic, int bx, int by, int width, int height) +static double c[8] = {1.0, +0.980785280403230, // cos(Pi*1/16), sin(Pi*7/16) +0.923879532511287, // cos(Pi*2/16), sin(Pi*6/16) +0.831469612302545, // cos(Pi*3/16), sin(Pi*5/16) +0.707106781186548, // cos(Pi*4/16), sin(Pi*4/16), 1/sqrt(2) +0.555570233019602, // cos(Pi*5/16), sin(Pi*3/16) +0.382683432365090, // cos(Pi*6/16), sin(Pi*2/16) +0.195090322016128 // cos(Pi*7/16), sin(Pi*1/16) +}; + +static double cc[8]; +int ccquant = -1; + +static void preparequant(int quant) +{ + if(ccquant == quant) + return; + cc[0] = c[0]/(quant*2*4); + cc[1] = c[1]/(quant*2*4); + cc[2] = c[2]/(quant*2*4); + cc[3] = c[3]/(quant*2*4); + cc[4] = c[4]/(quant*2*4); + cc[5] = c[5]/(quant*2*4); + cc[6] = c[6]/(quant*2*4); + cc[7] = c[7]/(quant*2*4); + ccquant = quant; +} + +inline static void innerdct(double*a,double*b, double*c) +{ + // c1*c7*2 = c6 + // c2*c6*2 = c4 + // c3*c5*2 = c2 + // c4*c4*2 = 1 + + //{ 1, 3, 5, 7, -7, -5, -3, -1}, + //{ 3, -7, -1, -5, 5, 1, 7, -3}, + //{ 5, -1, 7, 3, -3, -7, 1, -5}, + //{ 7, -5, 3, -1, 1, -3, 5, -7} + double b0,b1,b2,b3,b4,b5; + b2 = (a[0]+a[7]); + b3 = (a[1]+a[6]); + b4 = (a[2]+a[5]); + b5 = (a[3]+a[4]); + + b0 = (b2+b5)*c[4]; + b1 = (b3+b4)*c[4]; + b[0*8] = b0 + b1; + b[4*8] = b0 - b1; + b[2*8] = (b2-b5)*c[2] + (b3-b4)*c[6]; + b[6*8] = (b2-b5)*c[6] + (b4-b3)*c[2]; + + b0 = (a[0]-a[7]); + b1 = (a[1]-a[6]); + b2 = (a[2]-a[5]); + b3 = (a[3]-a[4]); + + b[1*8] = b0*c[1] + b1*c[3] + b2*c[5] + b3*c[7]; + b[3*8] = b0*c[3] - b1*c[7] - b2*c[1] - b3*c[5]; + b[5*8] = b0*c[5] - b1*c[1] + b2*c[7] + b3*c[3]; + b[7*8] = b0*c[7] - b1*c[5] + b2*c[3] - b3*c[1]; +} + +static void dct2(double*src, int*dest) +{ + double tmp[64], tmp2[64]; + double*p; + int u,x,v,t; + + for(v=0;v<8;v++) + { + double* a=&src[v*8]; + double* b=&tmp[v]; + innerdct(a,b,c); + } + for(v=0;v<8;v++) + { + double* a=&tmp[v*8]; + double* b=&tmp2[v]; + innerdct(a,b,cc); + } + for(t=0;t<64;t++) { + dest[zigzagtable[t]] = (int)(tmp2[t]); + } +} + + +static inline int truncate256(int a) { - RGBA*p1 = &pic[by*width*16+bx*16]; - RGBA*p2 = p1; - int linex = width; + if(a>255) return 255; + if(a<0) return 0; + return a; +} + +static void getregion(fblock_t* bb, YUV*pic, int posx, int posy, int linex) +{ + YUV*p1 = &pic[posy*linex+posx]; + YUV*p2 = p1; int y1=0, y2=0, y3=0, y4=0; int u=0,v=0; int x,y; for(y=0;y<8;y++) { for(x=0;x<8;x++) { - double r,g,b; - r = (p2[x*2].r + p2[x*2+1].r + p2[linex+x*2].r + p2[linex+x*2+1].r)/4.0; - g = (p2[x*2].g + p2[x*2+1].g + p2[linex+x*2].g + p2[linex+x*2+1].g)/4.0; - b = (p2[x*2].b + p2[x*2+1].b + p2[linex+x*2].b + p2[linex+x*2+1].b)/4.0; - bb->u[u++] = (r*-0.169 + g*-0.332 + b*0.500 + 128.0); - bb->v[v++] = (r*0.500 + g*-0.419 + b*-0.0813 + 128.0); - - r = p1[x].r; g = p1[x].g; b = p1[x].b; - bb->y1[y1++] = (r*0.299 + g*0.587 + b*0.114); - r = p1[x+8].r; g = p1[x+8].g; b = p1[x+8].b; - bb->y2[y2++] = (r*0.299 + g*0.587 + b*0.114); - r = p1[linex*8+x].r; g = p1[linex*8+x].g; b = p1[linex*8+x].b; - bb->y3[y3++] = (r*0.299 + g*0.587 + b*0.114); - r = p1[linex*8+x+8].r; g = p1[linex*8+x+8].g; b = p1[linex*8+x+8].b; - bb->y4[y4++] = (r*0.299 + g*0.587 + b*0.114); + bb->u[u++] = (p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4; + bb->v[v++] = (p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4; + bb->y1[y1++] = p1[x].y; + bb->y2[y2++] = p1[x+8].y; + bb->y3[y3++] = p1[linex*8+x].y; + bb->y4[y4++] = p1[linex*8+x+8].y; } p1+=linex; p2+=linex*2; } } +static void rgb2yuv(YUV*dest, RGBA*src, int dlinex, int slinex, int width, int height) +{ + int x,y; + for(y=0;y>8; + dest[y*dlinex+x].u = (r*((int)(-0.169*256)) + g*((int)(-0.332*256)) + b*((int)( 0.500 *256))+ 128*256)>>8; + dest[y*dlinex+x].v = (r*((int)( 0.500*256)) + g*((int)(-0.419*256)) + b*((int)(-0.0813*256))+ 128*256)>>8; + } + } +} +static void copyregion(VIDEOSTREAM*s, YUV*dest, YUV*src, int bx, int by) +{ + YUV*p1 = &src[by*s->linex*16+bx*16]; + YUV*p2 = &dest[by*s->linex*16+bx*16]; + int y; + for(y=0;y<16;y++) { + memcpy(p1, p2, 16*sizeof(YUV)); + p1+=s->linex;p2+=s->linex; + } +} -int compareregions(VIDEOSTREAM*s, int bx, int by) +static void yuv2rgb(RGBA*dest, YUV*src, int linex, int width, int height) +{ + int x,y; + for(y=0;y>8)); + dest[y*linex+x].g = truncate256(yy - ((88*(u-128)+183*(v-128))>>8)); + dest[y*linex+x].b = truncate256(yy + ((455 * (u-128))>>8)); + } + } +} +static void copyblock(VIDEOSTREAM*s, YUV*dest, block_t*b, int bx, int by) +{ + YUV*p1 = &dest[(by*16)*s->linex+bx*16]; + YUV*p2 = &dest[(by*16+8)*s->linex+bx*16]; + int x,y; + for(y=0;y<8;y++) { + for(x=0;x<8;x++) { + int u,v,yy; + p1[x+0].u = b->u[(y/2)*8+(x/2)]; + p1[x+0].v = b->v[(y/2)*8+(x/2)]; + p1[x+0].y = b->y1[y*8+x]; + p1[x+8].u = b->u[(y/2)*8+(x/2)+4]; + p1[x+8].v = b->v[(y/2)*8+(x/2)+4]; + p1[x+8].y = b->y2[y*8+x]; + p2[x+0].u = b->u[(y/2+4)*8+(x/2)]; + p2[x+0].v = b->v[(y/2+4)*8+(x/2)]; + p2[x+0].y = b->y3[y*8+x]; + p2[x+8].u = b->u[(y/2+4)*8+(x/2)+4]; + p2[x+8].v = b->v[(y/2+4)*8+(x/2)+4]; + p2[x+8].y = b->y4[y*8+x]; + } + p1+=s->linex; + p2+=s->linex; + } +} + +static int compareregions(VIDEOSTREAM*s, int bx, int by) { int linex = s->width; - RGBA*p1 = &s->current[by*linex*16+bx*16]; - RGBA*p2 = &s->oldpic[by*linex*16+bx*16]; + YUV*p1 = &s->current[by*linex*16+bx*16]; + YUV*p2 = &s->oldpic[by*linex*16+bx*16]; int diff = 0; int x,y; for(y=0;y<16;y++) { for(x=0;x<16;x++) { - RGBA*m = &p1[x]; - RGBA*n = &p2[x]; - int r = m->r - n->r; - int g = m->g - n->g; - int b = m->b - n->b; - diff += r*r+g*g+b*b; + YUV*m = &p1[x]; + YUV*n = &p2[x]; + int y = m->y - n->y; + int u = m->u - n->u; + int v = m->v - n->v; + diff += y*y+(u*u+v*v)/4; } p1+=linex; p2+=linex; } - return diff; + return diff/256; } -static int valtodc(int val) +static inline int valtodc(int val) { assert(val>=0); /* table 12/h.263 */ - val+=4; //round + //val+=4; //round val/=8; /* TODO: what to do for zero values? skip the block? */ if(val==0) @@ -218,8 +381,20 @@ static int valtodc(int val) return 254; return val; } +static int dctoval(int dc) +{ + int val; + assert(dc>0); + assert(dc!=128); + assert(dc<256); + /* table 12/h.263 */ + val = dc*8; + if(val == 255*8) + val = 128*8; + return val; +} -static void codehuffman(TAG*tag, struct huffcode*table, int index) +static int codehuffman(TAG*tag, struct huffcode*table, int index) { /* TODO: !optimize! */ int i=0; @@ -230,26 +405,58 @@ static void codehuffman(TAG*tag, struct huffcode*table, int index) swf_SetBits(tag, 1, 1); i++; } + return i; } static void quantize8x8(double*src, int*dest, int has_dc, int quant) { int t,pos=0; + double q = 1.0/(quant*2); if(has_dc) { dest[0] = valtodc((int)src[0]); /*DC*/ pos++; } for(t=pos;t<64;t++) { - dest[t] = (int)src[t]; - //val = (quant*(2*level+1)-1)+quant&1 -/* if(quant&1) { - dest[t] = (dest[t]/quant - 1)/2; - } else { - dest[t] = ((dest[t]+1)/quant - 1)/2; - }*/ - //dest[t] = (dest[t]/quant-1)/2; - dest[t] = dest[t]/(quant*2); + //dest[t] = (int)src[t]; + /* exact: if(quant&1){dest[t] = (dest[t]/quant - 1)/2;}else{dest[t] = ((dest[t]+1)/quant - 1)/2;} */ + //if(quant&1){dest[t] = (dest[t]/quant - 1)/2;}else{dest[t] = ((dest[t]+1)/quant - 1)/2;} + //dest[t] = dest[t]/(quant*2); + dest[t] = (int)(src[t]*q); + /* TODO: warn if this happens- the video will be buggy */ + if(dest[t]>127) dest[t]=127; + if(dest[t]<-127) dest[t]=-127; + } +} + +static void dequantize8x8(int*b, int has_dc, int quant) +{ + int t,pos=0; + if(has_dc) { + b[0] = dctoval(b[0]); //DC + pos++; + } + for(t=pos;t<64;t++) { + if(b[t]) { + int sign = 0; + if(b[t]<0) { + b[t] = -b[t]; + sign = 1; + } + + if(quant&1) { + b[t] = quant*(2*b[t]+1); //-7,8,24,40 + } else { + b[t] = quant*(2*b[t]+1)-1; //-8,7,23,39 + } + + if(sign) + b[t] = -b[t]; + } + + /* paragraph 6.2.2, "clipping of reconstruction levels": */ + if(b[t]>2047) b[t]=2047; + if(b[t]<-2048) b[t]=-2048; } } @@ -257,20 +464,66 @@ static int hascoef(int*b, int has_dc) { int t; int pos=0; - int range=2; /*TODO: should be a global parameter */ if(has_dc) pos++; for(t=pos;t<64;t++) { - if(b[t]<=-range || b[t]>=range) + if(b[t]) return 1; } return 0; } +static int coefbits8x8(int*bb, int has_dc) +{ + int t; + int pos=0; + int bits=0; + int last; + + if(has_dc) { + bits+=8; + pos++; + } + for(last=63;last>=pos;last--) { + if(bb[last]) + break; + } + if(last < pos) + return bits; + while(1) { + int run=0, level=0, islast=0,t; + while(!bb[pos] && pos127) level = 127; + assert(level>=-127); + assert(level<=127); swf_SetBits(tag, islast, 1); swf_SetBits(tag, run, 6); - swf_SetBits(tag, level, 8); //fixme + swf_SetBits(tag, level, 8); //FIXME: fixme?? } if(islast) break; pos++; } - - //codehuffman(tag, rle, 58); - //swf_SetBits(tag, 1, 1); //sign } } +static void quantize(fblock_t*fb, block_t*b, int has_dc, int quant) +{ + quantize8x8(fb->y1, b->y1, has_dc, quant); + quantize8x8(fb->y2, b->y2, has_dc, quant); + quantize8x8(fb->y3, b->y3, has_dc, quant); + quantize8x8(fb->y4, b->y4, has_dc, quant); + quantize8x8(fb->u, b->u, has_dc, quant); + quantize8x8(fb->v, b->v, has_dc, quant); +} + static void dodct(fblock_t*fb) { dct(fb->y1); dct(fb->y2); dct(fb->y3); dct(fb->y4); @@ -351,15 +612,63 @@ static void dodct(fblock_t*fb) fzigzag(fb->u); fzigzag(fb->v); } +static void dodctandquant(fblock_t*fb, block_t*b, int has_dc, int quant) +{ + int t; + if(has_dc) { + dodct(fb); + quantize(fb,b,has_dc,quant); + return; + } + preparequant(quant); + dct2(fb->y1,b->y1); dct2(fb->y2,b->y2); dct2(fb->y3,b->y3); dct2(fb->y4,b->y4); + dct2(fb->u,b->u); dct2(fb->v,b->v); +} -static void quantize(fblock_t*fb, block_t*b, int has_dc, int quant) +static void doidct(block_t*b) +{ + fblock_t fb; + int t; + for(t=0;t<64;t++) { + fb.y1[t] = b->y1[zigzagtable[t]]; + fb.y2[t] = b->y2[zigzagtable[t]]; + fb.y3[t] = b->y3[zigzagtable[t]]; + fb.y4[t] = b->y4[zigzagtable[t]]; + fb.u[t] = b->u[zigzagtable[t]]; + fb.v[t] = b->v[zigzagtable[t]]; + } + idct(fb.y1); idct(fb.y2); idct(fb.y3); idct(fb.y4); + idct(fb.u); idct(fb.v); + for(t=0;t<64;t++) { + b->y1[t] = fb.y1[t]; + b->y2[t] = fb.y2[t]; + b->y3[t] = fb.y3[t]; + b->y4[t] = fb.y4[t]; + b->u[t] = fb.u[t]; + b->v[t] = fb.v[t]; + } +} +static void truncateblock(block_t*b) { - quantize8x8(fb->y1,b->y1,has_dc,quant); - quantize8x8(fb->y2,b->y2,has_dc,quant); - quantize8x8(fb->y3,b->y3,has_dc,quant); - quantize8x8(fb->y4,b->y4,has_dc,quant); - quantize8x8(fb->u,b->u,has_dc,quant); - quantize8x8(fb->v,b->v,has_dc,quant); + int t; + for(t=0;t<64;t++) { + b->y1[t] = truncate256(b->y1[t]); + b->y2[t] = truncate256(b->y2[t]); + b->y3[t] = truncate256(b->y3[t]); + b->y4[t] = truncate256(b->y4[t]); + b->u[t] = truncate256(b->u[t]); + b->v[t] = truncate256(b->v[t]); + } +} + +static void dequantize(block_t*b, int has_dc, int quant) +{ + dequantize8x8(b->y1, has_dc, quant); + dequantize8x8(b->y2, has_dc, quant); + dequantize8x8(b->y3, has_dc, quant); + dequantize8x8(b->y4, has_dc, quant); + dequantize8x8(b->u, has_dc, quant); + dequantize8x8(b->v, has_dc, quant); } static void getblockpatterns(block_t*b, int*cbpybits,int*cbpcbits, int has_dc) @@ -401,31 +710,22 @@ static void change_quant(int quant, int*dquant) *dquant = 0; } -void decode_blockI(VIDEOSTREAM*s, block_t*b, int bx, int by) -{ - int x,y; - /* FIXME */ - for(x=0;x<16;x++) - for(y=0;y<16;y++) { - s->oldpic[(y+by*16)*s->width+(x+bx*16)] = s->current[(y+by*16)*s->width+(x+bx*16)]; - } -} - -void encode_blockI(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) +static void encode_blockI(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) { fblock_t fb; block_t b; int dquant=0; int cbpcbits = 0, cbpybits=0; - getregion(&fb, s->current, bx, by, s->width, s->height); - dodct(&fb); + getregion(&fb, s->current, bx*16, by*16, s->width); change_quant(*quant, &dquant); *quant+=dquant; - quantize(&fb, &b, 1, *quant); - decode_blockI(s, &b, bx, by); + dodctandquant(&fb, &b, 1, *quant); + //quantize(&fb, &b, 1, *quant); + + //decode_blockI(s, &b, bx, by); getblockpatterns(&b, &cbpybits, &cbpcbits, 1); @@ -450,9 +750,98 @@ void encode_blockI(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) /* chrominance */ encode8x8(tag, b.u, 1, cbpcbits&2); encode8x8(tag, b.v, 1, cbpcbits&1); + + /* reconstruct */ + dequantize(&b, 1, *quant); + doidct(&b); + truncateblock(&b); + copyblock(s, s->current, &b, bx, by); +} + +static void yuvdiff(fblock_t*a, fblock_t*b) +{ + int t; + for(t=0;t<64;t++) { + a->y1[t] = (a->y1[t] - b->y1[t]); + a->y2[t] = (a->y2[t] - b->y2[t]); + a->y3[t] = (a->y3[t] - b->y3[t]); + a->y4[t] = (a->y4[t] - b->y4[t]); + a->u[t] = (a->u[t] - b->u[t]); + a->v[t] = (a->v[t] - b->v[t]); + } +} + +static void predictmvd(VIDEOSTREAM*s, int bx, int by, int*px, int*py) +{ + int i1,i2; + int x1,y1,x2,y2,x3,y3; + int x4,y4,p; + if(bx) {x1=s->mvdx[by*s->bbx+bx-1]; + y1=s->mvdy[by*s->bbx+bx-1]; + } else {x1=y1=0;} + + if(by) {x2=s->mvdx[(by-1)*s->bbx+bx]; + y2=s->mvdy[(by-1)*s->bbx+bx]; + if(bxbbx-1) { + x3=s->mvdx[(by-1)*s->bbx+bx+1]; + y3=s->mvdy[(by-1)*s->bbx+bx+1]; + } else { + x3=y3=0; + } + } + else {x2=x3=x1;y2=y3=y1;} + + if((x1 <= x2 && x2 <= x3) || + (x3 <= x2 && x2 <= x1)) { + x4=x2; + } else if((x2 <= x1 && x1 <= x3) || + (x3 <= x1 && x1 <= x2)) { + x4=x1; + } else if((x1 <= x3 && x3 <= x2) || + (x2 <= x3 && x3 <= x1)) { + x4=x3; + } + + if((y1 <= y2 && y2 <= y3) || + (y3 <= y2 && y2 <= y1)) { + y4=y2; + } else if((y2 <= y1 && y1 <= y3) || + (y3 <= y1 && y1 <= y2)) { + y4=y1; + } else if((y1 <= y3 && y3 <= y2) || + (y2 <= y3 && y3 <= y1)) { + y4=y3; + } + + *px = x4; + *py = y4; + assert((x4>=-32 && x4<=31) && (y4>=-32 && y4<=31)); +} + +static inline int mvd2index(int px, int py, int x, int y, int xy) +{ + assert((x>=-32 && x<=31) && (y>=-32 && y<=31)); + assert((x&1)==0 && (y&1)==0);//for now + assert((x&2)==0 && (y&2)==0);//for now(2) + + x-=px; + y-=py; + + if(xy) + x=y; + x+=32; + + /* (x&63) */ + if(x>63) + x-=64; + if(x<0) + x+=64; + + assert(x>=0 && x<64); + return x; } -void encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) +static int encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) { fblock_t fb; block_t b; @@ -462,24 +851,187 @@ void encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) int has_dc=1; int mode = 0; int cbpcbits = 0, cbpybits=0; + int diff; + int predictmvdx; + int predictmvdy; + + block_t b_i; + int bits_i; + + fblock_t fbold_v00; + block_t b_v00; + int bits_v00 = 65535; + int x_v00=0; + int y_v00=0; + + diff = compareregions(s, bx, by); + if(diff < 20 /*TODO: should be a parameter- good values are between 32 and 48 */) { + swf_SetBits(tag, 1,1); /* cod=1, block skipped */ + /* copy the region from the last frame so that we have a complete reconstruction */ + copyregion(s, s->current, s->oldpic, bx, by); + return 1; + } - { - int diff; - diff = compareregions(s, bx, by); - if(diff < 64/*TODO: should be a parameter*/) { - swf_SetBits(tag, 1,1); /* cod=1, block skipped */ - return; - } + predictmvd(s,bx,by,&predictmvdx,&predictmvdy); + getregion(&fb, s->current, bx*16, by*16, s->width); + + { /* consider I-block */ + fblock_t fb_i; + int y,c; + memcpy(&fb_i, &fb, sizeof(fblock_t)); + dodctandquant(&fb_i, &b_i, 1, *quant); + //quantize(&fb_i, &b_i, 1, *quant); + getblockpatterns(&b_i, &y, &c, 1); + bits_i = 1; //cod + bits_i += mcbpc_inter[3*4+c].len; + bits_i += cbpy[y].len; + bits_i += coefbits8x8(b_i.y1, 1); + bits_i += coefbits8x8(b_i.y2, 1); + bits_i += coefbits8x8(b_i.y3, 1); + bits_i += coefbits8x8(b_i.y4, 1); + bits_i += coefbits8x8(b_i.u, 1); + bits_i += coefbits8x8(b_i.v, 1); } - getregion(&fb, s->current, bx, by, s->width, s->height); - dodct(&fb); + { /* consider mvd(x,y)-block */ + fblock_t fbdiff; + int y,c; + + x_v00=0; + y_v00=0; + + if(s->do_motion) { + int hx,hy; + int bestx=0,besty=0,bestbits=65536; + int startx=-8,endx=8; + int starty=-8,endy=8; + + if(!bx) startx=0; + if(!by) starty=0; + if(bx==s->bbx-1) endx=0; + if(by==s->bby-1) endy=0; + + for(hx=startx;hx<=endx;hx+=4) + for(hy=starty;hy<=endy;hy+=4) + { + block_t b; + fblock_t fbold; + int bits = 0; + memcpy(&fbdiff, &fb, sizeof(fblock_t)); + getregion(&fbold, s->oldpic, bx*16+hx/2, by*16+hy/2, s->linex); + yuvdiff(&fbdiff, &fbold); + dodctandquant(&fbdiff, &b, 0, *quant); + //quantize(&fbdiff, &b, 0, *quant); + bits += coefbits8x8(b.y1, 0); + bits += coefbits8x8(b.y2, 0); + bits += coefbits8x8(b.y3, 0); + bits += coefbits8x8(b.y4, 0); + bits += coefbits8x8(b.u, 0); + bits += coefbits8x8(b.v, 0); + if(bitsoldpic, bx*16+x_v00/2, by*16+y_v00/2, s->linex); + yuvdiff(&fbdiff, &fbold_v00); + dodctandquant(&fbdiff, &b_v00, 0, *quant); + //quantize(&fbdiff, &b_v00, 0, *quant); + getblockpatterns(&b_v00, &y, &c, 0); + + bits_v00 = 1; //cod + bits_v00 += mcbpc_inter[0*4+c].len; + bits_v00 += cbpy[y^15].len; + bits_v00 += mvd[mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 0)].len; // (0,0) + bits_v00 += mvd[mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 1)].len; + bits_v00 += coefbits8x8(b_v00.y1, 0); + bits_v00 += coefbits8x8(b_v00.y2, 0); + bits_v00 += coefbits8x8(b_v00.y3, 0); + bits_v00 += coefbits8x8(b_v00.y4, 0); + bits_v00 += coefbits8x8(b_v00.u, 0); + bits_v00 += coefbits8x8(b_v00.v, 0); + } - quantize(&fb, &b, has_dc, *quant); + if(bits_i > bits_v00) + { + /* mvd (0,0) block (mode=0) */ + int t; + mode = 0; // mvd w/o mvd24 + has_dc = 0; + memcpy(&b, &b_v00, sizeof(block_t)); + + getblockpatterns(&b, &cbpybits, &cbpcbits, has_dc); + swf_SetBits(tag,0,1); // COD + codehuffman(tag, mcbpc_inter, mode*4+cbpcbits); + codehuffman(tag, cbpy, cbpybits^15); + + /* vector */ + codehuffman(tag, mvd, mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 0)); + codehuffman(tag, mvd, mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 1)); + s->mvdx[by*s->bbx+bx] = x_v00; + s->mvdy[by*s->bbx+bx] = y_v00; + + /* luminance */ + encode8x8(tag, b.y1, has_dc, cbpybits&8); + encode8x8(tag, b.y2, has_dc, cbpybits&4); + encode8x8(tag, b.y3, has_dc, cbpybits&2); + encode8x8(tag, b.y4, has_dc, cbpybits&1); + + /* chrominance */ + encode8x8(tag, b.u, has_dc, cbpcbits&2); + encode8x8(tag, b.v, has_dc, cbpcbits&1); + + /* -- reconstruction -- */ + dequantize(&b, 0, *quant); + doidct(&b); + for(t=0;t<64;t++) { + b.y1[t] = truncate256(b.y1[t] + (int)fbold_v00.y1[t]); + b.y2[t] = truncate256(b.y2[t] + (int)fbold_v00.y2[t]); + b.y3[t] = truncate256(b.y3[t] + (int)fbold_v00.y3[t]); + b.y4[t] = truncate256(b.y4[t] + (int)fbold_v00.y4[t]); + b.u[t] = truncate256(b.u[t] + (int)fbold_v00.u[t]); + b.v[t] = truncate256(b.v[t] + (int)fbold_v00.v[t]); + } + copyblock(s, s->current, &b, bx, by); + return bits_v00; + } else { + /* i block (mode=3) */ + mode = 3; + has_dc = 1; + memcpy(&b, &b_i, sizeof(block_t)); + getblockpatterns(&b, &cbpybits, &cbpcbits, has_dc); + swf_SetBits(tag,0,1); // COD + codehuffman(tag, mcbpc_inter, mode*4+cbpcbits); + codehuffman(tag, cbpy, cbpybits); + + /* luminance */ + encode8x8(tag, b.y1, has_dc, cbpybits&8); + encode8x8(tag, b.y2, has_dc, cbpybits&4); + encode8x8(tag, b.y3, has_dc, cbpybits&2); + encode8x8(tag, b.y4, has_dc, cbpybits&1); + + /* chrominance */ + encode8x8(tag, b.u, has_dc, cbpcbits&2); + encode8x8(tag, b.v, has_dc, cbpcbits&1); + + /* -- reconstruction -- */ + dequantize(&b, 1, *quant); + doidct(&b); + truncateblock(&b); + copyblock(s, s->current, &b, bx, by); + return bits_i; + } + exit(1); +#if 0 + dodct(&fb); + quantize(&fb, &b, has_dc, *quant); getblockpatterns(&b, &cbpybits, &cbpcbits, has_dc); if(!dquant && has_mvd && !has_mvd24 && !has_dc) mode = 0; @@ -494,16 +1046,14 @@ void encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) codehuffman(tag, mcbpc_inter, mode*4+cbpcbits); codehuffman(tag, cbpy, (mode==3 || mode==4)?cbpybits:cbpybits^15); - if(!bx&&!by) { - printf("cbpcbits: %d\n", cbpcbits); - printf("cbpybits: %d\n", cbpybits); - } - if(dquant) { setQuant(tag, dquant); } if(has_mvd) { + /* 0,0 */ + codehuffman(tag, mvd, 32); + codehuffman(tag, mvd, 32); } if(has_mvd24) { } @@ -517,6 +1067,7 @@ void encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) /* chrominance */ encode8x8(tag, b.u, has_dc, cbpcbits&2); encode8x8(tag, b.v, has_dc, cbpcbits&1); +#endif } #define TYPE_IFRAME 0 @@ -554,54 +1105,270 @@ static void writeHeader(TAG*tag, int width, int height, int frame, int quant, in swf_SetBits(tag, type, 2); /* I-Frame or P-Frame */ swf_SetBits(tag, 0, 1); /* No deblock filter */ + assert(quant>0); swf_SetBits(tag, quant, 5); /* quantizer (1-31), may be updated later on*/ swf_SetBits(tag, 0, 1); /* No extra info */ } -void swf_SetVideoStreamIFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic) +int stat_qdiff(double*b1, double*b2) +{ + int x; + double diff=0; + for(x=0;x<64;x++) { + double y1 = b1[x] - b2[x]; + diff += y1*y1; + } + return (int)(diff/64); +} + +int stat_absdiff(double*b1, double*b2) +{ + int x; + double diff=0; + for(x=0;x<64;x++) { + double y1 = b1[x] - b2[x]; + diff += fabs(y1); + } + return (int)(diff/64); +} + +int stat_absfreq(double*b1, double*b2) +{ + int x; + double diff=0; + double d1[64],d2[64]; + memcpy(&d1, b1, 64*sizeof(double)); + dct(d1); + memcpy(&d2, b2, 64*sizeof(double)); + dct(d2); + for(x=0;x<64;x++) { + double y1 = d1[x] - d2[x]; + diff += fabs(y1); + } + return (int)(diff/64); +} + +int stat_qfreq(double*b1, double*b2) +{ + int x; + double diff=0; + double d1[64],d2[64]; + memcpy(&d1, b1, 64*sizeof(double)); + dct(d1); + memcpy(&d2, b2, 64*sizeof(double)); + dct(d2); + for(x=0;x<64;x++) { + double y1 = d1[x] - d2[x]; + diff += y1*y1; + } + return (int)(diff/64); +} + +int stat_nonnull(double*b1, double*b2) +{ + int x; + int diff=0; + double d1[64],d2[64]; + memcpy(&d1, b1, 64*sizeof(double)); + dct(d1); + memcpy(&d2, b2, 64*sizeof(double)); + dct(d2); + for(x=0;x<64;x++) { + int y1 = (int)((d1[x] - d2[x])/9); + if(y1) + diff++; + } + return diff; +} + +void stat_filter(FILE*fi, double*d1, double*d2) +{ + int x,y,xx,yy,b; + for(b=3;b>=0;b--) { + int d = 1<=0;b--) { + int d = 1<=0;b--) { + int d = 1<bby;by++) + for(bx=0;bxbbx;bx++) + { + for(by2=0;by2bby;by2++) + for(bx2=0;bx2current, bx*16, by*16, s->linex); + memcpy(&fbdiff, &fbnew, sizeof(fblock_t)); + getregion(&fbold, s->current, bx2*16, by2*16, s->linex); + yuvdiff(&fbdiff, &fbold); + dodctandquant(&fbdiff, &b, 0, quant); + //quantize(&fbdiff, &b, 0, quant); + + stat(fi, b.y1, fbnew.y1, fbold.y1); + stat(fi, b.y2, fbnew.y2, fbold.y2); + stat(fi, b.y3, fbnew.y3, fbold.y3); + stat(fi, b.y4, fbnew.y4, fbold.y4); + stat(fi, b.u, fbnew.u, fbold.u); + stat(fi, b.v, fbnew.v, fbold.v); + + num++; + if(num==1000) { + fclose(fi); + exit(7); + } + } + printf("%d\n", num);fflush(stdout); + } + fclose(fi); + exit(7); +} + +void swf_SetVideoStreamIFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant) +{ + int bx, by; + + if(quant<1) quant=1; + if(quant>31) quant=31; writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_IFRAME); - bbx = (s->width+15)/16; - bby = (s->height+15)/16; + rgb2yuv(s->current, pic, s->linex, s->olinex, s->width, s->height); - s->current = pic; + //dostat(s); - for(by=0;bybby;by++) { - for(bx=0;bxbbx;bx++) { encode_blockI(tag, s, bx, by, &quant); } } s->frame++; + memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV)); } -void swf_SetVideoStreamPFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic) +void swf_SetVideoStreamPFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant) { - int bx, by, bbx, bby; - int quant = 7; + int bx, by; - writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_PFRAME); + if(quant<1) quant=1; + if(quant>31) quant=31; - bbx = (s->width+15)/16; - bby = (s->height+15)/16; + writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_PFRAME); - s->current = pic; + rgb2yuv(s->current, pic, s->linex, s->olinex, s->width, s->height); + memset(s->mvdx, 0, s->bbx*s->bby*sizeof(int)); + memset(s->mvdy, 0, s->bbx*s->bby*sizeof(int)); - for(by=0;bybby;by++) { - for(bx=0;bxbbx;bx++) { encode_blockP(tag, s, bx, by, &quant); } } s->frame++; + memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV)); +#ifdef MAIN + { + int t; + FILE*fi = fopen("test.ppm", "wb"); + yuv2rgb(pic, s->current, s->linex, s->width, s->height); + fprintf(fi, "P6\n%d %d\n255\n", s->width, s->height); + for(t=0;twidth*s->height;t++) + { + fwrite(&pic[t].r, 1, 1, fi); + fwrite(&pic[t].g, 1, 1, fi); + fwrite(&pic[t].b, 1, 1, fi); + } + fclose(fi); + } +#endif } +#ifdef MAIN +#include "png.h" int main(int argn, char*argv[]) { int fi; @@ -612,7 +1379,8 @@ int main(int argn, char*argv[]) SWFPLACEOBJECT obj; int width = 0; int height = 0; - int frames = 100; + int frames = 50; + int framerate = 29; unsigned char*data; char* fname = "/home/kramm/pics/peppers.png"; VIDEOSTREAM stream; @@ -632,7 +1400,7 @@ int main(int argn, char*argv[]) memset(&obj,0,sizeof(obj)); swf.fileVersion = 6; - swf.frameRate = 29*256; + swf.frameRate = framerate*256; swf.movieSize.xmax = 20*width; swf.movieSize.ymax = 20*height; @@ -644,6 +1412,7 @@ int main(int argn, char*argv[]) tag = swf_InsertTag(tag, ST_DEFINEVIDEOSTREAM); swf_SetU16(tag, 33); swf_SetVideoStreamDefine(tag, &stream, frames, width, height); + stream.do_motion = 1; for(t=0;t