2 Routines for handling h.263 video tags
4 Part of the swftools package.
6 Copyright (c) 2003 Matthias Kramm <kramm@quiss.org>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
26 #include "../rfxswf.h"
27 #include "h263tables.h"
31 - use prepare* / write* in encode_IFrame_block
32 - check whether mvd steps of 2 lead to (much) smaller results
38 void swf_SetVideoStreamDefine(TAG*tag, VIDEOSTREAM*stream, U16 frames, U16 width, U16 height)
43 memset(stream, 0, sizeof(VIDEOSTREAM));
44 stream->olinex = width;
45 stream->owidth = width;
46 stream->oheight = height;
48 height+=15;height&=~15;
49 stream->linex = width;
50 stream->width = width;
51 stream->height = height;
52 stream->bbx = width/16;
53 stream->bby = height/16;
54 stream->current = (YUV*)rfx_calloc(width*height*sizeof(YUV));
55 stream->oldpic = (YUV*)rfx_calloc(width*height*sizeof(YUV));
56 stream->mvdx = (int*)rfx_alloc(stream->bbx*stream->bby*sizeof(int));
57 stream->mvdy = (int*)rfx_alloc(stream->bbx*stream->bby*sizeof(int));
58 stream->do_motion = 0;
60 assert((stream->width&15) == 0);
61 assert((stream->height&15) == 0);
62 assert((stream->bbx*16) == stream->width);
63 assert((stream->bby*16) == stream->height);
65 swf_SetU16(tag, frames);
66 swf_SetU16(tag, width);
67 swf_SetU16(tag, height);
68 //swf_SetU8(tag, 1); /* smoothing on */
69 swf_SetU8(tag, 0); /* smoothing off */
70 swf_SetU8(tag, 2); /* codec = h.263 sorenson spark */
73 void swf_VideoStreamClear(VIDEOSTREAM*stream)
75 rfx_free(stream->oldpic);stream->oldpic = 0;
76 rfx_free(stream->current);stream->current = 0;
77 rfx_free(stream->mvdx);stream->mvdx=0;
78 rfx_free(stream->mvdy);stream->mvdy=0;
81 typedef struct _block_t
91 static inline int truncate256(int a)
98 static void getregion(block_t* bb, YUV*pic, int posx, int posy, int linex)
106 p1 = &pic[posy*linex+posx];
110 bb->u[i] = (p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4;
111 bb->v[i] = (p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4;
113 bb->y2[i] = p1[x+8].y;
114 bb->y3[i] = p1[linex*8+x].y;
115 bb->y4[i] = p1[linex*8+x+8].y;
123 /* This function is pretty complex. Let's hope it works correctly */
124 static void getmvdregion(block_t* bb, YUV*pic, int posx, int posy, int mvdx, int mvdy, int linex)
132 posx = posx*16 + ((mvdx&~1)/2); //works also for negative mvdx (unlike mvdx/2)
133 posy = posy*16 + ((mvdy&~1)/2);
134 p1 = &pic[posy*linex+posx];
135 p2 = &pic[(posy&~1)*linex+(posx&~1)];
136 uvhp = ((mvdx&1)|((mvdx>>1)&1))|((mvdy&2)|((mvdy&1)<<1));
137 yhp = ((mvdy&1)<<1|(mvdx&1));
140 if(yhp==0 || yhp==2) {
143 bb->y1[yy] = p1[x].y;
144 bb->y2[yy] = p1[x+8].y;
145 bb->y3[yy] = p1[linex*8+x].y;
146 bb->y4[yy] = p1[linex*8+x+8].y;
154 bb->y1[yy] += p1[x].y; bb->y1[yy] /= 2;
155 bb->y2[yy] += p1[x+8].y; bb->y2[yy] /= 2;
156 bb->y3[yy] += p1[linex*8+x].y; bb->y3[yy] /= 2;
157 bb->y4[yy] += p1[linex*8+x+8].y; bb->y4[yy] /= 2;
162 } else if(yhp==1 || yhp==3) {
165 bb->y1[yy] = (p1[x].y + p1[x+1].y);
166 bb->y2[yy] = (p1[x+8].y + p1[x+8+1].y);
167 bb->y3[yy] = (p1[linex*8+x].y + p1[linex*8+x+1].y);
168 bb->y4[yy] = (p1[linex*8+x+8].y + p1[linex*8+x+8+1].y);
175 bb->y1[yy] += (p1[x].y + p1[x+1].y); bb->y1[yy]/=4;
176 bb->y2[yy] += (p1[x+8].y + p1[x+8+1].y); bb->y2[yy]/=4;
177 bb->y3[yy] += (p1[linex*8+x].y + p1[linex*8+x+1].y); bb->y3[yy]/=4;
178 bb->y4[yy] += (p1[linex*8+x+8].y + p1[linex*8+x+8+1].y); bb->y4[yy]/=4;
183 bb->y1[yy]/=2; bb->y2[yy]/=2; bb->y3[yy]/=2; bb->y4[yy]/=2;
191 if(uvhp==0 || uvhp==2) {
194 bb->u[uv] = (p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4;
195 bb->v[uv] = (p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4;
202 bb->u[uv] += (p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4;
203 bb->v[uv] += (p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4;
210 } else /* uvhp==1 || uvhp==3 */ {
213 bb->u[uv] = ((p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4+
214 (p2[x*2+2].u + p2[x*2+1+2].u + p2[linex+x*2+2].u + p2[linex+x*2+1+2].u)/4);
215 bb->v[uv] = ((p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4+
216 (p2[x*2+2].v + p2[x*2+1+2].v + p2[linex+x*2+2].v + p2[linex+x*2+1+2].v)/4);
223 bb->u[uv] += ((p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4+
224 (p2[x*2+2].u + p2[x*2+1+2].u + p2[linex+x*2+2].u + p2[linex+x*2+1+2].u)/4);
225 bb->v[uv] += ((p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4+
226 (p2[x*2+2].v + p2[x*2+1+2].v + p2[linex+x*2+2].v + p2[linex+x*2+1+2].v)/4);
242 static void rgb2yuv(YUV*dest, RGBA*src, int dlinex, int slinex, int width, int height)
245 for(y=0;y<height;y++) {
246 for(x=0;x<width;x++) {
248 r = src[y*slinex+x].r;
249 g = src[y*slinex+x].g;
250 b = src[y*slinex+x].b;
251 /*dest[y*dlinex+x].y = (r*0.299 + g*0.587 + b*0.114);
252 dest[y*dlinex+x].u = (r*-0.169 + g*-0.332 + b*0.500 + 128.0);
253 dest[y*dlinex+x].v = (r*0.500 + g*-0.419 + b*-0.0813 + 128.0);*/
255 //dest[y*dlinex+x].y = 128;//(r*((int)( 0.299*256)) + g*((int)( 0.587*256)) + b*((int)( 0.114 *256)))>>8;
257 dest[y*dlinex+x].y = (r*((int)( 0.299*256)) + g*((int)( 0.587*256)) + b*((int)( 0.114 *256)))>>8;
258 dest[y*dlinex+x].u = (r*((int)(-0.169*256)) + g*((int)(-0.332*256)) + b*((int)( 0.500 *256))+ 128*256)>>8;
259 dest[y*dlinex+x].v = (r*((int)( 0.500*256)) + g*((int)(-0.419*256)) + b*((int)(-0.0813*256))+ 128*256)>>8;
264 static void copyregion(VIDEOSTREAM*s, YUV*dest, YUV*src, int bx, int by)
266 YUV*p1 = &dest[by*s->linex*16+bx*16];
267 YUV*p2 = &src[by*s->linex*16+bx*16];
270 memcpy(p1, p2, 16*sizeof(YUV));
271 p1+=s->linex;p2+=s->linex;
275 static void yuv2rgb(RGBA*dest, YUV*src, int linex, int width, int height)
278 for(y=0;y<height;y++) {
279 for(x=0;x<width;x++) {
281 u = src[y*linex+x].u;
282 v = src[y*linex+x].v;
283 yy = src[y*linex+x].y;
284 dest[y*linex+x].r = truncate256(yy + ((360*(v-128))>>8));
285 dest[y*linex+x].g = truncate256(yy - ((88*(u-128)+183*(v-128))>>8));
286 dest[y*linex+x].b = truncate256(yy + ((455 * (u-128))>>8));
290 static void copy_block_pic(VIDEOSTREAM*s, YUV*dest, block_t*b, int bx, int by)
292 YUV*p1 = &dest[(by*16)*s->linex+bx*16];
293 YUV*p2 = &dest[(by*16+8)*s->linex+bx*16];
298 p1[x+0].u = b->u[(y/2)*8+(x/2)];
299 p1[x+0].v = b->v[(y/2)*8+(x/2)];
300 p1[x+0].y = b->y1[y*8+x];
301 p1[x+8].u = b->u[(y/2)*8+(x/2)+4];
302 p1[x+8].v = b->v[(y/2)*8+(x/2)+4];
303 p1[x+8].y = b->y2[y*8+x];
304 p2[x+0].u = b->u[(y/2+4)*8+(x/2)];
305 p2[x+0].v = b->v[(y/2+4)*8+(x/2)];
306 p2[x+0].y = b->y3[y*8+x];
307 p2[x+8].u = b->u[(y/2+4)*8+(x/2)+4];
308 p2[x+8].v = b->v[(y/2+4)*8+(x/2)+4];
309 p2[x+8].y = b->y4[y*8+x];
316 static int compare_pic_pic(VIDEOSTREAM*s, YUV*pp1, YUV*pp2, int bx, int by)
318 int linex = s->width;
319 YUV*p1 = &pp1[by*linex*16+bx*16];
320 YUV*p2 = &pp2[by*linex*16+bx*16];
321 int diffy=0, diffuv = 0;
331 diffuv += abs(u)+abs(v);
336 return diffy + diffuv/4;
339 static int compare_pic_block(VIDEOSTREAM*s, block_t* b, YUV*pic, int bx, int by)
341 int linex = s->width;
342 YUV*y1 = &pic[(by*2)*linex*8+bx*16];
343 YUV*y2 = &pic[(by*2)*linex*8+bx*16+8];
344 YUV*y3 = &pic[(by*2+1)*linex*8+bx*16];
345 YUV*y4 = &pic[(by*2+1)*linex*8+bx*16+8];
347 YUV*uv2 = &y1[linex];
348 int diffy=0, diffuv = 0;
352 int yy,u1,v1,u2,v2,u3,v3,u4,v4;
354 yy = y1[x].y - b->y1[y8x];
356 yy = y2[x].y - b->y2[y8x];
358 yy = y3[x].y - b->y3[y8x];
360 yy = y4[x].y - b->y4[y8x];
362 u1 = uv1[x*2].u - b->u[y8x];
363 v1 = uv1[x*2].v - b->v[y8x];
364 u2 = uv1[x*2+1].u - b->u[y8x];
365 v2 = uv1[x*2+1].v - b->v[y8x];
366 u3 = uv2[x*2].u - b->u[y8x];
367 v3 = uv2[x*2].v - b->v[y8x];
368 u4 = uv2[x*2+1].u - b->u[y8x];
369 v4 = uv2[x*2+1].v - b->v[y8x];
370 diffuv += (abs(u1)+abs(v1));
371 diffuv += (abs(u2)+abs(v2));
372 diffuv += (abs(u3)+abs(v3));
373 diffuv += (abs(u4)+abs(v4));
382 return diffy + diffuv/4;
385 static inline int valtodc(int val)
393 /* TODO: what to do for zero values? skip the block? */
402 static int dctoval(int dc)
415 /* TODO: we could also just let the caller pass only the string table[index] here */
416 static int codehuffman(TAG*tag, struct huffcode*table, int index)
418 /* TODO: !optimize! */
420 while(table[index].code[i]) {
421 if(table[index].code[i]=='0')
422 swf_SetBits(tag, 0, 1);
424 swf_SetBits(tag, 1, 1);
430 static void quantize8x8(int*src, int*dest, int has_dc, int quant)
433 double q = 1.0/(quant*2);
435 dest[0] = valtodc((int)src[0]); /*DC*/
440 //dest[t] = (int)src[t];
441 /* exact: if(quant&1){dest[t] = (dest[t]/quant - 1)/2;}else{dest[t] = ((dest[t]+1)/quant - 1)/2;} */
442 //if(quant&1){dest[t] = (dest[t]/quant - 1)/2;}else{dest[t] = ((dest[t]+1)/quant - 1)/2;}
443 //dest[t] = dest[t]/(quant*2);
444 dest[t] = (int)(src[t]*q);
445 /* TODO: warn if this happens- the video will be buggy */
446 if(dest[t]>127) dest[t]=127;
447 if(dest[t]<-127) dest[t]=-127;
451 static void dequantize8x8(int*b, int has_dc, int quant)
455 b[0] = dctoval(b[0]); //DC
458 for(t=pos;t<64;t++) {
467 b[t] = quant*(2*b[t]+1); //-7,8,24,40
469 b[t] = quant*(2*b[t]+1)-1; //-8,7,23,39
476 /* paragraph 6.2.2, "clipping of reconstruction levels": */
477 if(b[t]>2047) b[t]=2047;
478 if(b[t]<-2048) b[t]=-2048;
482 static int hascoef(int*b, int has_dc)
488 for(t=pos;t<64;t++) {
495 static int coefbits8x8(int*bb, int has_dc)
506 for(last=63;last>=pos;last--) {
513 int run=0, level=0, islast=0,t;
514 while(!bb[pos] && pos<last) {
521 if(level<0) level=-level;
523 for(t=0;t<RLE_ESCAPE;t++) {
524 if(rle_params[t].run == run &&
525 rle_params[t].level == level &&
526 rle_params[t].last == islast) {
527 bits += rle[t].len + 1;
532 bits += rle[RLE_ESCAPE].len + 1 + 6 + 8;
541 static int encode8x8(TAG*tag, int*bb, int has_dc, int has_tcoef)
548 swf_SetBits(tag, bb[0], 8);
555 /* determine last non-null coefficient */
556 for(last=63;last>=pos;last--) {
557 /* TODO: we could leave out small coefficients
558 after a certain point (32?) */
562 /* blocks without coefficients should not be included
563 in the cbpy/cbpc patterns: */
572 while(!bb[pos] && pos<last) {
584 for(t=0;t<RLE_ESCAPE;t++) {
585 /* TODO: lookup table */
586 if(rle_params[t].run == run &&
587 rle_params[t].level == level &&
588 rle_params[t].last == islast) {
589 bits += codehuffman(tag, rle, t);
590 swf_SetBits(tag, sign, 1);
596 bits += codehuffman(tag, rle, RLE_ESCAPE);
599 if(!level || level<-127 || level>127) {
600 fprintf(stderr, "Warning: Overflow- Level %d at pos %d\n", level, pos);
601 if(level<-127) level=-127;
602 if(level>127) level=127;
607 assert(level<=127); //TODO: known to fail for pos=0 (with custom frames?)
609 swf_SetBits(tag, islast, 1);
610 swf_SetBits(tag, run, 6);
611 swf_SetBits(tag, level, 8); //FIXME: fixme??
623 static void quantize(block_t*fb, block_t*b, int has_dc, int quant)
625 quantize8x8(fb->y1, b->y1, has_dc, quant);
626 quantize8x8(fb->y2, b->y2, has_dc, quant);
627 quantize8x8(fb->y3, b->y3, has_dc, quant);
628 quantize8x8(fb->y4, b->y4, has_dc, quant);
629 quantize8x8(fb->u, b->u, has_dc, quant);
630 quantize8x8(fb->v, b->v, has_dc, quant);
633 static void dodct(block_t*fb)
635 dct(fb->y1); dct(fb->y2); dct(fb->y3); dct(fb->y4);
636 dct(fb->u); dct(fb->v);
645 static void dodctandquant(block_t*fb, block_t*b, int has_dc, int quant)
650 quantize(fb,b,has_dc,quant);
654 dct2(fb->y1,b->y1); dct2(fb->y2,b->y2); dct2(fb->y3,b->y3); dct2(fb->y4,b->y4);
655 dct2(fb->u,b->u); dct2(fb->v,b->v);
658 /* prepare for encoding (only values in (-127..-1,1..127) are
659 allowed as non-zero, non-dc values */
660 if(b->y1[t]<-127) b->y1[t]=-127;
661 if(b->y2[t]<-127) b->y2[t]=-127;
662 if(b->y3[t]<-127) b->y3[t]=-127;
663 if(b->y4[t]<-127) b->y4[t]=-127;
664 if(b->u[t]<-127) b->u[t]=-127;
665 if(b->v[t]<-127) b->v[t]=-127;
667 if(b->y1[t]>127) b->y1[t]=127;
668 if(b->y2[t]>127) b->y2[t]=127;
669 if(b->y3[t]>127) b->y3[t]=127;
670 if(b->y4[t]>127) b->y4[t]=127;
671 if(b->u[t]>127) b->u[t]=127;
672 if(b->v[t]>127) b->v[t]=127;
676 static void doidct(block_t*b)
681 fb.y1[t] = b->y1[zigzagtable[t]];
682 fb.y2[t] = b->y2[zigzagtable[t]];
683 fb.y3[t] = b->y3[zigzagtable[t]];
684 fb.y4[t] = b->y4[zigzagtable[t]];
685 fb.u[t] = b->u[zigzagtable[t]];
686 fb.v[t] = b->v[zigzagtable[t]];
688 idct(fb.y1); idct(fb.y2); idct(fb.y3); idct(fb.y4);
689 idct(fb.u); idct(fb.v);
691 memcpy(b, &fb, sizeof(block_t));
694 static void truncateblock(block_t*b)
698 b->y1[t] = truncate256(b->y1[t]);
699 b->y2[t] = truncate256(b->y2[t]);
700 b->y3[t] = truncate256(b->y3[t]);
701 b->y4[t] = truncate256(b->y4[t]);
702 b->u[t] = truncate256(b->u[t]);
703 b->v[t] = truncate256(b->v[t]);
707 static void dequantize(block_t*b, int has_dc, int quant)
709 dequantize8x8(b->y1, has_dc, quant);
710 dequantize8x8(b->y2, has_dc, quant);
711 dequantize8x8(b->y3, has_dc, quant);
712 dequantize8x8(b->y4, has_dc, quant);
713 dequantize8x8(b->u, has_dc, quant);
714 dequantize8x8(b->v, has_dc, quant);
717 static void getblockpatterns(block_t*b, int*cbpybits,int*cbpcbits, int has_dc)
722 *cbpybits|=hascoef(b->y1, has_dc)*8;
723 *cbpybits|=hascoef(b->y2, has_dc)*4;
724 *cbpybits|=hascoef(b->y3, has_dc)*2;
725 *cbpybits|=hascoef(b->y4, has_dc)*1;
727 *cbpcbits|=hascoef(b->u, has_dc)*2;
728 *cbpcbits|=hascoef(b->v, has_dc)*1;
731 static void setQuant(TAG*tag, int dquant)
738 swf_SetBits(tag, 0x0, 2);
739 } else if(dquant == -2) {
740 swf_SetBits(tag, 0x1, 2);
741 } else if(dquant == +1) {
742 swf_SetBits(tag, 0x2, 2);
743 } else if(dquant == +2) {
744 swf_SetBits(tag, 0x3, 2);
746 assert(0*strlen("invalid dquant"));
750 static void change_quant(int quant, int*dquant)
756 static void yuvdiff(block_t*a, block_t*b)
760 a->y1[t] = (a->y1[t] - b->y1[t]);
761 a->y2[t] = (a->y2[t] - b->y2[t]);
762 a->y3[t] = (a->y3[t] - b->y3[t]);
763 a->y4[t] = (a->y4[t] - b->y4[t]);
764 a->u[t] = (a->u[t] - b->u[t]);
765 a->v[t] = (a->v[t] - b->v[t]);
769 static void predictmvd(VIDEOSTREAM*s, int bx, int by, int*px, int*py)
772 int x1,y1,x2,y2,x3,y3;
774 if(bx) {x1=s->mvdx[by*s->bbx+bx-1];
775 y1=s->mvdy[by*s->bbx+bx-1];
778 if(by) {x2=s->mvdx[(by-1)*s->bbx+bx];
779 y2=s->mvdy[(by-1)*s->bbx+bx];
781 x3=s->mvdx[(by-1)*s->bbx+bx+1];
782 y3=s->mvdy[(by-1)*s->bbx+bx+1];
787 else {x2=x3=x1;y2=y3=y1;}
789 if((x1 <= x2 && x2 <= x3) ||
790 (x3 <= x2 && x2 <= x1)) {
792 } else if((x2 <= x1 && x1 <= x3) ||
793 (x3 <= x1 && x1 <= x2)) {
795 } else if((x1 <= x3 && x3 <= x2) ||
796 (x2 <= x3 && x3 <= x1)) {
803 if((y1 <= y2 && y2 <= y3) ||
804 (y3 <= y2 && y2 <= y1)) {
806 } else if((y2 <= y1 && y1 <= y3) ||
807 (y3 <= y1 && y1 <= y2)) {
809 } else if((y1 <= y3 && y3 <= y2) ||
810 (y2 <= y3 && y3 <= y1)) {
819 assert((x4>=-32 && x4<=31) && (y4>=-32 && y4<=31));
822 static inline int mvd2index(int px, int py, int x, int y, int xy)
825 if((x<-32 && x>31) || (y<-32 && y>31))
826 fprintf(stderr, "(%d,%d)\n", x,y);
827 assert((x>=-32 && x<=31) && (y>=-32 && y<=31));
828 //assert((x&1)==0 && (y&1)==0);//for now
829 //assert((x&2)==0 && (y&2)==0);//for now(2)
844 assert(x>=0 && x<64);
848 typedef struct _iblockdata_t
850 block_t b; //transformed quantized coefficients
851 block_t reconstruction;
854 struct huffcode*ctable; //table to use for chrominance encoding (different for i-frames)
855 int iframe; // 1 if this is part of an iframe
858 typedef struct _mvdblockdata_t
862 block_t reconstruction;
871 void prepareIBlock(VIDEOSTREAM*s, iblockdata_t*data, int bx, int by, block_t* fb, int*bits, int iframe)
873 /* consider I-block */
877 struct huffcode*ctable;
882 data->iframe = iframe;
884 data->ctable = &mcbpc_inter[3*4];
886 data->ctable = &mcbpc_intra[0];
889 memcpy(&fb_i, fb, sizeof(block_t));
890 dodctandquant(&fb_i, &data->b, 1, s->quant);
891 getblockpatterns(&data->b, &y, &c, 1);
896 *bits += data->ctable[c].len;
897 *bits += cbpy[y].len;
898 *bits += coefbits8x8(data->b.y1, 1);
899 *bits += coefbits8x8(data->b.y2, 1);
900 *bits += coefbits8x8(data->b.y3, 1);
901 *bits += coefbits8x8(data->b.y4, 1);
902 *bits += coefbits8x8(data->b.u, 1);
903 *bits += coefbits8x8(data->b.v, 1);
906 /* -- reconstruction -- */
907 memcpy(&data->reconstruction,&data->b,sizeof(block_t));
908 dequantize(&data->reconstruction, 1, s->quant);
909 doidct(&data->reconstruction);
910 truncateblock(&data->reconstruction);
913 int writeIBlock(VIDEOSTREAM*s, TAG*tag, iblockdata_t*data)
920 getblockpatterns(&data->b, &y, &c, has_dc);
922 swf_SetBits(tag,0,1); bits += 1; // COD
924 bits += codehuffman(tag, data->ctable, c);
925 bits += codehuffman(tag, cbpy, y);
928 bits += encode8x8(tag, data->b.y1, has_dc, y&8);
929 bits += encode8x8(tag, data->b.y2, has_dc, y&4);
930 bits += encode8x8(tag, data->b.y3, has_dc, y&2);
931 bits += encode8x8(tag, data->b.y4, has_dc, y&1);
934 bits += encode8x8(tag, data->b.u, has_dc, c&2);
935 bits += encode8x8(tag, data->b.v, has_dc, c&1);
937 copy_block_pic(s, s->current, &data->reconstruction, data->bx, data->by);
938 assert(data->bits == bits);
942 int getmvdbits(VIDEOSTREAM*s,block_t*fb, int bx,int by,int hx,int hy)
948 memcpy(&fbdiff, fb, sizeof(block_t));
949 getmvdregion(&fbold, s->oldpic, bx, by, hx, hy, s->linex);
950 yuvdiff(&fbdiff, &fbold);
951 dodctandquant(&fbdiff, &b, 0, s->quant);
952 bits += coefbits8x8(b.y1, 0);
953 bits += coefbits8x8(b.y2, 0);
954 bits += coefbits8x8(b.y3, 0);
955 bits += coefbits8x8(b.y4, 0);
956 bits += coefbits8x8(b.u, 0);
957 bits += coefbits8x8(b.v, 0);
961 void prepareMVDBlock(VIDEOSTREAM*s, mvdblockdata_t*data, int bx, int by, block_t* fb, int*bits)
962 { /* consider mvd(x,y)-block */
972 predictmvd(s,bx,by,&predictmvdx,&predictmvdy);
980 int bestx=0,besty=0,bestbits=65536;
981 int startx=-32,endx=31;
982 int starty=-32,endy=31;
986 if(bx==s->bbx-1) endx=0;
987 if(by==s->bby-1) endy=0;
989 for(hx=startx;hx<=endx;hx+=4)
990 for(hy=starty;hy<=endy;hy+=4)
993 bits = getmvdbits(s,fb,bx,by,hx,hy);
1001 if(bestx-3 > startx) startx = bestx-3;
1002 if(besty-3 > starty) starty = besty-3;
1003 if(bestx+3 < endx) endx = bestx+3;
1004 if(besty+3 < endy) endy = besty+3;
1006 for(hx=startx;hx<=endx;hx++)
1007 for(hy=starty;hy<=endy;hy++)
1010 bits = getmvdbits(s,fb,bx,by,hx,hy);
1017 data->movex = bestx;
1018 data->movey = besty;
1021 memcpy(&fbdiff, fb, sizeof(block_t));
1022 getmvdregion(&data->fbold, s->oldpic, bx, by, data->movex, data->movey, s->linex);
1023 yuvdiff(&fbdiff, &data->fbold);
1024 dodctandquant(&fbdiff, &data->b, 0, s->quant);
1025 getblockpatterns(&data->b, &y, &c, 0);
1027 data->xindex = mvd2index(predictmvdx, predictmvdy, data->movex, data->movey, 0);
1028 data->yindex = mvd2index(predictmvdx, predictmvdy, data->movex, data->movey, 1);
1031 *bits += mcbpc_inter[0*4+c].len;
1032 *bits += cbpy[y^15].len;
1033 *bits += mvd[data->xindex].len; // (0,0)
1034 *bits += mvd[data->yindex].len;
1035 *bits += coefbits8x8(data->b.y1, 0);
1036 *bits += coefbits8x8(data->b.y2, 0);
1037 *bits += coefbits8x8(data->b.y3, 0);
1038 *bits += coefbits8x8(data->b.y4, 0);
1039 *bits += coefbits8x8(data->b.u, 0);
1040 *bits += coefbits8x8(data->b.v, 0);
1043 /* -- reconstruction -- */
1044 memcpy(&data->reconstruction, &data->b, sizeof(block_t));
1045 dequantize(&data->reconstruction, 0, s->quant);
1046 doidct(&data->reconstruction);
1048 data->reconstruction.y1[t] =
1049 truncate256(data->reconstruction.y1[t] + (int)data->fbold.y1[t]);
1050 data->reconstruction.y2[t] =
1051 truncate256(data->reconstruction.y2[t] + (int)data->fbold.y2[t]);
1052 data->reconstruction.y3[t] =
1053 truncate256(data->reconstruction.y3[t] + (int)data->fbold.y3[t]);
1054 data->reconstruction.y4[t] =
1055 truncate256(data->reconstruction.y4[t] + (int)data->fbold.y4[t]);
1056 data->reconstruction.u[t] =
1057 truncate256(data->reconstruction.u[t] + (int)data->fbold.u[t]);
1058 data->reconstruction.v[t] =
1059 truncate256(data->reconstruction.v[t] + (int)data->fbold.v[t]);
1063 int writeMVDBlock(VIDEOSTREAM*s, TAG*tag, mvdblockdata_t*data)
1067 int has_dc=0; // mvd w/o mvd24
1068 /* mvd (0,0) block (mode=0) */
1074 getblockpatterns(&data->b, &y, &c, has_dc);
1075 swf_SetBits(tag,0,1); bits += 1; // COD
1076 bits += codehuffman(tag, mcbpc_inter, mode*4+c);
1077 bits += codehuffman(tag, cbpy, y^15);
1080 bits += codehuffman(tag, mvd, data->xindex);
1081 bits += codehuffman(tag, mvd, data->yindex);
1084 bits += encode8x8(tag, data->b.y1, has_dc, y&8);
1085 bits += encode8x8(tag, data->b.y2, has_dc, y&4);
1086 bits += encode8x8(tag, data->b.y3, has_dc, y&2);
1087 bits += encode8x8(tag, data->b.y4, has_dc, y&1);
1090 bits += encode8x8(tag, data->b.u, has_dc, c&2);
1091 bits += encode8x8(tag, data->b.v, has_dc, c&1);
1093 s->mvdx[by*s->bbx+bx] = data->movex;
1094 s->mvdy[by*s->bbx+bx] = data->movey;
1096 copy_block_pic(s, s->current, &data->reconstruction, data->bx, data->by);
1097 assert(data->bits == bits);
1101 static int encode_PFrame_block(TAG*tag, VIDEOSTREAM*s, int bx, int by)
1108 iblockdata_t iblock;
1109 mvdblockdata_t mvdblock;
1111 getregion(&fb, s->current, bx, by, s->linex);
1112 prepareIBlock(s, &iblock, bx, by, &fb, &bits_i, 0);
1114 /* encoded last frame <=> original current block: */
1115 diff1 = compare_pic_pic(s, s->current, s->oldpic, bx, by);
1116 /* encoded current frame <=> original current block: */
1117 diff2 = compare_pic_block(s, &iblock.reconstruction, s->current, bx, by);
1119 if(diff1 <= diff2) {
1120 swf_SetBits(tag, 1,1); /* cod=1, block skipped */
1121 /* copy the region from the last frame so that we have a complete reconstruction */
1122 copyregion(s, s->current, s->oldpic, bx, by);
1125 prepareMVDBlock(s, &mvdblock, bx, by, &fb, &bits_vxy);
1127 if(bits_i > bits_vxy) {
1128 return writeMVDBlock(s, tag, &mvdblock);
1130 return writeIBlock(s, tag, &iblock);
1134 /* should be called encode_IFrameBlock */
1135 static void encode_IFrame_block(TAG*tag, VIDEOSTREAM*s, int bx, int by)
1141 getregion(&fb, s->current, bx, by, s->width);
1142 prepareIBlock(s, &data, bx, by, &fb, &bits, 1);
1143 writeIBlock(s, tag, &data);
1147 static int bmid = 0;
1149 void setdbgpic(TAG*tag, RGBA*pic, int width, int height)
1154 tag = swf_InsertTag(tag,ST_REMOVEOBJECT2);
1155 swf_SetU16(tag, 133);
1157 tag = swf_InsertTag(tag, ST_DEFINEBITSLOSSLESS);
1158 swf_SetU16(tag, 1000+bmid);
1159 swf_SetLosslessBits(tag, width, height, (void*)pic, BMF_32BIT);
1161 tag = swf_InsertTag(tag, ST_DEFINESHAPE);
1162 swf_SetU16(tag, 2000+bmid);
1163 swf_ShapeSetBitmapRect(tag, 1000+bmid, width, height);
1165 tag = swf_InsertTag(tag,ST_PLACEOBJECT2);
1166 swf_GetMatrix(0,&m);
1168 swf_ObjectPlace(tag, 2000+bmid, 133, &m, 0, 0);
1174 #define TYPE_IFRAME 0
1175 #define TYPE_PFRAME 1
1177 static void writeHeader(TAG*tag, int width, int height, int frame, int quant, int type)
1180 swf_SetU16(tag, frame);
1181 swf_SetBits(tag, 1, 17); /* picture start code*/
1182 swf_SetBits(tag, 0, 5); /* version=0, version 1 would optimize rle behaviour*/
1183 swf_SetBits(tag, frame, 8); /* time reference */
1185 /* write dimensions, taking advantage of some predefined sizes
1186 if the opportunity presents itself */
1187 i32 = width<<16|height;
1190 case 352<<16|288: swf_SetBits(tag, 2, 3);break;
1191 case 176<<16|144: swf_SetBits(tag, 3, 3);break;
1192 case 128<<16|96: swf_SetBits(tag, 4, 3);break;
1193 case 320<<16|240: swf_SetBits(tag, 5, 3);break;
1194 case 160<<16|120: swf_SetBits(tag, 6, 3);break;
1196 if(width>255 || height>255) {
1197 swf_SetBits(tag, 1, 3);
1198 swf_SetBits(tag, width, 16);
1199 swf_SetBits(tag, height, 16);
1201 swf_SetBits(tag, 0, 3);
1202 swf_SetBits(tag, width, 8);
1203 swf_SetBits(tag, height, 8);
1207 swf_SetBits(tag, type, 2); /* I-Frame or P-Frame */
1208 swf_SetBits(tag, 0, 1); /* No deblock filter */
1211 swf_SetBits(tag, quant, 5); /* quantizer (1-31), may be updated later on*/
1212 swf_SetBits(tag, 0, 1); /* No extra info */
1215 void swf_SetVideoStreamIFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant)
1219 if(quant<1) quant=1;
1220 if(quant>31) quant=31;
1223 writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_IFRAME);
1225 /* fixme: should fill with 0,128,128, not 0,0,0 */
1226 memset(s->current, 0, s->linex*s->height*sizeof(YUV));
1228 rgb2yuv(s->current, pic, s->linex, s->olinex, s->owidth, s->oheight);
1230 for(by=0;by<s->bby;by++)
1232 for(bx=0;bx<s->bbx;bx++)
1234 encode_IFrame_block(tag, s, bx, by);
1238 memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV));
1240 void swf_SetVideoStreamBlackFrame(TAG*tag, VIDEOSTREAM*s)
1247 writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_IFRAME);
1249 for(y=0;y<s->height;y++)
1250 for(x=0;x<s->width;x++) {
1251 s->current[y*s->width+x].y = 0;
1252 s->current[y*s->width+x].u = 128;
1253 s->current[y*s->width+x].v = 128;
1257 s->current[y*s->width+x].y = 64;
1258 s->current[y*s->width+x].u = 128;
1259 s->current[y*s->width+x].v = 128;
1262 for(by=0;by<s->bby;by++)
1264 for(bx=0;bx<s->bbx;bx++)
1266 encode_IFrame_block(tag, s, bx, by);
1270 memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV));
1273 void swf_SetVideoStreamPFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant)
1277 if(quant<1) quant=1;
1278 if(quant>31) quant=31;
1281 writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_PFRAME);
1283 /* fixme: should fill with 0,128,128, not 0,0,0 */
1284 memset(s->current, 0, s->linex*s->height*sizeof(YUV));
1286 rgb2yuv(s->current, pic, s->linex, s->olinex, s->owidth, s->oheight);
1287 memset(s->mvdx, 0, s->bbx*s->bby*sizeof(int));
1288 memset(s->mvdy, 0, s->bbx*s->bby*sizeof(int));
1290 for(by=0;by<s->bby;by++)
1292 for(bx=0;bx<s->bbx;bx++)
1294 encode_PFrame_block(tag, s, bx, by);
1298 memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV));
1302 yuv2rgb(pic, s->current, s->linex, s->width, s->height);
1303 setdbgpic(tag, pic, s->width, s->height);
1308 void swf_SetVideoStreamMover(TAG*tag, VIDEOSTREAM*s, signed char* movex, signed char* movey, void**pictures, int quant)
1313 if(quant<1) quant=1;
1314 if(quant>31) quant=31;
1317 writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_PFRAME);
1319 memset(s->mvdx, 0, s->bbx*s->bby*sizeof(int));
1320 memset(s->mvdy, 0, s->bbx*s->bby*sizeof(int));
1322 for(by=0;by<s->bby;by++)
1324 for(bx=0;bx<s->bbx;bx++)
1326 int predictmvdx=0, predictmvdy=0;
1327 int mvx=movex[by*s->bbx+bx];
1328 int mvy=movey[by*s->bbx+bx];
1329 void*picture = pictures?pictures[by*s->bbx+bx]:0;
1331 if(mvx<-32) mvx=-32;
1333 if(mvy<-32) mvy=-32;
1336 if(mvx == 0 && mvy == 0 && picture == 0) {
1337 swf_SetBits(tag,1,1); // COD skip
1345 swf_SetBits(tag,0,1); // COD
1347 if(mvx==0 && mvy==0 && picture) { // only picture
1353 RGBA* picblock = (RGBA*)picture;
1354 rgb2yuv(pic, picblock,16,16,16,16);
1355 /* TODO: if has_dc!=1, subtract 128 from rgb values */
1356 getregion(&b, pic, 0,0,16);
1357 dodctandquant(&b, &b2, 1, s->quant);
1358 getblockpatterns(&b2, &y, &c, 1);
1363 codehuffman(tag, mcbpc_inter, mode*4+c);
1364 codehuffman(tag, cbpy, mode==3?y:y^15);
1367 /* has motion vector */
1368 predictmvd(s,bx,by,&predictmvdx,&predictmvdy);
1369 codehuffman(tag, mvd, mvd2index(predictmvdx, predictmvdy, mvx, mvy, 0));
1370 codehuffman(tag, mvd, mvd2index(predictmvdx, predictmvdy, mvx, mvy, 1));
1371 s->mvdx[by*s->bbx+bx] = mvx;
1372 s->mvdy[by*s->bbx+bx] = mvy;
1376 encode8x8(tag, b2.y1, has_dc, y&8);
1377 encode8x8(tag, b2.y2, has_dc, y&4);
1378 encode8x8(tag, b2.y3, has_dc, y&2);
1379 encode8x8(tag, b2.y4, has_dc, y&1);
1380 encode8x8(tag, b2.u, has_dc, c&2);
1381 encode8x8(tag, b2.v, has_dc, c&1);
1391 void test_copy_diff()
1394 VIDEOSTREAM* s = &stream;
1396 RGBA*pic = (RGBA*)rfx_alloc(256*256*sizeof(RGBA));
1401 for(y=0;y<256;y++) {
1402 pic[y*256+x].r = x*y;
1403 pic[y*256+x].g = x+y;
1404 pic[y*256+x].b = (x+1)%(y+1);
1406 tag = swf_InsertTag(0, ST_DEFINEVIDEOSTREAM);
1407 swf_SetU16(tag, 33);
1408 swf_SetVideoStreamDefine(tag, s, 10, 256, 256);
1410 rgb2yuv(s->current, pic, s->linex, s->olinex, s->owidth, s->oheight);
1411 for(by=0;by<16;by++)
1412 for(bx=0;bx<16;bx++) {
1414 /* test1: does compare pic pic return zero for identical blocks? */
1415 diff1 = compare_pic_pic(s, s->current, s->current, bx, by);
1417 /* test2: do blocks which are copied back return zero diff? */
1418 getregion(&fb, s->current, bx, by, s->linex);
1419 copy_block_pic(s, s->oldpic, &fb, bx, by);
1420 diff1 = compare_pic_block(s, &fb, s->oldpic, bx, by);
1422 /* test3: does compare_pic_block return the same result as compare_pic_pic? */
1423 getregion(&fb, s->current, 15-bx, 15-by, s->linex);
1424 copy_block_pic(s, s->oldpic, &fb, bx, by);
1425 diff1 = compare_pic_block(s, &fb, s->current, bx, by);
1426 diff2 = compare_pic_pic(s, s->current, s->oldpic, bx, by);
1427 assert(diff1 == diff2);
1436 int compileSWFActionCode(const char *script, int version, void**data, int*len) {return 0;}
1451 pic = rfx_calloc(width*height*4);
1453 memset(&swf,0,sizeof(SWF));
1454 memset(&obj,0,sizeof(obj));
1456 swf.fileVersion = 6;
1457 swf.frameRate = 15*256;
1458 swf.movieSize.xmax = 20*width;
1459 swf.movieSize.ymax = 20*height;
1461 swf.firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
1463 rgb.r = 0x00;rgb.g = 0x30;rgb.b = 0xff;
1464 swf_SetRGB(tag,&rgb);
1466 tag = swf_InsertTag(tag, ST_DEFINEVIDEOSTREAM);
1468 swf_SetVideoStreamDefine(tag, &stream, frames, width, height);
1469 stream.do_motion = 0;
1471 for(y=0;y<height;y++) {
1472 for(x=0;x<width;x++) {
1476 pic[y*width+x].r = 0;
1477 pic[y*width+x].g = 0;
1478 pic[y*width+x].b = 0;
1479 pic[y*width+x].a = 0;
1482 tag = swf_InsertTag(tag, ST_VIDEOFRAME);
1485 swf_SetVideoStreamIFrame(tag, &stream, pic, 7);
1487 tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
1488 swf_GetPlaceObject(0, &obj);
1493 swf_SetPlaceObject(tag,&obj);
1495 tag = swf_InsertTag(tag, ST_SHOWFRAME);
1497 swf_VideoStreamClear(&stream);
1499 tag = swf_InsertTag(tag, ST_END);
1501 int fi = open("black.swf", O_WRONLY|O_CREAT|O_TRUNC, 0644);
1502 if(swf_WriteSWF(fi,&swf)<0) {
1503 fprintf(stderr,"WriteSWF() failed.\n");
1509 int main(int argn, char*argv[])
1515 RGBA* pic, *pic2, rgb;
1522 char* fname = "/home/kramm/pics/peppers_fromjpg.png";
1523 //char* fname = "/home/kramm/pics/baboon.png";
1533 memset(&stream, 0, sizeof(stream));
1535 getPNG(fname, &width, &height, &data);
1536 pic = (RGBA*)rfx_alloc(width*height*sizeof(RGBA));
1537 pic2 = (RGBA*)rfx_alloc(width*height*sizeof(RGBA));
1538 memcpy(pic, data, width*height*sizeof(RGBA));
1541 printf("Compressing %s, size %dx%d\n", fname, width, height);
1543 memset(&swf,0,sizeof(SWF));
1544 memset(&obj,0,sizeof(obj));
1546 swf.fileVersion = 6;
1547 swf.frameRate = framerate*256;
1548 swf.movieSize.xmax = 20*width*2;
1549 swf.movieSize.ymax = 20*height;
1551 swf.firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
1553 rgb.r = 0x00;rgb.g = 0x30;rgb.b = 0xff;
1554 swf_SetRGB(tag,&rgb);
1556 tag = swf_InsertTag(tag, ST_DEFINEVIDEOSTREAM);
1557 swf_SetU16(tag, 33);
1558 swf_SetVideoStreamDefine(tag, &stream, frames, width, height);
1559 stream.do_motion = 0;
1563 for(t=0;t<frames;t++)
1567 for(y=0,yy=0;y<height;y++,yy+=d) {
1568 RGBA*line = &pic[((int)yy)*width];
1569 for(x=0,xx=0;x<width;x++,xx+=d) {
1572 if(dx==0 && dy==0) {
1573 pic2[y*width+x] = line[((int)xx)];
1574 pic2[y*width+x].r+=2;
1575 pic2[y*width+x].g+=2;
1576 pic2[y*width+x].b+=2;
1578 //pic2[y*width+x] = line[((int)xx)];
1579 //pic2[y*width+x].r = lrand48();//line[((int)xx)];
1580 //pic2[y*width+x].g = lrand48();//line[((int)xx)];
1581 //pic2[y*width+x].b = lrand48();//line[((int)xx)];
1582 pic2[y*width+x].r = 0;
1583 pic2[y*width+x].g = 0;
1584 pic2[y*width+x].b = 0;
1586 /*if(dx==16 && dy==16)
1587 pic2[y*width+x] = pic[(y-16*16)*width+(x-16*16)];*/
1588 /*if(dx<=0 && dy<=0) {
1589 pic2[y*width+x] = line[((int)xx)];*/
1590 /*if(x==0 && y==0) {
1592 memset(&color, 0, sizeof(RGBA));
1593 pic2[y*width+x] = color;*/
1596 color.r = lrand48();
1597 color.g = lrand48();
1598 color.b = lrand48();
1600 pic2[y*width+x] = color;
1604 printf("frame:%d\n", t);fflush(stdout);
1609 tag = swf_InsertTag(tag, ST_VIDEOFRAME);
1610 swf_SetU16(tag, 33);
1612 swf_SetVideoStreamIFrame(tag, &stream, pic2, 7);
1614 swf_SetVideoStreamPFrame(tag, &stream, pic2, 7);
1617 tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
1618 swf_GetPlaceObject(0, &obj);
1627 swf_SetPlaceObject(tag,&obj);
1629 tag = swf_InsertTag(tag, ST_SHOWFRAME);
1632 swf_VideoStreamClear(&stream);
1634 tag = swf_InsertTag(tag, ST_END);
1636 fi = open("video3.swf", O_WRONLY|O_CREAT|O_TRUNC, 0644);
1637 if(swf_WriteSWF(fi,&swf)<0) {
1638 fprintf(stderr,"WriteSWF() failed.\n");