lib/h.263/mkvideo.c

   1 /* mkvideo.c
   2    Create a video file.
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org> */
   7
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <assert.h>
  11 #include <math.h>
  12 #include "../rfxswf.h"
  13 #include "h263tables.c"
  14 #include "swfvideo.h"
  15
  16 void swf_SetVideoStreamDefine(TAG*tag, VIDEOSTREAM*stream, U16 frames, U16 width, U16 height)
  17 {
  18     width=width&~15; height=height&~15;
  19     swf_SetU16(tag, frames);
  20     swf_SetU16(tag, width);
  21     swf_SetU16(tag, height);
  22     swf_SetU8(tag, 1); /* smoothing on */
  23     swf_SetU8(tag, 2); /* codec = h.263 sorenson spark */
  24
  25     memset(stream, 0, sizeof(VIDEOSTREAM));
  26     stream->olinex = width;
  27     width+=15;width&=~15;
  28     height+=15;height&=~15;
  29     stream->linex = width;
  30     stream->width = width;
  31     stream->height = height;
  32     stream->bbx = width/16;
  33     stream->bby = height/16;
  34     stream->current = (YUV*)malloc(width*height*sizeof(YUV));
  35     stream->oldpic = (YUV*)malloc(width*height*sizeof(YUV));
  36     stream->mvdx = (int*)malloc(stream->bbx*stream->bby*sizeof(int));
  37     stream->mvdy = (int*)malloc(stream->bbx*stream->bby*sizeof(int));
  38     stream->do_motion = 0;
  39
  40     memset(stream->oldpic, 0, width*height*sizeof(YUV));
  41     memset(stream->current, 0, width*height*sizeof(YUV));
  42 }
  43 void swf_VideoStreamClear(VIDEOSTREAM*stream)
  44 {
  45     free(stream->oldpic);stream->oldpic = 0;
  46     free(stream->current);stream->current = 0;
  47     free(stream->mvdx);stream->mvdx=0;
  48     free(stream->mvdy);stream->mvdy=0;
  49 }
  50
  51 typedef struct _block_t
  52 {
  53     int y1[64];
  54     int y2[64];
  55     int y3[64];
  56     int y4[64];
  57     int u[64];
  58     int v[64];
  59 } block_t;
  60
  61 typedef struct _fblock_t
  62 {
  63     double y1[64];
  64     double y2[64];
  65     double y3[64];
  66     double y4[64];
  67     double u[64];
  68     double v[64];
  69 } fblock_t;
  70
  71 static int zigzagtable[64] = {
  72     0, 1, 5, 6, 14, 15, 27, 28,
  73     2, 4, 7, 13, 16, 26, 29, 42,
  74     3, 8, 12, 17, 25, 30, 41, 43,
  75     9, 11, 18, 24, 31, 40, 44, 53,
  76     10, 19, 23, 32, 39, 45, 52, 54,
  77     20, 22, 33, 38, 46, 51, 55, 60,
  78     21, 34, 37, 47, 50, 56, 59, 61,
  79     35, 36, 48, 49, 57, 58, 62, 63};
  80
  81 static void fzigzag(double*src)
  82 {
  83     double tmp[64];
  84     int t;
  85     for(t=0;t<64;t++) {
  86         ((int*)&tmp[zigzagtable[t]])[0] = ((int*)&src[t])[0];
  87         ((int*)&tmp[zigzagtable[t]])[1] = ((int*)&src[t])[1];
  88     }
  89     memcpy(src, tmp, sizeof(double)*64);
  90 }
  91
  92 #define PI 3.14159265358979
  93 #define SQRT2 1.414214
  94 #define RSQRT2 (1.0/1.414214)
  95
  96 static double table[8][8] =
  97 {
  98 {0.707106781186548,0.707106781186548,0.707106781186548,0.707106781186548,0.707106781186548,0.707106781186548,0.707106781186548,0.707106781186548},
  99 {0.980785280403230,0.831469612302545,0.555570233019602,0.195090322016128,-0.195090322016128,-0.555570233019602,-0.831469612302545,-0.980785280403230},
 100 {0.923879532511287,0.382683432365090,-0.382683432365090,-0.923879532511287,-0.923879532511287,-0.382683432365090,0.382683432365090,0.923879532511287},
 101 {0.831469612302545,-0.195090322016128,-0.980785280403230,-0.555570233019602,0.555570233019602,0.980785280403230,0.195090322016129,-0.831469612302545},
 102 {0.707106781186548,-0.707106781186547,-0.707106781186548,0.707106781186547,0.707106781186548,-0.707106781186547,-0.707106781186547,0.707106781186547},
 103 {0.555570233019602,-0.980785280403230,0.195090322016128,0.831469612302545,-0.831469612302545,-0.195090322016128,0.980785280403231,-0.555570233019602},
 104 {0.382683432365090,-0.923879532511287,0.923879532511287,-0.382683432365090,-0.382683432365091,0.923879532511287,-0.923879532511286,0.382683432365090},
 105 {0.195090322016128,-0.555570233019602,0.831469612302545,-0.980785280403231,0.980785280403230,-0.831469612302545,0.555570233019602,-0.195090322016129}
 106 };
 107
 108 static void dct(double*src)
 109 {
 110     double tmp[64];
 111     int x,y,u,v,t;
 112
 113     for(v=0;v<8;v++)
 114     for(u=0;u<8;u++)
 115     {
 116         double c = 0;
 117         for(x=0;x<8;x++)
 118         {
 119             c+=table[u][x]*src[v*8+x];
 120         }
 121         tmp[v*8+u] = c;
 122     }
 123     for(u=0;u<8;u++)
 124     for(v=0;v<8;v++)
 125     {
 126         double c = 0;
 127         for(y=0;y<8;y++)
 128         {
 129             c+=table[v][y]*tmp[y*8+u];
 130         }
 131         src[v*8+u] = c*0.25;
 132     }
 133 }
 134
 135 static void idct(double*src)
 136 {
 137     double tmp[64];
 138     int x,y,u,v;
 139     for(y=0;y<8;y++)
 140     for(x=0;x<8;x++)
 141     {
 142         double c = 0;
 143         for(u=0;u<8;u++)
 144         {
 145             c+=table[u][x]*src[y*8+u];
 146         }
 147         tmp[y*8+x] = c;
 148     }
 149     for(y=0;y<8;y++)
 150     for(x=0;x<8;x++)
 151     {
 152         double c = 0;
 153         for(v=0;v<8;v++)
 154         {
 155             c+=table[v][y]*tmp[v*8+x];
 156         }
 157         src[y*8+x] = c*0.25;
 158     }
 159 }
 160
 161 static double c[8] = {1.0,
 162 0.980785280403230, // cos(Pi*1/16), sin(Pi*7/16)
 163 0.923879532511287, // cos(Pi*2/16), sin(Pi*6/16)
 164 0.831469612302545, // cos(Pi*3/16), sin(Pi*5/16)
 165 0.707106781186548, // cos(Pi*4/16), sin(Pi*4/16), 1/sqrt(2)
 166 0.555570233019602, // cos(Pi*5/16), sin(Pi*3/16)
 167 0.382683432365090, // cos(Pi*6/16), sin(Pi*2/16)
 168 0.195090322016128 // cos(Pi*7/16), sin(Pi*1/16)
 169 };
 170
 171 static double cc[8];
 172 int ccquant = -1;
 173
 174 static void preparequant(int quant)
 175 {
 176     if(ccquant == quant)
 177         return;
 178     cc[0] = c[0]/(quant*2*4);
 179     cc[1] = c[1]/(quant*2*4);
 180     cc[2] = c[2]/(quant*2*4);
 181     cc[3] = c[3]/(quant*2*4);
 182     cc[4] = c[4]/(quant*2*4);
 183     cc[5] = c[5]/(quant*2*4);
 184     cc[6] = c[6]/(quant*2*4);
 185     cc[7] = c[7]/(quant*2*4);
 186     ccquant = quant;
 187 }
 188
 189 inline static void innerdct(double*a,double*b, double*c)
 190 {
 191     // c1*c7*2 = c6
 192     // c2*c6*2 = c4
 193     // c3*c5*2 = c2
 194     // c4*c4*2 = 1
 195
 196      //{  1,  3,  5,  7, -7, -5, -3, -1},
 197      //{  3, -7, -1, -5,  5,  1,  7, -3},
 198      //{  5, -1,  7,  3, -3, -7,  1, -5},
 199      //{  7, -5,  3, -1,  1, -3,  5, -7}
 200     double b0,b1,b2,b3,b4,b5;
 201     b2 = (a[0]+a[7]);
 202     b3 = (a[1]+a[6]);
 203     b4 = (a[2]+a[5]);
 204     b5 = (a[3]+a[4]);
 205
 206     b0 = (b2+b5)*c[4];
 207     b1 = (b3+b4)*c[4];
 208     b[0*8] = b0 + b1;
 209     b[4*8] = b0 - b1;
 210     b[2*8] = (b2-b5)*c[2] + (b3-b4)*c[6];
 211     b[6*8] = (b2-b5)*c[6] + (b4-b3)*c[2];
 212
 213     b0 = (a[0]-a[7]);
 214     b1 = (a[1]-a[6]);
 215     b2 = (a[2]-a[5]);
 216     b3 = (a[3]-a[4]);
 217
 218     b[1*8] = b0*c[1] + b1*c[3] + b2*c[5] + b3*c[7];
 219     b[3*8] = b0*c[3] - b1*c[7] - b2*c[1] - b3*c[5];
 220     b[5*8] = b0*c[5] - b1*c[1] + b2*c[7] + b3*c[3];
 221     b[7*8] = b0*c[7] - b1*c[5] + b2*c[3] - b3*c[1];
 222 }
 223
 224 static void dct2(double*src, int*dest)
 225 {
 226     double tmp[64], tmp2[64];
 227     double*p;
 228     int u,x,v,t;
 229
 230     for(v=0;v<8;v++)
 231     {
 232         double* a=&src[v*8];
 233         double* b=&tmp[v];
 234         innerdct(a,b,c);
 235     }
 236     for(v=0;v<8;v++)
 237     {
 238         double* a=&tmp[v*8];
 239         double* b=&tmp2[v];
 240         innerdct(a,b,cc);
 241     }
 242     for(t=0;t<64;t++) {
 243         dest[zigzagtable[t]] = (int)(tmp2[t]);
 244     }
 245 }
 246
 247
 248 static inline int truncate256(int a)
 249 {
 250     if(a>255) return 255;
 251     if(a<0) return 0;
 252     return a;
 253 }
 254
 255 static void getregion(fblock_t* bb, YUV*pic, int posx, int posy, int linex)
 256 {
 257     YUV*p1 = &pic[posy*linex+posx];
 258     YUV*p2 = p1;
 259     int y1=0, y2=0, y3=0, y4=0;
 260     int u=0,v=0;
 261     int x,y;
 262     for(y=0;y<8;y++) {
 263         for(x=0;x<8;x++) {
 264             bb->u[u++] = (p2[x*2].u + p2[x*2+1].u + p2[linex+x*2].u + p2[linex+x*2+1].u)/4;
 265             bb->v[v++] = (p2[x*2].v + p2[x*2+1].v + p2[linex+x*2].v + p2[linex+x*2+1].v)/4;
 266             bb->y1[y1++] = p1[x].y;
 267             bb->y2[y2++] = p1[x+8].y;
 268             bb->y3[y3++] = p1[linex*8+x].y;
 269             bb->y4[y4++] = p1[linex*8+x+8].y;
 270         }
 271         p1+=linex;
 272         p2+=linex*2;
 273     }
 274 }
 275 static void rgb2yuv(YUV*dest, RGBA*src, int dlinex, int slinex, int width, int height)
 276 {
 277     int x,y;
 278     for(y=0;y<height;y++) {
 279         for(x=0;x<width;x++) {
 280             int r,g,b;
 281             r = src[y*slinex+x].r;
 282             g = src[y*slinex+x].g;
 283             b = src[y*slinex+x].b;
 284             /*dest[y*dlinex+x].y = (r*0.299 + g*0.587 + b*0.114);
 285             dest[y*dlinex+x].u = (r*-0.169 + g*-0.332 + b*0.500 + 128.0);
 286             dest[y*dlinex+x].v = (r*0.500 + g*-0.419 + b*-0.0813 + 128.0);*/
 287             dest[y*dlinex+x].y = (r*((int)( 0.299*256)) + g*((int)( 0.587*256)) + b*((int)( 0.114 *256)))>>8;
 288             dest[y*dlinex+x].u = (r*((int)(-0.169*256)) + g*((int)(-0.332*256)) + b*((int)( 0.500 *256))+ 128*256)>>8;
 289             dest[y*dlinex+x].v = (r*((int)( 0.500*256)) + g*((int)(-0.419*256)) + b*((int)(-0.0813*256))+ 128*256)>>8;
 290         }
 291     }
 292 }
 293 static void copyregion(VIDEOSTREAM*s, YUV*dest, YUV*src, int bx, int by)
 294 {
 295     YUV*p1 = &src[by*s->linex*16+bx*16];
 296     YUV*p2 = &dest[by*s->linex*16+bx*16];
 297     int y;
 298     for(y=0;y<16;y++) {
 299         memcpy(p1, p2, 16*sizeof(YUV));
 300         p1+=s->linex;p2+=s->linex;
 301     }
 302 }
 303
 304 static void yuv2rgb(RGBA*dest, YUV*src, int linex, int width, int height)
 305 {
 306     int x,y;
 307     for(y=0;y<height;y++) {
 308         for(x=0;x<width;x++) {
 309             int u,v,yy;
 310             u = src[y*linex+x].u;
 311             v = src[y*linex+x].v;
 312             yy = src[y*linex+x].y;
 313             dest[y*linex+x].r = truncate256(yy + ((360*(v-128))>>8));
 314             dest[y*linex+x].g = truncate256(yy - ((88*(u-128)+183*(v-128))>>8));
 315             dest[y*linex+x].b = truncate256(yy + ((455 * (u-128))>>8));
 316         }
 317     }
 318 }
 319 static void copyblock(VIDEOSTREAM*s, YUV*dest, block_t*b, int bx, int by)
 320 {
 321     YUV*p1 = &dest[(by*16)*s->linex+bx*16];
 322     YUV*p2 = &dest[(by*16+8)*s->linex+bx*16];
 323     int x,y;
 324     for(y=0;y<8;y++) {
 325         for(x=0;x<8;x++) {
 326             int u,v,yy;
 327             p1[x+0].u = b->u[(y/2)*8+(x/2)];
 328             p1[x+0].v = b->v[(y/2)*8+(x/2)];
 329             p1[x+0].y = b->y1[y*8+x];
 330             p1[x+8].u = b->u[(y/2)*8+(x/2)+4];
 331             p1[x+8].v = b->v[(y/2)*8+(x/2)+4];
 332             p1[x+8].y = b->y2[y*8+x];
 333             p2[x+0].u = b->u[(y/2+4)*8+(x/2)];
 334             p2[x+0].v = b->v[(y/2+4)*8+(x/2)];
 335             p2[x+0].y = b->y3[y*8+x];
 336             p2[x+8].u = b->u[(y/2+4)*8+(x/2)+4];
 337             p2[x+8].v = b->v[(y/2+4)*8+(x/2)+4];
 338             p2[x+8].y = b->y4[y*8+x];
 339         }
 340         p1+=s->linex;
 341         p2+=s->linex;
 342     }
 343 }
 344
 345 static int compareregions(VIDEOSTREAM*s, int bx, int by)
 346 {
 347     int linex = s->width;
 348     YUV*p1 = &s->current[by*linex*16+bx*16];
 349     YUV*p2 = &s->oldpic[by*linex*16+bx*16];
 350     int diff = 0;
 351     int x,y;
 352     for(y=0;y<16;y++) {
 353         for(x=0;x<16;x++) {
 354             YUV*m = &p1[x];
 355             YUV*n = &p2[x];
 356             int y = m->y - n->y;
 357             int u = m->u - n->u;
 358             int v = m->v - n->v;
 359             diff += y*y+(u*u+v*v)/4;
 360         }
 361         p1+=linex;
 362         p2+=linex;
 363     }
 364     return diff/256;
 365 }
 366
 367 static inline int valtodc(int val)
 368 {
 369     assert(val>=0);
 370
 371     /* table 12/h.263 */
 372
 373     //val+=4; //round
 374     val/=8;
 375     /* TODO: what to do for zero values? skip the block? */
 376     if(val==0)
 377         return 1;
 378     if(val==128)
 379         return 255;
 380     if(val>254)
 381         return 254;
 382     return val;
 383 }
 384 static int dctoval(int dc)
 385 {
 386     int val;
 387     assert(dc>0);
 388     assert(dc!=128);
 389     assert(dc<256);
 390     /* table 12/h.263 */
 391     val = dc*8;
 392     if(val == 255*8)
 393         val = 128*8;
 394     return val;
 395 }
 396
 397 static int codehuffman(TAG*tag, struct huffcode*table, int index)
 398 {
 399     /* TODO: !optimize! */
 400     int i=0;
 401     while(table[index].code[i]) {
 402         if(table[index].code[i]=='0')
 403             swf_SetBits(tag, 0, 1);
 404         else
 405             swf_SetBits(tag, 1, 1);
 406         i++;
 407     }
 408     return i;
 409 }
 410
 411 static void quantize8x8(double*src, int*dest, int has_dc, int quant)
 412 {
 413     int t,pos=0;
 414     double q = 1.0/(quant*2);
 415     if(has_dc) {
 416         dest[0] = valtodc((int)src[0]); /*DC*/
 417         pos++;
 418     }
 419     for(t=pos;t<64;t++)
 420     {
 421         //dest[t] = (int)src[t];
 422     /* exact: if(quant&1){dest[t] = (dest[t]/quant - 1)/2;}else{dest[t] = ((dest[t]+1)/quant - 1)/2;} */
 423         //if(quant&1){dest[t] = (dest[t]/quant - 1)/2;}else{dest[t] = ((dest[t]+1)/quant - 1)/2;}
 424         //dest[t] = dest[t]/(quant*2);
 425         dest[t] = (int)(src[t]*q);
 426         /* TODO: warn if this happens- the video will be buggy */
 427         if(dest[t]>127) dest[t]=127;
 428         if(dest[t]<-127) dest[t]=-127;
 429     }
 430 }
 431
 432 static void dequantize8x8(int*b, int has_dc, int quant)
 433 {
 434     int t,pos=0;
 435     if(has_dc) {
 436         b[0] = dctoval(b[0]); //DC
 437         pos++;
 438     }
 439     for(t=pos;t<64;t++) {
 440         if(b[t]) {
 441             int sign = 0;
 442             if(b[t]<0) {
 443                 b[t] = -b[t];
 444                 sign = 1;
 445             }
 446
 447             if(quant&1) {
 448                 b[t] = quant*(2*b[t]+1); //-7,8,24,40
 449             } else {
 450                 b[t] = quant*(2*b[t]+1)-1; //-8,7,23,39
 451             }
 452
 453             if(sign)
 454                 b[t] = -b[t];
 455         }
 456
 457         /* paragraph 6.2.2, "clipping of reconstruction levels": */
 458         if(b[t]>2047) b[t]=2047;
 459         if(b[t]<-2048) b[t]=-2048;
 460     }
 461 }
 462
 463 static int hascoef(int*b, int has_dc)
 464 {
 465     int t;
 466     int pos=0;
 467     if(has_dc)
 468         pos++;
 469     for(t=pos;t<64;t++) {
 470         if(b[t])
 471             return 1;
 472     }
 473     return 0;
 474 }
 475
 476 static int coefbits8x8(int*bb, int has_dc)
 477 {
 478     int t;
 479     int pos=0;
 480     int bits=0;
 481     int last;
 482
 483     if(has_dc) {
 484         bits+=8;
 485         pos++;
 486     }
 487     for(last=63;last>=pos;last--) {
 488         if(bb[last])
 489             break;
 490     }
 491     if(last < pos)
 492         return bits;
 493     while(1) {
 494         int run=0, level=0, islast=0,t;
 495         while(!bb[pos] && pos<last) {
 496             pos++;
 497             run++;
 498         }
 499         if(pos==last)
 500             islast=1;
 501         level=bb[pos];
 502         if(level<0) level=-level;
 503         assert(level);
 504         for(t=0;t<RLE_ESCAPE;t++) {
 505             if(rle_params[t].run == run &&
 506                rle_params[t].level == level &&
 507                rle_params[t].last == islast) {
 508                 bits += rle[t].len + 1;
 509                 break;
 510             }
 511         }
 512         if(t==RLE_ESCAPE) {
 513             bits += rle[RLE_ESCAPE].len + 1 + 6 + 8;
 514         }
 515         if(islast)
 516             break;
 517         pos++;
 518     }
 519     return bits;
 520 }
 521
 522 static void encode8x8(TAG*tag, int*bb, int has_dc, int has_tcoef)
 523 {
 524     int t;
 525     int pos=0;
 526     int bits=0;
 527
 528     if(has_dc) {
 529         swf_SetBits(tag, bb[0], 8);
 530         pos++;
 531     }
 532
 533     if(has_tcoef) {
 534         int last;
 535         /* determine last non-null coefficient */
 536         for(last=63;last>=pos;last--) {
 537             /* TODO: we could leave out small coefficients
 538                      after a certain point (32?) */
 539             if(bb[last])
 540                 break;
 541         }
 542         /* blocks without coefficients should not be included
 543            in the cbpy/cbpc patterns: */
 544         assert(bb[last]);
 545
 546         while(1) {
 547             int run=0;
 548             int level=0;
 549             int islast=0;
 550             int sign=0;
 551             int t;
 552             while(!bb[pos] && pos<last) {
 553                 pos++;
 554                 run++;
 555             }
 556             if(pos==last)
 557                 islast=1;
 558             level=bb[pos];
 559             assert(level);
 560             if(level<0) {
 561                 level = -level;
 562                 sign = 1;
 563             }
 564             for(t=0;t<RLE_ESCAPE;t++) {
 565                 /* TODO: lookup table */
 566                 if(rle_params[t].run == run &&
 567                    rle_params[t].level == level &&
 568                    rle_params[t].last == islast) {
 569                     codehuffman(tag, rle, t);
 570                     swf_SetBits(tag, sign, 1);
 571                     break;
 572                 }
 573             }
 574             if(t==RLE_ESCAPE) {
 575                 codehuffman(tag, rle, RLE_ESCAPE);
 576                 level=bb[pos];
 577                 /* table 14/h.263 */
 578                 assert(level);
 579                 assert(level>=-127);
 580                 assert(level<=127);
 581
 582                 swf_SetBits(tag, islast, 1);
 583                 swf_SetBits(tag, run, 6);
 584                 swf_SetBits(tag, level, 8); //FIXME: fixme??
 585             }
 586
 587             if(islast)
 588                 break;
 589             pos++;
 590         }
 591     }
 592 }
 593
 594 static void quantize(fblock_t*fb, block_t*b, int has_dc, int quant)
 595 {
 596     quantize8x8(fb->y1, b->y1, has_dc, quant);
 597     quantize8x8(fb->y2, b->y2, has_dc, quant);
 598     quantize8x8(fb->y3, b->y3, has_dc, quant);
 599     quantize8x8(fb->y4, b->y4, has_dc, quant);
 600     quantize8x8(fb->u, b->u, has_dc, quant);
 601     quantize8x8(fb->v, b->v, has_dc, quant);
 602 }
 603
 604 static void dodct(fblock_t*fb)
 605 {
 606     dct(fb->y1); dct(fb->y2); dct(fb->y3); dct(fb->y4);
 607     dct(fb->u);  dct(fb->v);
 608     fzigzag(fb->y1);
 609     fzigzag(fb->y2);
 610     fzigzag(fb->y3);
 611     fzigzag(fb->y4);
 612     fzigzag(fb->u);
 613     fzigzag(fb->v);
 614 }
 615 static void dodctandquant(fblock_t*fb, block_t*b, int has_dc, int quant)
 616 {
 617     int t;
 618     if(has_dc) {
 619         dodct(fb);
 620         quantize(fb,b,has_dc,quant);
 621         return;
 622     }
 623     preparequant(quant);
 624     dct2(fb->y1,b->y1); dct2(fb->y2,b->y2); dct2(fb->y3,b->y3); dct2(fb->y4,b->y4);
 625     dct2(fb->u,b->u);  dct2(fb->v,b->v);
 626 }
 627
 628 static void doidct(block_t*b)
 629 {
 630     fblock_t fb;
 631     int t;
 632     for(t=0;t<64;t++) {
 633         fb.y1[t] = b->y1[zigzagtable[t]];
 634         fb.y2[t] = b->y2[zigzagtable[t]];
 635         fb.y3[t] = b->y3[zigzagtable[t]];
 636         fb.y4[t] = b->y4[zigzagtable[t]];
 637         fb.u[t] = b->u[zigzagtable[t]];
 638         fb.v[t] = b->v[zigzagtable[t]];
 639     }
 640     idct(fb.y1); idct(fb.y2); idct(fb.y3); idct(fb.y4);
 641     idct(fb.u);  idct(fb.v);
 642     for(t=0;t<64;t++) {
 643         b->y1[t] = fb.y1[t];
 644         b->y2[t] = fb.y2[t];
 645         b->y3[t] = fb.y3[t];
 646         b->y4[t] = fb.y4[t];
 647         b->u[t] = fb.u[t];
 648         b->v[t] = fb.v[t];
 649     }
 650 }
 651 static void truncateblock(block_t*b)
 652 {
 653     int t;
 654     for(t=0;t<64;t++) {
 655         b->y1[t] = truncate256(b->y1[t]);
 656         b->y2[t] = truncate256(b->y2[t]);
 657         b->y3[t] = truncate256(b->y3[t]);
 658         b->y4[t] = truncate256(b->y4[t]);
 659         b->u[t] = truncate256(b->u[t]);
 660         b->v[t] = truncate256(b->v[t]);
 661     }
 662 }
 663
 664 static void dequantize(block_t*b, int has_dc, int quant)
 665 {
 666     dequantize8x8(b->y1, has_dc, quant);
 667     dequantize8x8(b->y2, has_dc, quant);
 668     dequantize8x8(b->y3, has_dc, quant);
 669     dequantize8x8(b->y4, has_dc, quant);
 670     dequantize8x8(b->u, has_dc, quant);
 671     dequantize8x8(b->v, has_dc, quant);
 672 }
 673
 674 static void getblockpatterns(block_t*b, int*cbpybits,int*cbpcbits, int has_dc)
 675 {
 676     *cbpybits = 0;
 677     *cbpcbits = 0;
 678
 679     *cbpybits|=hascoef(b->y1, has_dc)*8;
 680     *cbpybits|=hascoef(b->y2, has_dc)*4;
 681     *cbpybits|=hascoef(b->y3, has_dc)*2;
 682     *cbpybits|=hascoef(b->y4, has_dc)*1;
 683
 684     *cbpcbits|=hascoef(b->u, has_dc)*2;
 685     *cbpcbits|=hascoef(b->v, has_dc)*1;
 686 }
 687
 688 static void setQuant(TAG*tag, int dquant)
 689 {
 690     int code = 0;
 691     /* 00 01 10 11
 692        -1 -2 +1 +2
 693     */
 694     if(dquant == -1) {
 695         swf_SetBits(tag, 0x0, 2);
 696     } else if(dquant == -2) {
 697         swf_SetBits(tag, 0x1, 2);
 698     } else if(dquant == +1) {
 699         swf_SetBits(tag, 0x2, 2);
 700     } else if(dquant == +2) {
 701         swf_SetBits(tag, 0x3, 2);
 702     } else {
 703         assert(0*strlen("invalid dquant"));
 704     }
 705 }
 706
 707 static void change_quant(int quant, int*dquant)
 708 {
 709     /* TODO */
 710     *dquant = 0;
 711 }
 712
 713 static void encode_blockI(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant)
 714 {
 715     fblock_t fb;
 716     block_t b;
 717     int dquant=0;
 718     int cbpcbits = 0, cbpybits=0;
 719
 720     getregion(&fb, s->current, bx*16, by*16, s->width);
 721
 722     change_quant(*quant, &dquant);
 723     *quant+=dquant;
 724
 725     dodctandquant(&fb, &b, 1, *quant);
 726     //quantize(&fb, &b, 1, *quant);
 727
 728     //decode_blockI(s, &b, bx, by);
 729
 730     getblockpatterns(&b, &cbpybits, &cbpcbits, 1);
 731
 732     if(dquant) {
 733         codehuffman(tag, mcbpc_intra, 4+cbpcbits);
 734     } else {
 735         codehuffman(tag, mcbpc_intra, 0+cbpcbits);
 736     }
 737
 738     codehuffman(tag, cbpy, cbpybits);
 739
 740     if(dquant) {
 741         setQuant(tag, dquant);
 742     }
 743
 744     /* luminance */
 745     encode8x8(tag, b.y1, 1, cbpybits&8);
 746     encode8x8(tag, b.y2, 1, cbpybits&4);
 747     encode8x8(tag, b.y3, 1, cbpybits&2);
 748     encode8x8(tag, b.y4, 1, cbpybits&1);
 749
 750     /* chrominance */
 751     encode8x8(tag, b.u, 1, cbpcbits&2);
 752     encode8x8(tag, b.v, 1, cbpcbits&1);
 753
 754     /* reconstruct */
 755     dequantize(&b, 1, *quant);
 756     doidct(&b);
 757     truncateblock(&b);
 758     copyblock(s, s->current, &b, bx, by);
 759 }
 760
 761 static void yuvdiff(fblock_t*a, fblock_t*b)
 762 {
 763     int t;
 764     for(t=0;t<64;t++) {
 765         a->y1[t] = (a->y1[t] - b->y1[t]);
 766         a->y2[t] = (a->y2[t] - b->y2[t]);
 767         a->y3[t] = (a->y3[t] - b->y3[t]);
 768         a->y4[t] = (a->y4[t] - b->y4[t]);
 769         a->u[t]  = (a->u[t] - b->u[t]);
 770         a->v[t]  = (a->v[t] - b->v[t]);
 771     }
 772 }
 773
 774 static void predictmvd(VIDEOSTREAM*s, int bx, int by, int*px, int*py)
 775 {
 776     int i1,i2;
 777     int x1,y1,x2,y2,x3,y3;
 778     int x4,y4,p;
 779     if(bx) {x1=s->mvdx[by*s->bbx+bx-1];
 780             y1=s->mvdy[by*s->bbx+bx-1];
 781     } else {x1=y1=0;}
 782
 783     if(by) {x2=s->mvdx[(by-1)*s->bbx+bx];
 784             y2=s->mvdy[(by-1)*s->bbx+bx];
 785             if(bx<s->bbx-1) {
 786                 x3=s->mvdx[(by-1)*s->bbx+bx+1];
 787                 y3=s->mvdy[(by-1)*s->bbx+bx+1];
 788             } else {
 789                 x3=y3=0;
 790             }
 791            }
 792     else   {x2=x3=x1;y2=y3=y1;}
 793
 794            if((x1 <= x2 && x2 <= x3) ||
 795               (x3 <= x2 && x2 <= x1)) {
 796         x4=x2;
 797     } else if((x2 <= x1 && x1 <= x3) ||
 798               (x3 <= x1 && x1 <= x2)) {
 799         x4=x1;
 800     } else if((x1 <= x3 && x3 <= x2) ||
 801               (x2 <= x3 && x3 <= x1)) {
 802         x4=x3;
 803     }
 804
 805            if((y1 <= y2 && y2 <= y3) ||
 806               (y3 <= y2 && y2 <= y1)) {
 807         y4=y2;
 808     } else if((y2 <= y1 && y1 <= y3) ||
 809               (y3 <= y1 && y1 <= y2)) {
 810         y4=y1;
 811     } else if((y1 <= y3 && y3 <= y2) ||
 812               (y2 <= y3 && y3 <= y1)) {
 813         y4=y3;
 814     }
 815
 816     *px = x4;
 817     *py = y4;
 818     assert((x4>=-32 && x4<=31) && (y4>=-32 && y4<=31));
 819 }
 820
 821 static inline int mvd2index(int px, int py, int x, int y, int xy)
 822 {
 823     assert((x>=-32 && x<=31) && (y>=-32 && y<=31));
 824     assert((x&1)==0 && (y&1)==0);//for now
 825     assert((x&2)==0 && (y&2)==0);//for now(2)
 826
 827     x-=px;
 828     y-=py;
 829
 830     if(xy)
 831         x=y;
 832     x+=32;
 833
 834     /* (x&63) */
 835     if(x>63)
 836         x-=64;
 837     if(x<0)
 838         x+=64;
 839
 840     assert(x>=0 && x<64);
 841     return x;
 842 }
 843
 844 static int encode_blockP(TAG*tag, VIDEOSTREAM*s, int bx, int by, int*quant)
 845 {
 846     fblock_t fb;
 847     block_t b;
 848     int dquant=0;
 849     int has_mvd=0;
 850     int has_mvd24=0;
 851     int has_dc=1;
 852     int mode = 0;
 853     int cbpcbits = 0, cbpybits=0;
 854     int diff;
 855     int predictmvdx;
 856     int predictmvdy;
 857
 858     block_t b_i;
 859     int bits_i;
 860
 861     fblock_t fbold_v00;
 862     block_t b_v00;
 863     int bits_v00 = 65535;
 864     int x_v00=0;
 865     int y_v00=0;
 866
 867     diff = compareregions(s, bx, by);
 868     if(diff < 20 /*TODO: should be a parameter- good values are between 32 and 48 */) {
 869         swf_SetBits(tag, 1,1); /* cod=1, block skipped */
 870         /* copy the region from the last frame so that we have a complete reconstruction */
 871         copyregion(s, s->current, s->oldpic, bx, by);
 872         return 1;
 873     }
 874
 875     predictmvd(s,bx,by,&predictmvdx,&predictmvdy);
 876     getregion(&fb, s->current, bx*16, by*16, s->width);
 877
 878     { /* consider I-block */
 879         fblock_t fb_i;
 880         int y,c;
 881         memcpy(&fb_i, &fb, sizeof(fblock_t));
 882         dodctandquant(&fb_i, &b_i, 1, *quant);
 883         //quantize(&fb_i, &b_i, 1, *quant);
 884         getblockpatterns(&b_i, &y, &c, 1);
 885         bits_i = 1; //cod
 886         bits_i += mcbpc_inter[3*4+c].len;
 887         bits_i += cbpy[y].len;
 888         bits_i += coefbits8x8(b_i.y1, 1);
 889         bits_i += coefbits8x8(b_i.y2, 1);
 890         bits_i += coefbits8x8(b_i.y3, 1);
 891         bits_i += coefbits8x8(b_i.y4, 1);
 892         bits_i += coefbits8x8(b_i.u, 1);
 893         bits_i += coefbits8x8(b_i.v, 1);
 894     }
 895
 896     { /* consider mvd(x,y)-block */
 897         fblock_t fbdiff;
 898         int y,c;
 899
 900         x_v00=0;
 901         y_v00=0;
 902
 903         if(s->do_motion) {
 904             int hx,hy;
 905             int bestx=0,besty=0,bestbits=65536;
 906             int startx=-8,endx=8;
 907             int starty=-8,endy=8;
 908
 909             if(!bx) startx=0;
 910             if(!by) starty=0;
 911             if(bx==s->bbx-1) endx=0;
 912             if(by==s->bby-1) endy=0;
 913
 914             for(hx=startx;hx<=endx;hx+=4)
 915             for(hy=starty;hy<=endy;hy+=4)
 916             {
 917                 block_t b;
 918                 fblock_t fbold;
 919                 int bits = 0;
 920                 memcpy(&fbdiff, &fb, sizeof(fblock_t));
 921                 getregion(&fbold, s->oldpic, bx*16+hx/2, by*16+hy/2, s->linex);
 922                 yuvdiff(&fbdiff, &fbold);
 923                 dodctandquant(&fbdiff, &b, 0, *quant);
 924                 //quantize(&fbdiff, &b, 0, *quant);
 925                 bits += coefbits8x8(b.y1, 0);
 926                 bits += coefbits8x8(b.y2, 0);
 927                 bits += coefbits8x8(b.y3, 0);
 928                 bits += coefbits8x8(b.y4, 0);
 929                 bits += coefbits8x8(b.u, 0);
 930                 bits += coefbits8x8(b.v, 0);
 931                 if(bits<bestbits) {
 932                     bestbits = bits;
 933                     bestx = hx;
 934                     besty = hy;
 935                 }
 936             }
 937             x_v00 = bestx;
 938             y_v00 = besty;
 939         }
 940
 941         memcpy(&fbdiff, &fb, sizeof(fblock_t));
 942         getregion(&fbold_v00, s->oldpic, bx*16+x_v00/2, by*16+y_v00/2, s->linex);
 943         yuvdiff(&fbdiff, &fbold_v00);
 944         dodctandquant(&fbdiff, &b_v00, 0, *quant);
 945         //quantize(&fbdiff, &b_v00, 0, *quant);
 946         getblockpatterns(&b_v00, &y, &c, 0);
 947
 948         bits_v00 = 1; //cod
 949         bits_v00 += mcbpc_inter[0*4+c].len;
 950         bits_v00 += cbpy[y^15].len;
 951         bits_v00 += mvd[mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 0)].len; // (0,0)
 952         bits_v00 += mvd[mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 1)].len;
 953         bits_v00 += coefbits8x8(b_v00.y1, 0);
 954         bits_v00 += coefbits8x8(b_v00.y2, 0);
 955         bits_v00 += coefbits8x8(b_v00.y3, 0);
 956         bits_v00 += coefbits8x8(b_v00.y4, 0);
 957         bits_v00 += coefbits8x8(b_v00.u, 0);
 958         bits_v00 += coefbits8x8(b_v00.v, 0);
 959     }
 960
 961     if(bits_i > bits_v00)
 962     {
 963         /* mvd (0,0) block (mode=0) */
 964         int t;
 965         mode = 0; // mvd w/o mvd24
 966         has_dc = 0;
 967         memcpy(&b, &b_v00, sizeof(block_t));
 968
 969         getblockpatterns(&b, &cbpybits, &cbpcbits, has_dc);
 970         swf_SetBits(tag,0,1); // COD
 971         codehuffman(tag, mcbpc_inter, mode*4+cbpcbits);
 972         codehuffman(tag, cbpy, cbpybits^15);
 973
 974         /* vector */
 975         codehuffman(tag, mvd, mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 0));
 976         codehuffman(tag, mvd, mvd2index(predictmvdx, predictmvdy, x_v00, y_v00, 1));
 977         s->mvdx[by*s->bbx+bx] = x_v00;
 978         s->mvdy[by*s->bbx+bx] = y_v00;
 979
 980         /* luminance */
 981         encode8x8(tag, b.y1, has_dc, cbpybits&8);
 982         encode8x8(tag, b.y2, has_dc, cbpybits&4);
 983         encode8x8(tag, b.y3, has_dc, cbpybits&2);
 984         encode8x8(tag, b.y4, has_dc, cbpybits&1);
 985
 986         /* chrominance */
 987         encode8x8(tag, b.u, has_dc, cbpcbits&2);
 988         encode8x8(tag, b.v, has_dc, cbpcbits&1);
 989
 990         /* -- reconstruction -- */
 991         dequantize(&b, 0, *quant);
 992         doidct(&b);
 993         for(t=0;t<64;t++) {
 994             b.y1[t] = truncate256(b.y1[t] + (int)fbold_v00.y1[t]);
 995             b.y2[t] = truncate256(b.y2[t] + (int)fbold_v00.y2[t]);
 996             b.y3[t] = truncate256(b.y3[t] + (int)fbold_v00.y3[t]);
 997             b.y4[t] = truncate256(b.y4[t] + (int)fbold_v00.y4[t]);
 998             b.u[t] = truncate256(b.u[t] + (int)fbold_v00.u[t]);
 999             b.v[t] = truncate256(b.v[t] + (int)fbold_v00.v[t]);
1000         }
1001         copyblock(s, s->current, &b, bx, by);
1002         return bits_v00;
1003     } else {
1004         /* i block (mode=3) */
1005         mode = 3;
1006         has_dc = 1;
1007         memcpy(&b, &b_i, sizeof(block_t));
1008         getblockpatterns(&b, &cbpybits, &cbpcbits, has_dc);
1009         swf_SetBits(tag,0,1); // COD
1010         codehuffman(tag, mcbpc_inter, mode*4+cbpcbits);
1011         codehuffman(tag, cbpy, cbpybits);
1012
1013         /* luminance */
1014         encode8x8(tag, b.y1, has_dc, cbpybits&8);
1015         encode8x8(tag, b.y2, has_dc, cbpybits&4);
1016         encode8x8(tag, b.y3, has_dc, cbpybits&2);
1017         encode8x8(tag, b.y4, has_dc, cbpybits&1);
1018
1019         /* chrominance */
1020         encode8x8(tag, b.u, has_dc, cbpcbits&2);
1021         encode8x8(tag, b.v, has_dc, cbpcbits&1);
1022
1023         /* -- reconstruction -- */
1024         dequantize(&b, 1, *quant);
1025         doidct(&b);
1026         truncateblock(&b);
1027         copyblock(s, s->current, &b, bx, by);
1028         return bits_i;
1029     }
1030
1031     exit(1);
1032 #if 0
1033     dodct(&fb);
1034     quantize(&fb, &b, has_dc, *quant);
1035     getblockpatterns(&b, &cbpybits, &cbpcbits, has_dc);
1036
1037     if(!dquant && has_mvd && !has_mvd24 && !has_dc) mode = 0;
1038     else if(dquant && has_mvd && !has_mvd24 && !has_dc) mode = 1;
1039     else if(!dquant && has_mvd && has_mvd24 && !has_dc) mode = 2;
1040     else if(!dquant && !has_mvd && !has_mvd24 && has_dc) mode = 3;
1041     else if(dquant && !has_mvd && !has_mvd24 && has_dc) mode = 4;
1042     else exit(1);
1043
1044     swf_SetBits(tag,0,1); /* cod - 1 if we're not going to code this block*/
1045
1046     codehuffman(tag, mcbpc_inter, mode*4+cbpcbits);
1047     codehuffman(tag, cbpy, (mode==3 || mode==4)?cbpybits:cbpybits^15);
1048
1049     if(dquant) {
1050         setQuant(tag, dquant);
1051     }
1052
1053     if(has_mvd) {
1054         /* 0,0 */
1055         codehuffman(tag, mvd, 32);
1056         codehuffman(tag, mvd, 32);
1057     }
1058     if(has_mvd24) {
1059     }
1060
1061     /* luminance */
1062     encode8x8(tag, b.y1, has_dc, cbpybits&8);
1063     encode8x8(tag, b.y2, has_dc, cbpybits&4);
1064     encode8x8(tag, b.y3, has_dc, cbpybits&2);
1065     encode8x8(tag, b.y4, has_dc, cbpybits&1);
1066
1067     /* chrominance */
1068     encode8x8(tag, b.u, has_dc, cbpcbits&2);
1069     encode8x8(tag, b.v, has_dc, cbpcbits&1);
1070 #endif
1071 }
1072
1073 #define TYPE_IFRAME 0
1074 #define TYPE_PFRAME 1
1075
1076 static void writeHeader(TAG*tag, int width, int height, int frame, int quant, int type)
1077 {
1078     U32 i32;
1079     swf_SetU16(tag, frame);
1080     swf_SetBits(tag, 1, 17); /* picture start code*/
1081     swf_SetBits(tag, 0, 5); /* version=0, version 1 would optimize rle behaviour*/
1082     swf_SetBits(tag, frame, 8); /* time reference */
1083
1084     /* write dimensions, taking advantage of some predefined sizes
1085        if the opportunity presents itself */
1086     i32 = width<<16|height;
1087     switch(i32)
1088     {
1089         case 352<<16|288: swf_SetBits(tag, 2, 3);break;
1090         case 176<<16|144: swf_SetBits(tag, 3, 3);break;
1091         case 128<<16|96: swf_SetBits(tag, 4, 3);break;
1092         case 320<<16|240: swf_SetBits(tag, 5, 3);break;
1093         case 160<<16|120: swf_SetBits(tag, 6, 3);break;
1094         default:
1095             if(width>255 || height>255) {
1096                 swf_SetBits(tag, 1, 3);
1097                 swf_SetBits(tag, width, 16);
1098                 swf_SetBits(tag, height, 16);
1099             } else {
1100                 swf_SetBits(tag, 0, 3);
1101                 swf_SetBits(tag, width, 8);
1102                 swf_SetBits(tag, height, 8);
1103             }
1104     }
1105
1106     swf_SetBits(tag, type, 2); /* I-Frame or P-Frame */
1107     swf_SetBits(tag, 0, 1); /* No deblock filter */
1108     assert(quant>0);
1109     swf_SetBits(tag, quant, 5); /* quantizer (1-31), may be updated later on*/
1110     swf_SetBits(tag, 0, 1); /* No extra info */
1111 }
1112
1113 int stat_qdiff(double*b1, double*b2)
1114 {
1115     int x;
1116     double diff=0;
1117     for(x=0;x<64;x++) {
1118         double y1 = b1[x] - b2[x];
1119         diff += y1*y1;
1120     }
1121     return (int)(diff/64);
1122 }
1123
1124 int stat_absdiff(double*b1, double*b2)
1125 {
1126     int x;
1127     double diff=0;
1128     for(x=0;x<64;x++) {
1129         double y1 = b1[x] - b2[x];
1130         diff += fabs(y1);
1131     }
1132     return (int)(diff/64);
1133 }
1134
1135 int stat_absfreq(double*b1, double*b2)
1136 {
1137     int x;
1138     double diff=0;
1139     double d1[64],d2[64];
1140     memcpy(&d1, b1, 64*sizeof(double));
1141     dct(d1);
1142     memcpy(&d2, b2, 64*sizeof(double));
1143     dct(d2);
1144     for(x=0;x<64;x++) {
1145         double y1 = d1[x] - d2[x];
1146         diff += fabs(y1);
1147     }
1148     return (int)(diff/64);
1149 }
1150
1151 int stat_qfreq(double*b1, double*b2)
1152 {
1153     int x;
1154     double diff=0;
1155     double d1[64],d2[64];
1156     memcpy(&d1, b1, 64*sizeof(double));
1157     dct(d1);
1158     memcpy(&d2, b2, 64*sizeof(double));
1159     dct(d2);
1160     for(x=0;x<64;x++) {
1161         double y1 = d1[x] - d2[x];
1162         diff += y1*y1;
1163     }
1164     return (int)(diff/64);
1165 }
1166
1167 int stat_nonnull(double*b1, double*b2)
1168 {
1169     int x;
1170     int diff=0;
1171     double d1[64],d2[64];
1172     memcpy(&d1, b1, 64*sizeof(double));
1173     dct(d1);
1174     memcpy(&d2, b2, 64*sizeof(double));
1175     dct(d2);
1176     for(x=0;x<64;x++) {
1177         int y1 = (int)((d1[x] - d2[x])/9);
1178         if(y1)
1179             diff++;
1180     }
1181     return diff;
1182 }
1183
1184 void stat_filter(FILE*fi, double*d1, double*d2)
1185 {
1186     int x,y,xx,yy,b;
1187     for(b=3;b>=0;b--) {
1188         int d = 1<<b;
1189         double diff=0;
1190         for(x=0;x<8;x+=d)
1191         for(y=0;y<8;y+=d)
1192         {
1193             double add1=0,add2=0;
1194             for(xx=x;xx<x+d;xx++)
1195             for(yy=y;yy<y+d;yy++)
1196             {
1197                 add1 += d1[yy*8+xx];
1198                 add2 += d2[yy*8+xx];
1199             }
1200             diff += fabs(add1-add2);
1201         }
1202         fprintf(fi, "\t%d",(int)(diff/64));
1203     }
1204 }
1205
1206 void qstat_filter(FILE*fi, double*d1, double*d2)
1207 {
1208     int x,y,xx,yy,b;
1209     for(b=3;b>=0;b--) {
1210         int d = 1<<b;
1211         double diff=0;
1212         for(x=0;x<8;x+=d)
1213         for(y=0;y<8;y+=d)
1214         {
1215             double add1=0,add2=0;
1216             for(xx=x;xx<x+d;xx++)
1217             for(yy=y;yy<y+d;yy++)
1218             {
1219                 add1 += d1[yy*8+xx];
1220                 add2 += d2[yy*8+xx];
1221             }
1222             diff += (add1-add2)*(add1-add2);
1223         }
1224         fprintf(fi, "\t%d",(int)(diff/64));
1225     }
1226 }
1227
1228 void qqstat_filter(FILE*fi, double*d1, double*d2)
1229 {
1230     int x,y,xx,yy,b;
1231     for(b=3;b>=0;b--) {
1232         int d = 1<<b;
1233         double diff=0;
1234         for(x=0;x<8;x+=d)
1235         for(y=0;y<8;y+=d)
1236         {
1237             double add1=0,add2=0;
1238             for(xx=x;xx<x+d;xx++)
1239             for(yy=y;yy<y+d;yy++)
1240             {
1241                 add1 += d1[yy*8+xx]*d1[yy*8+xx];
1242                 add2 += d2[yy*8+xx]*d2[yy*8+xx];
1243             }
1244             diff += fabs(add1-add2);
1245         }
1246         fprintf(fi, "\t%d",(int)(diff/64));
1247     }
1248 }
1249
1250 void stat(FILE*fi, int*vals, double*yold, double*ynew)
1251 {
1252     int t;
1253     int bits = coefbits8x8(vals, 0);
1254     fprintf(fi, "%d\t%d\t%d\t%d\t%d\t%d", bits,
1255              stat_nonnull(ynew, yold),
1256              stat_qdiff(ynew,yold),
1257              stat_absdiff(ynew,yold),
1258              stat_absfreq(ynew,yold),
1259              stat_qfreq(ynew,yold));
1260     stat_filter(fi, ynew, yold);
1261     qqstat_filter(fi, ynew, yold);
1262     fprintf(fi, "\n");
1263 }
1264
1265 void dostat(VIDEOSTREAM*s)
1266 {
1267     int bx,by,bx2,by2;
1268     int quant = 9;
1269     int num = 0;
1270     FILE*fi = fopen("mvd.dat", "wb");
1271     fprintf(fi, "bits\tnonnull\tqdiff\tabsdiff\tabsfreq\tqfreq\tf1\tf2\tf4\tf8\tqf1\tqf2\tqf4\tqf8\n");
1272     for(by=0;by<s->bby;by++)
1273     for(bx=0;bx<s->bbx;bx++)
1274     {
1275         for(by2=0;by2<s->bby;by2++)
1276         for(bx2=0;bx2<bx;bx2++)
1277         {
1278             fblock_t fbnew,fbdiff,fbold;
1279             block_t b;
1280             int t, y,c,bits;
1281             getregion(&fbnew, s->current, bx*16, by*16, s->linex);
1282             memcpy(&fbdiff, &fbnew, sizeof(fblock_t));
1283             getregion(&fbold, s->current, bx2*16, by2*16, s->linex);
1284             yuvdiff(&fbdiff, &fbold);
1285             dodctandquant(&fbdiff, &b, 0, quant);
1286             //quantize(&fbdiff, &b, 0, quant);
1287
1288             stat(fi, b.y1, fbnew.y1, fbold.y1);
1289             stat(fi, b.y2, fbnew.y2, fbold.y2);
1290             stat(fi, b.y3, fbnew.y3, fbold.y3);
1291             stat(fi, b.y4, fbnew.y4, fbold.y4);
1292             stat(fi, b.u, fbnew.u, fbold.u);
1293             stat(fi, b.v, fbnew.v, fbold.v);
1294
1295             num++;
1296             if(num==1000) {
1297                 fclose(fi);
1298                 exit(7);
1299             }
1300         }
1301         printf("%d\n", num);fflush(stdout);
1302     }
1303     fclose(fi);
1304     exit(7);
1305 }
1306
1307 void swf_SetVideoStreamIFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant)
1308 {
1309     int bx, by;
1310
1311     if(quant<1) quant=1;
1312     if(quant>31) quant=31;
1313
1314     writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_IFRAME);
1315
1316     rgb2yuv(s->current, pic, s->linex, s->olinex, s->width, s->height);
1317
1318     //dostat(s);
1319
1320     for(by=0;by<s->bby;by++)
1321     {
1322         for(bx=0;bx<s->bbx;bx++)
1323         {
1324             encode_blockI(tag, s, bx, by, &quant);
1325         }
1326     }
1327     s->frame++;
1328     memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV));
1329 }
1330
1331 void swf_SetVideoStreamPFrame(TAG*tag, VIDEOSTREAM*s, RGBA*pic, int quant)
1332 {
1333     int bx, by;
1334
1335     if(quant<1) quant=1;
1336     if(quant>31) quant=31;
1337
1338     writeHeader(tag, s->width, s->height, s->frame, quant, TYPE_PFRAME);
1339
1340     rgb2yuv(s->current, pic, s->linex, s->olinex, s->width, s->height);
1341     memset(s->mvdx, 0, s->bbx*s->bby*sizeof(int));
1342     memset(s->mvdy, 0, s->bbx*s->bby*sizeof(int));
1343
1344     for(by=0;by<s->bby;by++)
1345     {
1346         for(bx=0;bx<s->bbx;bx++)
1347         {
1348             encode_blockP(tag, s, bx, by, &quant);
1349         }
1350     }
1351     s->frame++;
1352     memcpy(s->oldpic, s->current, s->width*s->height*sizeof(YUV));
1353 #ifdef MAIN
1354     {
1355         int t;
1356         FILE*fi = fopen("test.ppm", "wb");
1357         yuv2rgb(pic, s->current, s->linex, s->width, s->height);
1358         fprintf(fi, "P6\n%d %d\n255\n", s->width, s->height);
1359         for(t=0;t<s->width*s->height;t++)
1360         {
1361             fwrite(&pic[t].r, 1, 1, fi);
1362             fwrite(&pic[t].g, 1, 1, fi);
1363             fwrite(&pic[t].b, 1, 1, fi);
1364         }
1365         fclose(fi);
1366     }
1367 #endif
1368 }
1369
1370 #ifdef MAIN
1371 #include "png.h"
1372 int main(int argn, char*argv[])
1373 {
1374     int fi;
1375     int t;
1376     SWF swf;
1377     TAG * tag;
1378     RGBA* pic, *pic2, rgb;
1379     SWFPLACEOBJECT obj;
1380     int width = 0;
1381     int height = 0;
1382     int frames = 50;
1383     int framerate = 29;
1384     unsigned char*data;
1385     char* fname = "/home/kramm/pics/peppers.png";
1386     VIDEOSTREAM stream;
1387     double d = 1.0;
1388
1389     memset(&stream, 0, sizeof(stream));
1390
1391     getPNG(fname, &width, &height, &data);
1392     pic = (RGBA*)malloc(width*height*sizeof(RGBA));
1393     pic2 = (RGBA*)malloc(width*height*sizeof(RGBA));
1394     memcpy(pic, data, width*height*sizeof(RGBA));
1395     free(data);
1396
1397     printf("Compressing %s, size %dx%d\n", fname, width, height);
1398
1399     memset(&swf,0,sizeof(SWF));
1400     memset(&obj,0,sizeof(obj));
1401
1402     swf.fileVersion    = 6;
1403     swf.frameRate      = framerate*256;
1404     swf.movieSize.xmax = 20*width;
1405     swf.movieSize.ymax = 20*height;
1406
1407     swf.firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
1408     tag = swf.firstTag;
1409     rgb.r = 0x00;rgb.g = 0x00;rgb.b = 0x00;
1410     swf_SetRGB(tag,&rgb);
1411
1412     tag = swf_InsertTag(tag, ST_DEFINEVIDEOSTREAM);
1413     swf_SetU16(tag, 33);
1414     swf_SetVideoStreamDefine(tag, &stream, frames, width, height);
1415     stream.do_motion = 1;
1416
1417     for(t=0;t<frames;t++)
1418     {
1419         int x,y;
1420         double xx,yy;
1421         for(y=0,yy=0;y<height;y++,yy+=d)  {
1422             RGBA*line = &pic[((int)yy)*width];
1423             for(x=0,xx=0;x<width;x++,xx+=d) {
1424                 pic2[y*width+x] = line[((int)xx)];
1425             }
1426         }
1427         printf("frame:%d\n", t);fflush(stdout);
1428
1429         tag = swf_InsertTag(tag, ST_VIDEOFRAME);
1430         swf_SetU16(tag, 33);
1431         if(t==0)
1432             swf_SetVideoStreamIFrame(tag, &stream, pic2, 9);
1433         else
1434             swf_SetVideoStreamPFrame(tag, &stream, pic2, 9);
1435
1436         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
1437         swf_GetPlaceObject(0, &obj);
1438         if(t==0) {
1439             obj.depth = 1;
1440             obj.id = 33;
1441         } else {
1442             obj.move = 1;
1443             obj.depth = 1;
1444             obj.ratio = t;
1445         }
1446         swf_SetPlaceObject(tag,&obj);
1447
1448         tag = swf_InsertTag(tag, ST_SHOWFRAME);
1449         d-=0.005;
1450     }
1451
1452     swf_VideoStreamClear(&stream);
1453
1454     tag = swf_InsertTag(tag, ST_END);
1455
1456     fi = open("video3.swf", O_WRONLY|O_CREAT|O_TRUNC, 0644);
1457     if(swf_WriteSWC(fi,&swf)<0) {
1458         fprintf(stderr,"WriteSWF() failed.\n");
1459     }
1460     close(fi);
1461     swf_FreeTags(&swf);
1462 }
1463 #undef MAIN
1464 #endif