X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fh.263%2Fmkvideo.c;h=8fc554dcb8ddb491be5027c1ad76726ef4025d4b;hb=958c6ff463beca74ae616d04a21e709f4a016855;hp=fb7a1d9c7912c6610986707ec80cf17ff3c660ba;hpb=d724d55156188df62f807cc3269e141f33f66856;p=swftools.git diff --git a/lib/h.263/mkvideo.c b/lib/h.263/mkvideo.c index fb7a1d9..8fc554d 100644 --- a/lib/h.263/mkvideo.c +++ b/lib/h.263/mkvideo.c @@ -9,16 +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; - RGBA*oldpic; -} VIDEOSTREAM; +#include "swfvideo.h" void swf_SetVideoStreamDefine(TAG*tag, VIDEOSTREAM*stream, U16 frames, U16 width, U16 height) { @@ -29,9 +22,30 @@ void swf_SetVideoStreamDefine(TAG*tag, VIDEOSTREAM*stream, U16 frames, U16 width swf_SetU8(tag, 1); /* smoothing on */ swf_SetU8(tag, 2); /* codec = h.263 sorenson spark */ + memset(stream, 0, sizeof(VIDEOSTREAM)); + stream->olinex = width; + width+=15;width&=~15; + height+=15;height&=~15; + stream->linex = width; stream->width = width; stream->height = height; - stream->oldpic = 0; + 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 @@ -54,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); } @@ -143,44 +158,132 @@ static void idct(double*src) } } -static void getregion(fblock_t* bb, RGBA*pic, int bx, int by, int width, int height) +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; + } +} + +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 valtodc(int val) +static int compareregions(VIDEOSTREAM*s, int bx, int by) +{ + int linex = s->width; + 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++) { + 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/256; +} + +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) @@ -191,8 +294,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; @@ -203,26 +318,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; } } @@ -230,20 +377,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 dodct(fblock_t*fb) { + int t; dct(fb->y1); dct(fb->y2); dct(fb->y3); dct(fb->y4); dct(fb->u); dct(fb->v); fzigzag(fb->y1); @@ -325,14 +517,59 @@ static void dodct(fblock_t*fb) fzigzag(fb->v); } +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) +{ + 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 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); + 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 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) @@ -374,20 +611,22 @@ static void change_quant(int quant, int*dquant) *dquant = 0; } -void encode_blockI(TAG*tag, RGBA*pic, int bx, int by, int width, int height, 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, pic, bx, by, width, height); + getregion(&fb, s->current, bx*16, by*16, s->width); dodct(&fb); change_quant(*quant, &dquant); *quant+=dquant; - quantize(&fb, &b, 1, *quant); + + //decode_blockI(s, &b, bx, by); + getblockpatterns(&b, &cbpybits, &cbpcbits, 1); if(dquant) { @@ -411,9 +650,98 @@ void encode_blockI(TAG*tag, RGBA*pic, int bx, int by, int width, int height, int /* 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); } -void encode_blockP(TAG*tag, RGBA*pic, int bx, int by, int width, int height, int*quant) +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; +} + +static int encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant) { fblock_t fb; block_t b; @@ -423,15 +751,181 @@ void encode_blockP(TAG*tag, RGBA*pic, int bx, int by, int width, int height, int 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; + } - getregion(&fb, pic, bx, by, width, height); - dodct(&fb); + 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)); + dodct(&fb_i); + 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); + } - change_quant(*quant, &dquant); - *quant += dquant; + if(bx&&by&&(bxbbx-1)&&(bybby-1)) + { /* 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; + + for(hx=-8;hx<8;hx+=4) + for(hy=-8;hy<8;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); + dodct(&fbdiff); + 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); + dodct(&fbdiff); + 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); + } + + 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; @@ -446,16 +940,14 @@ void encode_blockP(TAG*tag, RGBA*pic, int bx, int by, int width, int height, int 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) { } @@ -469,6 +961,7 @@ void encode_blockP(TAG*tag, RGBA*pic, int bx, int by, int width, int height, int /* chrominance */ encode8x8(tag, b.u, has_dc, cbpcbits&2); encode8x8(tag, b.v, has_dc, cbpcbits&1); +#endif } #define TYPE_IFRAME 0 @@ -506,73 +999,292 @@ 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, U16 width, U16 height, int frame) +int stat_qdiff(double*b1, double*b2) { - int bx, by, bbx, bby; - int quant = 7; + int x; + double diff=0; + for(x=0;x<64;x++) { + double y1 = b1[x] - b2[x]; + diff += y1*y1; + } + return (int)(diff/64); +} - /* TODO: width not divisible by 16 will get us in trouble */ - width=width&~15; height=height&~15; +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); +} - writeHeader(tag, width, height, frame, quant, TYPE_IFRAME); +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(bx=0;bxbby;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); + dodct(&fbdiff); + 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_SetVideoStreamPFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, U16 width, U16 height, int frame) +void swf_SetVideoStreamIFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant) { - int bx, by, bbx, bby; - int quant = 7; + int bx, by; - /* TODO: width not divisible by 16 will get us in trouble */ - width=width&~15; height=height&~15; + if(quant<1) quant=1; + if(quant>31) quant=31; - writeHeader(tag, width, height, frame, quant, TYPE_PFRAME); + writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_IFRAME); - bbx = (width+15)/16; - bby = (height+15)/16; + rgb2yuv(s->current, pic, s->linex, s->olinex, s->width, s->height); - for(by=0;bybby;by++) { - for(bx=0;bxbbx;bx++) { - encode_blockP(tag, pic, bx, by, width, height, &quant); + 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, 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_PFRAME); + + 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; int t; SWF swf; TAG * tag; - RGBA* pic, rgb; + RGBA* pic, *pic2, rgb; SWFPLACEOBJECT obj; int width = 0; int height = 0; - int frames = 2; + int frames = 50; + int framerate = 29; unsigned char*data; char* fname = "/home/kramm/pics/peppers.png"; VIDEOSTREAM stream; + double d = 1.0; memset(&stream, 0, sizeof(stream)); getPNG(fname, &width, &height, &data); pic = (RGBA*)malloc(width*height*sizeof(RGBA)); + pic2 = (RGBA*)malloc(width*height*sizeof(RGBA)); memcpy(pic, data, width*height*sizeof(RGBA)); free(data); @@ -582,7 +1294,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; @@ -594,15 +1306,26 @@ 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