avi2swf/v2swf.c

   1 /*  v2swf.c
   2     part of swftools
   3
   4     Copyright (C) 2003 Matthias Kramm <kramm@quiss.org>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include "v2swf.h"
  24 #include "../lib/rfxswf.h"
  25 #include "../lib/q.h"
  26
  27 typedef struct _v2swf_internal_t
  28 {
  29     TAG*tag;
  30
  31     int filesize;
  32     int headersize;
  33     int frames;
  34
  35     int myframes;
  36
  37     struct writer_t out;
  38     struct writer_t out2;
  39
  40     ringbuffer_t r;
  41     videoreader_t* video;
  42
  43     int width;
  44     int height;
  45
  46     int video_eof;
  47     int audio_eof;
  48
  49     unsigned char* vrbuffer;
  50     unsigned char* buffer;
  51     unsigned char* lastbitmap;
  52
  53     int id;
  54     int lastid;
  55
  56     int quality;
  57     int blockdiff;
  58     int keyframe_interval;
  59     int diffmode;
  60
  61     float framerate;
  62     float fpsratio;
  63     float fpspos;
  64
  65     int bitrate;
  66     int samplerate;
  67
  68     int finished;
  69     int keyframe;
  70     int showframe;
  71
  72     float samplepos;
  73     float framesamplepos;
  74     int samplewritepos;
  75     double soundframepos;
  76     int soundstreamhead;
  77     int seek;
  78
  79     double audio_fix;
  80     int fixheader;
  81     int prescale;
  82
  83     int scale;
  84
  85     int domotion;
  86
  87     int head_done;
  88
  89     int version;
  90
  91     VIDEOSTREAM stream;
  92
  93 } v2swf_internal_t;
  94
  95 static int verbose = 0;
  96 static int filelog = 0;
  97
  98 static void msg(char*format, ...)
  99 {
 100     char buf[1024];
 101     int l;
 102     va_list arglist;
 103     if(!verbose)
 104         return;
 105     va_start(arglist, format);
 106     vsprintf(buf, format, arglist);
 107     va_end(arglist);
 108     l = strlen(buf);
 109     while(l && buf[l-1]=='\n') {
 110         buf[l-1] = 0;
 111         l--;
 112     }
 113     if(filelog)
 114     {
 115         FILE*fi = fopen("debug.log", "ab+");
 116         fprintf(fi, "(v2swf) %s\n", buf);
 117         fflush(fi);
 118         fclose(fi);
 119     }
 120
 121     printf("(v2swf) %s\n", buf);
 122     fflush(stdout);
 123 }
 124
 125 extern int swf_mp3_in_samplerate;
 126 extern int swf_mp3_out_samplerate;
 127 extern int swf_mp3_channels;
 128 extern int swf_mp3_bitrate;
 129
 130
 131 static void writeShape(v2swf_internal_t*i, int id, int gfxid, int width, int height)
 132 {
 133     RGBA rgb;
 134     MATRIX m;
 135     SHAPE*shape;
 136     SRECT r;
 137     int lines = 0;
 138     int ls,fs;
 139     swf_ResetTag(i->tag, ST_DEFINESHAPE);
 140     swf_ShapeNew(&shape);
 141     rgb.b = rgb.g = rgb.r = 0xff;
 142     if(lines)
 143         ls = swf_ShapeAddLineStyle(shape,20,&rgb);
 144     swf_GetMatrix(NULL,&m);
 145     m.sx = 20*65536;
 146     m.sy = 20*65536;
 147
 148     fs = swf_ShapeAddBitmapFillStyle(shape,&m,gfxid,0);
 149     swf_SetU16(i->tag,id);   // ID
 150     r.xmin = 0;
 151     r.ymin = 0;
 152     r.xmax = width*20;
 153     r.ymax = height*20;
 154     swf_SetRect(i->tag,&r);
 155
 156     swf_SetShapeStyles(i->tag,shape);
 157     swf_ShapeCountBits(shape,NULL,NULL);
 158     swf_SetShapeBits(i->tag,shape);
 159
 160     swf_ShapeSetAll(i->tag,shape,0,0,lines?ls:0,fs,0);
 161
 162     swf_ShapeSetLine(i->tag,shape,width*20,0);
 163     swf_ShapeSetLine(i->tag,shape,0,height*20);
 164     swf_ShapeSetLine(i->tag,shape,-width*20,0);
 165     swf_ShapeSetLine(i->tag,shape,0,-height*20);
 166     swf_ShapeSetEnd(i->tag);
 167     i->filesize += swf_WriteTag2(&i->out, i->tag);
 168     swf_ShapeFree(shape);
 169 }
 170
 171 /* returns 0 on partial read */
 172 static int getSamples(videoreader_t*video, S16*data, int len, double speedup)
 173 {
 174     double pos = 0;
 175     double ratio = (double) video->samplerate * speedup / swf_mp3_in_samplerate;
 176     int rlen = (int)(len * ratio);
 177     int t;
 178     S16 tmp[576*32];
 179     int r = /*resampled len */ rlen *
 180                   /* s16_le */ 2 *
 181                                video->channels;
 182     int l;
 183     memset(tmp, 0, sizeof(tmp));
 184     l = videoreader_getsamples(video, tmp, r);
 185     if(l <= 0) {
 186         return 0;
 187     }
 188     msg("%d samples read", l);
 189
 190     /* convert to 1 channel */
 191     for(t=0;t<rlen;t++) {
 192         int s;
 193         int a=0;
 194         for(s=0;s<video->channels;s++)
 195             a += tmp[t*video->channels+s];
 196         tmp[t] = a/video->channels;
 197     }
 198
 199     /* down/up-sample to the desired input samplerate (swf_mp3_in_samplerate) */
 200     for(t=0;t<len;t++) {
 201         data[t] = tmp[(int)pos];
 202         pos+=ratio;
 203     }
 204     return l == r;
 205 }
 206
 207 static void writeAudioForOneFrame(v2swf_internal_t* i)
 208 {
 209     int blocksize;
 210     double blockspersecond;
 211     double framespersecond, framesperblock, samplesperframe, samplesperblock;
 212     int seek;
 213     int s;
 214     double speedup = i->audio_fix;
 215     int num = 0;
 216     int pos = 0;
 217     S16 block1[576*4 * 2];
 218
 219     msg("writeAudioForOneFrame()");
 220
 221     if(i->audio_eof || i->video->channels<=0 || i->video->samplerate<=0) {
 222         i->audio_eof = 1;
 223         return; /* no sound in video */
 224     }
 225
 226     blocksize = (i->samplerate > 22050) ? 1152 : 576;
 227     blockspersecond = ((double)i->samplerate)/blocksize;
 228
 229     /* notice: for framerates greater than about 35, audio starts getting choppy. */
 230     framespersecond = i->framerate;
 231
 232     framesperblock = framespersecond / blockspersecond;
 233     samplesperframe = (blocksize * blockspersecond) / framespersecond; /* 11khz-samples per frame */
 234     samplesperblock = samplesperframe * framesperblock;
 235
 236     msg("samplesperblock: %f", samplesperblock);
 237
 238     if(!i->soundstreamhead) {
 239         swf_mp3_out_samplerate = i->samplerate;
 240         /* The pre-processing of sound samples in getSamples(..) above
 241            re-samples the sound to swf_mp3_in_samplerate. It is best to
 242            simply make it the original samplerate:  */
 243         swf_mp3_in_samplerate = i->video->samplerate;
 244
 245         /* first run - initialize */
 246         swf_mp3_channels = 1;//i->video->channels;
 247         swf_mp3_bitrate = i->bitrate;
 248         swf_ResetTag(i->tag, ST_SOUNDSTREAMHEAD);
 249         /* samplesperframe overrides the movie framerate: */
 250         msg("swf_SetSoundStreamHead(): %08x %d", i->tag, samplesperframe);
 251         swf_SetSoundStreamHead(i->tag, samplesperframe);
 252         msg("swf_SetSoundStreamHead() done");
 253         i->filesize += swf_WriteTag2(&i->out, i->tag);
 254         i->soundstreamhead = 1;
 255     }
 256
 257     /* for framerates greater than 19.14, every now and then a frame
 258        hasn't a soundstreamblock. Determine whether this is the case.
 259     */
 260     msg("SOUND: frame:%d soundframepos:%f samplewritepos:%d samplepos:%f\n", i->frames, i->soundframepos, i->samplewritepos, i->samplepos);
 261     if(i->frames < i->soundframepos) {
 262         msg("SOUND: block skipped\n");
 263         i->samplepos += samplesperframe;
 264         return;
 265     }
 266
 267     seek = i->seek;
 268
 269     //while(i->samplewritepos + num * blocksize < i->samplepos + blocksize) {
 270     do {
 271         i->samplewritepos += blocksize;
 272         i->soundframepos += framesperblock;
 273         num++;
 274     }
 275     while(i->samplewritepos < i->samplepos);
 276
 277     msg("SOUND: number of blocks: %d", num);
 278
 279     /* write num frames, max 1 block */
 280     for(pos=0;pos<num;pos++) {
 281         if(!getSamples(i->video, block1, blocksize * (double)swf_mp3_in_samplerate/swf_mp3_out_samplerate, speedup)) {
 282             i->audio_eof = 1; i->video->samplerate = i->video->channels = 0; //end of soundtrack
 283             /* fall through, this probably was a partial read. (We did, after all,
 284                come to this point, so i->audio_eof must have been false so far) */
 285         }
 286         if(!pos) {
 287             swf_ResetTag(i->tag, ST_SOUNDSTREAMBLOCK);
 288             swf_SetSoundStreamBlock(i->tag, block1, seek, num);
 289         } else {
 290             swf_SetSoundStreamBlock(i->tag, block1, seek, 0);
 291         }
 292     }
 293     i->filesize += swf_WriteTag2(&i->out, i->tag);
 294
 295     i->seek = blocksize - (i->samplewritepos - i->samplepos);
 296     i->samplepos += samplesperframe;
 297 }
 298
 299 static void writeShowFrame(v2swf_internal_t* i)
 300 {
 301     do {
 302         writeAudioForOneFrame(i);
 303
 304         swf_ResetTag(i->tag, ST_SHOWFRAME);
 305         i->filesize += swf_WriteTag2(&i->out, i->tag);
 306
 307         i->fpspos -= 1.0;
 308         i->frames ++;
 309     }
 310     while(i->fpspos >= 1.0);
 311     i->showframe = 0;
 312 }
 313
 314 static void writeShowTags(v2swf_internal_t* i, int shapeid, int bmid, int width, int height)
 315 {
 316     writeShape(i, shapeid, bmid, width, height);
 317
 318     swf_ResetTag(i->tag, ST_PLACEOBJECT2);
 319     if(!i->prescale) {
 320         MATRIX m;
 321         swf_GetMatrix(0, &m);
 322         m.sx = m.sy = i->scale;
 323         swf_ObjectPlace(i->tag,shapeid,shapeid,&m,0,0);
 324     } else {
 325         swf_ObjectPlace(i->tag,shapeid,shapeid,0,0,0);
 326     }
 327     i->filesize += swf_WriteTag2(&i->out, i->tag);
 328
 329     i->showframe = 1;
 330 }
 331
 332 static int wwrite(struct writer_t*w, void*data, int len)
 333 {
 334     v2swf_internal_t* i = (v2swf_internal_t*)w->internal;
 335     ringbuffer_put(&i->r, data, len);
 336     return len;
 337 }
 338
 339 static void wfinish(struct writer_t*w)
 340 {
 341     v2swf_internal_t* i = (v2swf_internal_t*)w->internal;
 342 }
 343
 344 static void writehead(v2swf_internal_t*i)
 345 {
 346     char header[]="FWS\6\0\0\0\4";
 347     SWF swf;
 348     int ret;
 349     int id;
 350
 351     header[3] = i->version;
 352     if(i->version >= 6) { //MX
 353         header[0] = 'C';
 354
 355         i->out2.write = wwrite;
 356         i->out2.finish = wfinish;
 357         i->out2.internal = i;
 358         i->out2.type = 77;
 359         i->out2.bitpos = 0;
 360         i->out2.mybyte = 0;
 361         i->out2.pos = 0;
 362         writer_init_zlibdeflate(&i->out, &i->out2);
 363     } else {
 364         i->out.write = wwrite;
 365         i->out.finish = wfinish;
 366         i->out.internal = i;
 367         i->out.type = 77;
 368         i->out.bitpos = 0;
 369         i->out.mybyte = 0;
 370         i->out.pos = 0;
 371         i->out2 = i->out;
 372     }
 373
 374     if(i->prescale) {
 375         i->width = (int)(i->video->width*(i->scale/65536.0));
 376         i->height = (int)(i->video->height*(i->scale/65536.0));
 377     } else {
 378         i->width = i->video->width;
 379         i->height = i->video->height;
 380     }
 381     if(!i->width)
 382         i->width = 1;
 383     if(!i->height)
 384         i->height = 1;
 385     i->buffer = (unsigned char*)malloc(i->width*i->height*4);
 386     i->vrbuffer = (unsigned char*)malloc(i->video->width*i->video->height*4);
 387
 388     memset(&swf, 0, sizeof(SWF));
 389     swf.fileVersion=i->version;
 390     swf.fileSize = 0;
 391     swf.frameCount = 65535;
 392     swf.movieSize.xmax=i->width*20;
 393     swf.movieSize.ymax=i->height*20;
 394     swf.compressed = 8; /* 8 = compression done by caller (us) */
 395     swf.frameRate = (int)(i->framerate*0x100);//25*0x100;
 396
 397     /* write the first 8 bytes to out */
 398     i->out2.write(&i->out2, header, 8);
 399
 400     i->filesize += swf_WriteHeader2(&i->out, &swf);
 401     i->headersize = i->filesize;
 402
 403     i->tag = swf_InsertTag(NULL,  ST_SETBACKGROUNDCOLOR);
 404     swf_SetU8(i->tag, 0); //black
 405     swf_SetU8(i->tag, 0);
 406     swf_SetU8(i->tag, 0);
 407     i->filesize += swf_WriteTag2(&i->out, i->tag);
 408 }
 409
 410 static void finish(v2swf_internal_t*i)
 411 {
 412     msg("finish(): i->finished=%d\n", i->finished);
 413     if(!i->finished) {
 414         msg("write endtag\n", i->finished);
 415
 416         swf_ResetTag(i->tag, ST_END);
 417         i->filesize += swf_WriteTag2(&i->out, i->tag);
 418         i->out.finish(&i->out);
 419
 420         if(i->version>=6) {
 421             swf_VideoStreamClear(&i->stream);
 422         }
 423         if(i->buffer)  {
 424             free(i->buffer);i->buffer = 0;
 425         }
 426         if(i->vrbuffer)  {
 427             free(i->vrbuffer);i->vrbuffer = 0;
 428         }
 429         if(i->lastbitmap)  {
 430             free(i->lastbitmap);i->lastbitmap = 0;
 431         }
 432
 433         /* FIXME: we shouldn't be doing this. the caller should */
 434         msg("call videoreader_close(%08x)\n", i->video);
 435         videoreader_close(i->video);
 436
 437         i->finished = 1;
 438     }
 439     msg("finishing done\n");
 440 }
 441 static void cleanup(v2swf_internal_t*i)
 442 {
 443     int t;
 444     for(t=i->lastid;t<i->id;t++) {
 445         if(!(t&1)) {
 446             swf_ResetTag(i->tag, ST_REMOVEOBJECT2);
 447             swf_SetU16(i->tag, t);
 448             i->filesize += swf_WriteTag2(&i->out, i->tag);
 449         }
 450         swf_ResetTag(i->tag, ST_FREECHARACTER);
 451         swf_SetU16(i->tag, t);
 452         i->filesize += swf_WriteTag2(&i->out, i->tag);
 453     }
 454     i->lastid = i->id;
 455 }
 456
 457 #define DIFFMODE_MAX 1
 458 #define DIFFMODE_MEAN 2
 459 #define DIFFMODE_EXACT 3
 460 #define DIFFMODE_QMEAN 4
 461
 462 static int blockdiff_max(U8*d1,U8*d2,int yadd, int maxdiff, int xl, int yl)
 463 {
 464     int x,y;
 465     for(y=0;y<yl;y++) {
 466         for(x=0;x<xl;x++) {
 467             int rd = d1[1] - d2[1];
 468             int gd = d1[2] - d2[2];
 469             int bd = d1[3] - d2[3];
 470             if(rd < 0) rd = -rd;
 471             if(gd < 0) gd = -gd;
 472             if(bd < 0) bd = -bd;
 473             if(rd+gd+bd>maxdiff)
 474                 return 1;
 475
 476             d1+=4; d2+=4;
 477         }
 478         d1 += yadd; d2 += yadd;
 479     }
 480     return 0;
 481 }
 482
 483 static int blockdiff_mean(U8*d1,U8*d2,int yadd, int maxdiff, int xl, int yl)
 484 {
 485     int mean = 0;
 486     int x,y;
 487     for(y=0;y<yl;y++) {
 488         for(x=0;x<xl;x++) {
 489             int rd = d1[1] - d2[1];
 490             int gd = d1[2] - d2[2];
 491             int bd = d1[3] - d2[3];
 492             if(rd < 0) rd = -rd;
 493             if(gd < 0) gd = -gd;
 494             if(bd < 0) bd = -bd;
 495             mean += rd+gd+bd;
 496
 497             d1+=4; d2+=4;
 498         }
 499         d1 += yadd; d2 += yadd;
 500     }
 501     if(mean/(xl*yl) > maxdiff)
 502         return 1;
 503     return 0;
 504 }
 505
 506 static int blockdiff_qmean(U8*d1,U8*d2,int yadd, int maxdiff, int xl, int yl)
 507 {
 508     int mean = 0;
 509     int x,y;
 510     for(y=0;y<yl;y++) {
 511         for(x=0;x<xl;x++) {
 512             int rd = d1[1] - d2[1];
 513             int gd = d1[2] - d2[2];
 514             int bd = d1[3] - d2[3];
 515             int q;
 516             if(rd < 0) rd = -rd;
 517             if(gd < 0) gd = -gd;
 518             if(bd < 0) bd = -bd;
 519             q = rd+gd+bd;
 520             mean += q*q;
 521
 522             d1+=4; d2+=4;
 523         }
 524         d1 += yadd; d2 += yadd;
 525     }
 526     if(mean/(xl*yl) > maxdiff*maxdiff)
 527         return 1;
 528     return 0;
 529 }
 530
 531 static int blockdiff_exact(U8*d1,U8*d2,int yadd, int xl, int yl)
 532 {
 533     int x,y;
 534     for(y=0;y<yl;y++) {
 535         for(x=0;x<xl;x++) {
 536             if((*(U32*)d1^*(U32*)d2)&0xffffff00) { //bits [RGB_] of [RGBA] differ
 537                 return 1;
 538             }
 539             d1+=4; d2+=4;
 540         }
 541         d1 += yadd; d2 += yadd;
 542     }
 543     return 0;
 544 }
 545
 546                 /*U32 r = (*(U32*)d1^-(U32*)d2)&0xffffff00;
 547                 U32 g = ((r << 3) ^ r)&0x80808080;
 548                 if(g)
 549                     goto differ;*/
 550
 551 static void checkInit(v2swf_internal_t*i)
 552 {
 553     if(!i->head_done) {
 554         writehead(i);
 555         if(i->version>=6) {
 556             swf_ResetTag(i->tag,  ST_DEFINEVIDEOSTREAM);
 557             swf_SetU16(i->tag, 99);
 558             swf_SetVideoStreamDefine(i->tag, &i->stream, 65535, i->width, i->height);
 559             i->filesize += swf_WriteTag2(&i->out, i->tag);
 560             if(i->domotion) {
 561                 i->stream.do_motion = 1;
 562             }
 563         }
 564         i->head_done = 1;
 565     }
 566 }
 567
 568 static void scaleimage(v2swf_internal_t*i)
 569 {
 570     int x,y;
 571     int xv,yv;
 572     int xm = (i->video->width*65536)/i->width;
 573     int ym = (i->video->height*65536)/i->height;
 574     msg("scaling from %dx%d to %dx%d\n",
 575             i->video->width, i->video->height,
 576             i->width, i->height
 577             );
 578
 579     memset(i->buffer, 255, i->width*i->height*4);
 580     for(y=0,yv=0;y<i->height;y++,yv+=ym) {
 581         int*src = &((int*)i->vrbuffer)[(yv>>16)*i->video->width];
 582         int*dest = &((int*)i->buffer)[y*i->width];
 583         for(x=0,xv=0;x<i->width;x++,xv+=xm) {
 584             dest[x] = src[xv>>16];
 585         }
 586     }
 587     //memcpy(i->buffer, i->vrbuffer, i->width*i->height*4);
 588 }
 589
 590 static int writeAudioOnly(v2swf_internal_t*i)
 591 {
 592     if(i->showframe) {
 593         i->fpspos += i->fpsratio;
 594         /* skip frames */
 595         if(i->fpspos<1.0) {
 596             return 0;
 597         }
 598         writeShowFrame(i);
 599     }
 600     i->showframe = 1;
 601     return 1;
 602 }
 603
 604 static int encodeoneframe(v2swf_internal_t*i)
 605 {
 606     videoreader_t*video = i->video;
 607     int ret;
 608
 609     checkInit(i);
 610
 611     if(i->video_eof && i->audio_eof) {
 612         if(!i->finished)
 613             finish(i);
 614         return 0;
 615     }
 616
 617     if(!i->audio_eof && i->video_eof) {
 618         return writeAudioOnly(i);
 619     }
 620
 621     if(!videoreader_getimage(i->video, i->vrbuffer))
 622     {
 623         i->video_eof = 1;
 624         msg("videoreader returned eof\n");
 625         if(i->audio_eof) {
 626             finish(i);
 627             return 0;
 628         } else {
 629             return writeAudioOnly(i);
 630         }
 631     }
 632
 633     msg("encoding image for frame %d\n", i->frames);
 634     if(i->showframe) {
 635         i->fpspos += i->fpsratio;
 636         /* skip frames */
 637         if(i->fpspos<1.0) {
 638             return 0;
 639         }
 640         writeShowFrame(i);
 641     }
 642
 643     scaleimage(i);
 644
 645     msg("version is %d\n", i->version);
 646
 647     if(i->version <= 4) {
 648
 649         int bmid = i->id++;
 650         int shapeid = i->id++;
 651         int width2 = i->width * 4;
 652
 653         if(i->id>=4) {
 654             swf_ResetTag(i->tag, ST_REMOVEOBJECT2);
 655             swf_SetU16(i->tag, i->id-3);
 656             i->filesize += swf_WriteTag2(&i->out, i->tag);
 657             swf_ResetTag(i->tag, ST_FREECHARACTER);
 658             swf_SetU16(i->tag, i->id-4);
 659             i->filesize += swf_WriteTag2(&i->out, i->tag);
 660         }
 661
 662         swf_ResetTag(i->tag, ST_DEFINEBITSJPEG2);
 663         swf_SetU16(i->tag, bmid);
 664         swf_SetJPEGBits2(i->tag, i->width, i->height, (RGBA*)i->buffer, i->quality);
 665         i->filesize += swf_WriteTag2(&i->out, i->tag);
 666
 667         writeShowTags(i, shapeid, bmid, i->width, i->height);
 668
 669     } else if(i->version == 5) {
 670         int width2 = i->width * 4;
 671         int width8 = (i->width+7)/8;
 672         int height8 = (i->height+7)/8;
 673
 674         /* the idea is here to only update those jpeg 8x8 blocks
 675            which actually have changed. This means that we have to keep
 676            the bitmap from the last frame for the comparison. */
 677
 678         (i->keyframe)--;
 679         if(!i->lastbitmap || !i->keyframe) {
 680             int t, bmid,shapeid;
 681             cleanup(i);
 682
 683             if(!i->lastbitmap) {
 684                 msg("Creating bitmap buffer for %dx%d (%dx%d), (%dx%d)\n", i->width, i->height, width2, i->height, width8, height8);
 685                 i->lastbitmap = (U8*)malloc(width2*i->height);
 686             }
 687             memcpy(i->lastbitmap, i->buffer, width2*i->height);
 688
 689             i->keyframe = i->keyframe_interval;
 690
 691             bmid = i->id++;
 692             shapeid = i->id++;
 693             width2 = i->width * 4;
 694             swf_ResetTag(i->tag, ST_DEFINEBITSJPEG2);
 695             swf_SetU16(i->tag, bmid);
 696             swf_SetJPEGBits2(i->tag, i->width, i->height, (RGBA*)i->buffer, i->quality);
 697             i->filesize += swf_WriteTag2(&i->out, i->tag);
 698
 699             writeShowTags(i, shapeid, bmid, i->width, i->height);
 700             return 1;
 701         } else {
 702             /* The following looks so ugly because it's somewhat optimized.
 703                What it does is walk through all the 8x8 blocks, find those
 704                which have changed too much and set all others to (R,G,B,A)=(0,0,0,0).
 705                It also set's alpha to 255 in those who haven't changed, and
 706                copies them to lastbitmap.
 707              */
 708
 709             int x8, y8;
 710             //int maxdiff = ((100 - i->quality)*256)/100;
 711             int maxdiff = i->blockdiff*3;
 712             for(y8=0;y8<height8;y8++)
 713             for(x8=0;x8<width8;x8++) {
 714                 int x,y;
 715                 int xl=8,yl=8;
 716                 int yadd;
 717                 U8*d1,*d1b,*d2,*d2b;
 718                 if(x8*8+xl > i->width)
 719                     xl = i->width - x8*8;
 720                 if(y8*8+yl > i->height)
 721                     yl = i->height - y8*8;
 722                 d1 = &i->buffer[width2*y8*8+x8*8*4];
 723                 d1b = d1;
 724                 d2 = &i->lastbitmap[width2*y8*8+x8*8*4];
 725                 d2b = d2;
 726                 yadd = width2 - (xl*4);
 727
 728                 if(i->diffmode == DIFFMODE_MAX) {
 729                     if(blockdiff_max(d1, d2, yadd, maxdiff, xl, yl))
 730                         goto differ;
 731                 } else if(i->diffmode == DIFFMODE_MEAN) {
 732                     if(blockdiff_mean(d1, d2, yadd, maxdiff, xl, yl))
 733                         goto differ;
 734                 } else if(i->diffmode == DIFFMODE_EXACT) {
 735                     if(blockdiff_exact(d1, d2, yadd, xl, yl))
 736                         goto differ;
 737                 } else if(i->diffmode == DIFFMODE_QMEAN) {
 738                     if(blockdiff_qmean(d1, d2, yadd, maxdiff, xl, yl))
 739                         goto differ;
 740                 }
 741
 742                 for(y=0;y<yl;y++) {
 743                     for(x=0;x<xl;x++) {
 744                         *(U32*)d1b = 0;
 745                         d1b+=4;
 746                     }
 747                     d1b += yadd;
 748                 }
 749                 continue;
 750     differ:
 751                 for(y=0;y<yl;y++) {
 752                     for(x=0;x<xl;x++) {
 753                         *(U32*)d2b = *(U32*)d1b;
 754                         d1b[0] = 255;
 755                         d1b+=4;d2b+=4;
 756                     }
 757                     d1b += yadd; d2b += yadd;
 758                 }
 759             }
 760
 761             /* ok, done. Now a) data is zeroed out in regions which haven't changed
 762                              b) lastbitmap equals the bitmap we were called with
 763                              c) data's alpha value is set to 255 in regions which did change */
 764
 765         }
 766
 767         {
 768             int bmid = i->id++;
 769             int shapeid = i->id++;
 770
 771             swf_ResetTag(i->tag, ST_DEFINEBITSJPEG3);
 772             swf_SetU16(i->tag, bmid);
 773             swf_SetJPEGBits3(i->tag, i->width, i->height, (RGBA*)i->buffer, i->quality);
 774             i->filesize += swf_WriteTag2(&i->out, i->tag);
 775
 776             writeShowTags(i, shapeid, bmid, i->width, i->height);
 777         }
 778     } else {
 779         int quant = 1+(30-(30*i->quality)/100);
 780         SWFPLACEOBJECT obj;
 781
 782         swf_GetPlaceObject(0, &obj);
 783         if(!i->prescale) {
 784             obj.matrix.sx = obj.matrix.sy = i->scale;
 785         }
 786
 787         if(i->stream.frame==0) {
 788             obj.depth = 1;
 789             obj.id = 99;
 790         } else {
 791             obj.move = 1;
 792             obj.depth = 1;
 793             obj.ratio = i->stream.frame;
 794         }
 795
 796         swf_ResetTag(i->tag, ST_VIDEOFRAME);
 797         swf_SetU16(i->tag, 99);
 798         if(!(--i->keyframe)) {
 799             msg("setting video I-frame, ratio=%d\n", i->stream.frame);
 800             swf_SetVideoStreamIFrame(i->tag, &i->stream, (RGBA*)i->buffer, quant);
 801             i->keyframe = i->keyframe_interval;
 802         } else {
 803             msg("setting video P-frame, ratio=%d\n", i->stream.frame);
 804             swf_SetVideoStreamPFrame(i->tag, &i->stream, (RGBA*)i->buffer, quant);
 805         }
 806         i->filesize += swf_WriteTag2(&i->out, i->tag);
 807
 808         swf_ResetTag(i->tag, ST_PLACEOBJECT2);
 809         swf_SetPlaceObject(i->tag,&obj);
 810         i->filesize += swf_WriteTag2(&i->out, i->tag);
 811         i->showframe = 1;
 812     }
 813     return 1;
 814 }
 815
 816 int v2swf_init(v2swf_t*v2swf, videoreader_t * video)
 817 {
 818     int ret = 0;
 819     int t=0;
 820     v2swf_internal_t* i;
 821     msg("v2swf_init()\n");
 822     memset(v2swf, 0, sizeof(v2swf_t));
 823     i = (v2swf_internal_t*)malloc(sizeof(v2swf_internal_t));
 824     memset(i, 0, sizeof(v2swf_internal_t));
 825     v2swf->internal = i;
 826
 827     ringbuffer_init(&i->r);
 828
 829     msg("video: %dx%d, fps %f\n", video->width, video->height, video->fps);
 830
 831     i->video = video;
 832     i->blockdiff = 64;
 833     i->keyframe_interval = 8;
 834     i->quality = 20;
 835     i->scale = 65536;
 836     i->samplerate = 11025;
 837     i->prescale = 0;
 838     i->head_done = 0;
 839     i->diffmode = DIFFMODE_QMEAN;
 840     i->audio_fix = 1.0;
 841     i->fixheader = 0;
 842     i->framerate = video->fps;
 843     i->fpsratio = 1.00000000000;
 844     i->fpspos = 0.0;
 845     i->bitrate = 32;
 846     i->version = 6;
 847     i->buffer = 0;
 848     i->lastbitmap = 0;
 849     i->filesize = 8;
 850     i->frames = 0;
 851     i->id = 1;
 852     i->lastid = 1;
 853     i->keyframe = 1;
 854     i->showframe = 0;
 855
 856     memset(&i->out, 0, sizeof(struct writer_t));
 857     memset(&i->out2, 0, sizeof(struct writer_t));
 858
 859     return 0;
 860 }
 861 int v2swf_read(v2swf_t*v2swf, void*buffer, int len)
 862 {
 863     v2swf_internal_t* i;
 864     int l;
 865     msg("v2swf_read(%d)\n", len);
 866     i = (v2swf_internal_t*)v2swf->internal;
 867
 868     while(!i->finished && i->r.available < len) {
 869         if(!encodeoneframe(i)) {
 870             break;
 871         }
 872     }
 873     msg("v2swf_read() done: %d bytes available in ringbuffer\n", i->r.available);
 874     l = ringbuffer_read(&i->r, buffer, len);
 875
 876     return l;
 877 }
 878 void v2swf_close(v2swf_t*v2swf)
 879 {
 880     v2swf_internal_t* i = (v2swf_internal_t*)v2swf->internal;
 881     msg("close(): i->finished=%d\n", i->finished);
 882
 883     /* needed only if aborting: */
 884     finish(i);
 885
 886     msg("freeing memory\n");
 887     free(v2swf->internal);
 888     memset(v2swf, 0, sizeof(v2swf_t));
 889     msg("close() done\n");
 890 }
 891
 892 static int mp3_bitrates[] =
 893 { 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0};
 894
 895 void v2swf_setparameter(v2swf_t*v2swf, char*name, char*value)
 896 {
 897     v2swf_internal_t* i;
 898
 899     msg("set parameters %s to %s\n", name, value);
 900
 901     if(!strcmp(name, "verbose")) {
 902         verbose = 1;
 903         msg("set parameters %s to %s\n", name, value);
 904         return;
 905     }
 906
 907     if(!v2swf || !v2swf->internal) {
 908         printf("error- couldn't set parameter %s: not initialized yet\n", name);fflush(stdout);
 909         return;
 910     }
 911     i = (v2swf_internal_t*)v2swf->internal;
 912
 913     if(!strcmp(name, "flash_version")) {
 914         i->version = atoi(value);
 915     } else if(!strcmp(name, "audiosync")) {
 916         i->audio_fix = (int)(atof(value));
 917     } else if(!strcmp(name, "scale")) {
 918         i->scale = (int)(atof(value)*65536);
 919     } else if(!strcmp(name, "scale65536")) {
 920         i->scale = atoi(value);
 921     } else if(!strcmp(name, "quality")) {
 922         i->quality = atoi(value);
 923     } else if(!strcmp(name, "motioncompensation")) {
 924         i->domotion = atoi(value);
 925     } else if(!strcmp(name, "prescale")) {
 926         i->prescale = atoi(value);
 927     } else if(!strcmp(name, "blockdiff")) {
 928         i->blockdiff = atoi(value);
 929     } else if(!strcmp(name, "fixheader")) {
 930         i->fixheader = atoi(value);
 931     } else if(!strcmp(name, "samplerate")) {
 932         i->samplerate = atoi(value);
 933     } else if(!strcmp(name, "framerate")) {
 934         i->framerate = atof(value);
 935         i->fpsratio = i->framerate / i->video->fps;
 936     }
 937     else if(!strcmp(name, "mp3_bitrate")) {
 938         int t=0,o;
 939         i->bitrate = o = atoi(value);
 940         if(i->bitrate>160)
 941             i->bitrate = 160;
 942         while(mp3_bitrates[t]) {
 943             if(i->bitrate <= mp3_bitrates[t]) {
 944                 i->bitrate = mp3_bitrates[t];
 945                 break;
 946             }
 947             t++;
 948         }
 949         msg("bitrate %d requested, setting to %d", o, i->bitrate);
 950     }
 951     else if(!strcmp(name, "blockdiff_mode")) {
 952         if(!strcmp(value, "max")) i->diffmode = DIFFMODE_MAX;
 953         else if(!strcmp(value, "mean")) i->diffmode = DIFFMODE_MEAN;
 954         else if(!strcmp(value, "qmean")) i->diffmode = DIFFMODE_QMEAN;
 955         else if(!strcmp(value, "exact")) i->diffmode = DIFFMODE_EXACT;
 956         else {
 957             printf("diffmode %s not recognized\n", value);
 958             printf("valid diffmodes are: %s\n", "max, mean, qmean, exact");
 959         }
 960     }
 961     else if(!strcmp(name, "keyframe_interval")
 962             || !strcmp(name, "keyframe")) {
 963         int k = atoi(value);if(k<=0) k=1;
 964         i->keyframe_interval = k;
 965     }
 966     else {
 967         printf("Setting encoder.%s not recognized!\n", name);fflush(stdout);
 968         return;
 969     }
 970 }
 971 void v2swf_backpatch(v2swf_t*v2swf, char*filename)
 972 {
 973     FILE* fi;
 974     unsigned char f;
 975     v2swf_internal_t* i = (v2swf_internal_t*)v2swf->internal;
 976     msg("v2swf_backpatch %s\n", filename);
 977     if(!i) {
 978         printf("call backpatch before close\n");fflush(stdout);
 979     }
 980     fi = fopen(filename, "rb+");
 981     if(!fi) {
 982         printf("can't open %s\n", filename);
 983         exit(1);
 984     }
 985     fseek(fi, 4, SEEK_SET);
 986     f = i->filesize      ;fwrite(&f,1,1,fi);
 987     f = i->filesize >> 8 ;fwrite(&f,1,1,fi);
 988     f = i->filesize >> 16;fwrite(&f,1,1,fi);
 989     f = i->filesize >> 24;fwrite(&f,1,1,fi);
 990     if(i->version<6) {
 991         /* no compression- we can backpatch the frames too */
 992         fseek(fi, i->headersize-2, SEEK_SET);
 993         f = i->frames        ;fwrite(&f,1,1,fi);
 994         f = i->frames >> 8   ;fwrite(&f,1,1,fi);
 995     }
 996     fclose(fi);
 997     if(i->fixheader) {
 998         SWF tmp;
 999         int fi;
1000         msg("v2swf_backpatch %s - fix header\n", filename);
1001         memset(&tmp, 0, sizeof(tmp));
1002         fi = open(filename, O_RDONLY|O_BINARY);
1003         if(fi>=0) {
1004             if(swf_ReadSWF(fi, &tmp)>=0) {
1005                 close(fi);
1006                 fi = open(filename, O_WRONLY|O_BINARY|O_TRUNC|O_CREAT, 0666);
1007                 if(fi>=0) {
1008                     swf_WriteSWC(fi, &tmp);
1009                     close(fi);
1010                     msg("v2swf_backpatch %s - fix header: success\n", filename);
1011                 }
1012             }
1013         }
1014     }
1015 }
1016
1017 void v2swf_setvideoparameter(videoreader_t*v, char*name, char*value)
1018 {
1019     msg("v2swf_setvideoparameter()");
1020     videoreader_setparameter(v, name, value);
1021 }