avi2swf/avi2swf.cc

   1 /* avi2swf.cc
   2    Convert avi movie files into swf.
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2001 Matthias Kramm <kramm@quiss.org>
   7
   8    This file is distributed under the GPL, see file COPYING for details */
   9
  10 #include <stdio.h>
  11 #include <fcntl.h>
  12 extern "C" {
  13 #include "../lib/rfxswf.h"
  14 #include "../lib/args.h"
  15 }
  16 #include <avifile/version.h>
  17 #if (AVIFILE_MAJOR_VERSION == 0) && (AVIFILE_MINOR_VERSION==6)
  18    #include <avifile.h>
  19    #include <aviplay.h>
  20    #include <fourcc.h>
  21    #include <creators.h>
  22    #include <StreamInfo.h>
  23    #define VERSION6
  24 #else
  25    #include <avifile.h>
  26    #include <aviplay.h>
  27    #include <aviutil.h>
  28    #define Width width
  29    #define Height height
  30    #define Data data
  31    #define Bpp bpp
  32 #endif
  33
  34 /*
  35 statistics: (for now)
  36    37   bytes per shape (rectangle)
  37    8-12 bytes per placeobject
  38    4    bytes per removeobject2
  39    696+ bytes per definejpeg2 (576 jpegtables)
  40    576  bytes per jpegtables
  41    122+ bytes per definejpeg
  42
  43    blocks*140 = minimal bytes per frames
  44    5000/140   = maximal blocks with framerate 5000
  45
  46    2    bytes per showframe
  47 */
  48
  49 static int cache_size=38; //in frames
  50
  51 static char * filename = 0;
  52 static char * outputfilename = "output.swf";
  53 static unsigned int firstframe = 0;
  54 static unsigned int lastframe = 0x7fffffff;
  55
  56 static int jpeg_quality = 20;
  57
  58 static char zlib = 0;
  59 static double scale = 1.0;
  60
  61 #ifndef ST_DEFINEBITSJPEG
  62 #define ST_DEFINEBITSJPEG       6
  63 #endif
  64
  65 int filesize = 0;
  66
  67 struct options_t options[] =
  68 {
  69  {"v","verbose"},
  70  {"o","output"},
  71  {"n","num"},
  72  {"s","start"},
  73  {"z","zlib"},
  74  {"V","version"},
  75  {0,0}
  76 };
  77
  78 int args_callback_option(char*name,char*val)
  79 {
  80     if(!strcmp(name, "V")) {
  81         printf("avi2swf - part of %s %s\n", PACKAGE, VERSION);
  82         exit(0);
  83     }
  84     else if(!strcmp(name, "o")) {
  85         outputfilename = val;
  86         return 1;
  87     }
  88     else if(!strcmp(name, "n")) {
  89         lastframe = atoi(val);
  90         return 1;
  91     }
  92     else if(!strcmp(name, "s")) {
  93         firstframe = atoi(val);
  94         return 1;
  95     }
  96     else if(!strcmp(name, "d")) {
  97         scale = atoi(val)/100.0;
  98         if(scale>1.0 || scale<=0) {
  99             fprintf(stderr, "Scale must be in the range 1-100!\n");
 100             exit(1);
 101         }
 102         return 1;
 103     }
 104     else if(!strcmp(name, "z")) {
 105         zlib = 1;
 106         return 0;
 107     }
 108     fprintf(stderr, "Unknown option: -%s\n", name);
 109     exit(1);
 110 }
 111 int args_callback_longoption(char*name,char*val)
 112 {
 113     return args_long2shortoption(options, name, val);
 114 }
 115 void args_callback_usage(char*name)
 116 {
 117     printf("\nUsage: %s file.avi\n", name);
 118     printf("\t-h , --help\t\t Print help and exit\n");
 119     printf("\t-o , --output filename\t Specify output filename\n");
 120     printf("\t-n , --num frames\t Number of frames to encode\n");
 121     printf("\t-s , --start frame\t First frame to encode\n");
 122     printf("\t-d , --scale factor\t Scale to factor percent\n");
 123     printf("\t-V , --version\t\t Print program version and exit\n");
 124     exit(0);
 125 }
 126 int args_callback_command(char*name,char*val)
 127 {
 128     if(filename) {
 129         fprintf(stderr, "Only one file allowed. You supplied at least two. (%s and %s)\n",
 130                  filename, name);
 131     }
 132     filename = name;
 133     return 0;
 134 }
 135
 136 /* id allocation/deallocation */
 137 char idtab[65536];
 138 unsigned int idtab_pos=1;
 139 int get_free_id()
 140 {
 141     while(idtab[idtab_pos] || !idtab_pos)
 142         idtab_pos++;
 143     idtab[idtab_pos]=1;
 144     return idtab_pos;
 145 }
 146 void free_id(int id)
 147 {
 148     idtab[id] = 0;
 149 }
 150
 151 void makeshape(int file, int id, int gfxid, int width, int height)
 152 {
 153     TAG*tag;
 154     RGBA rgb;
 155     MATRIX m;
 156     SHAPE*s;
 157     SRECT r;
 158     int lines = 0;
 159     int ls,fs;
 160     tag = swf_InsertTag(NULL, ST_DEFINESHAPE);
 161     swf_ShapeNew(&s);
 162     rgb.b = rgb.g = rgb.r = 0xff;
 163     if(lines)
 164         ls = swf_ShapeAddLineStyle(s,20,&rgb);
 165     swf_GetMatrix(NULL,&m);
 166     m.sx = 20*65536;
 167     m.sy = 20*65536;
 168
 169     fs = swf_ShapeAddBitmapFillStyle(s,&m,gfxid,0);
 170     swf_SetU16(tag,id);   // ID
 171     r.xmin = 0;
 172     r.ymin = 0;
 173     r.xmax = width*20;
 174     r.ymax = height*20;
 175     swf_SetRect(tag,&r);
 176
 177     swf_SetShapeStyles(tag,s);
 178     swf_ShapeCountBits(s,NULL,NULL);
 179     swf_SetShapeBits(tag,s);
 180
 181     swf_ShapeSetAll(tag,s,0,0,lines?ls:0,fs,0);
 182
 183     swf_ShapeSetLine(tag,s,width*20,0);
 184     swf_ShapeSetLine(tag,s,0,height*20);
 185     swf_ShapeSetLine(tag,s,-width*20,0);
 186     swf_ShapeSetLine(tag,s,0,-height*20);
 187     swf_ShapeSetEnd(tag);
 188     filesize += swf_WriteTag(file, tag);
 189     swf_DeleteTag(tag);
 190     swf_ShapeFree(s);
 191 }
 192
 193 void setshape(int file,int id,int depth,int x,int y,CXFORM*cx)
 194 {
 195     TAG*tag;
 196     MATRIX m;
 197     m.sx = 0x10000; m.sy = 0x10000;
 198     m.r0 = 0; m.r1 = 0;
 199     m.tx = x*20;
 200     m.ty = y*20;
 201     if(cx && !((cx->a0!=256)||(cx->r0!=256)||(cx->g0!=256)||(cx->b0!=256)
 202                 ||(cx->a1|cx->r1|cx->g1|cx->b1))) cx = 0;
 203     tag = swf_InsertTag(NULL,ST_PLACEOBJECT2);
 204       swf_ObjectPlace(tag,id,depth,&m,cx,0);
 205     filesize += swf_WriteTag(file, tag);
 206     swf_DeleteTag(tag);
 207 }
 208
 209
 210 int xblocksize;
 211 int yblocksize;
 212 struct GfxBlock {
 213 //    static int xblocksize;
 214 //    static int yblocksize;
 215     U8*data;
 216     int len;
 217 };
 218
 219 int width=0;
 220 int height=0;
 221
 222 int xblocks;
 223 int yblocks;
 224
 225 U8* blockbuffer = 0;
 226
 227 class GfxBlockCache {
 228
 229     GfxBlock*list;
 230     char*expire; //0=block's free
 231     int*ids;
 232     int size;
 233     int pos;
 234     int hits;
 235     int misses;
 236
 237     public:
 238
 239     GfxBlockCache(int file)
 240     {
 241         list=0;
 242         size = xblocks*yblocks*cache_size;
 243         printf("initializing cache (%d entries)\n", size);
 244         list = new GfxBlock[size];
 245         expire = new char[size];
 246         ids = new int[size];
 247         memset(expire,0,size);
 248         memset(list,0,sizeof(GfxBlock)*size);
 249         memset(ids,0,sizeof(int)*size);
 250         pos = 0;
 251         hits =0;
 252         misses =0;
 253     }
 254     void insert(GfxBlock*block, int gfxid)
 255     {
 256         int oldpos = pos;
 257         while(++pos!=oldpos)
 258         {
 259             if(pos==size) pos=0;
 260             if(!expire[pos])
 261                 break;
 262         }
 263         if(pos==oldpos) {
 264             // cache full- don't insert item
 265             return;
 266         }
 267         if(list[pos].data) {
 268             free(list[pos].data);
 269             list[pos].data = 0;
 270             //TODO: free this in the SWF, also
 271         }
 272         list[pos].data=(U8*)malloc(block->len);
 273         memcpy(list[pos].data,block->data,block->len);
 274         list[pos].len = block->len;
 275         expire[pos] = cache_size;
 276         ids[pos] = gfxid;
 277     }
 278     int find(GfxBlock*block, CXFORM*cxform)
 279     {
 280         //TODO: do least square regression here to derive cxform
 281         int s;
 282         int bestsum=-1;
 283         int bestid;
 284         float best;
 285         for(s=0;s<size;s++)
 286         if(expire[s])
 287         {
 288             int t = (block->len);
 289             U8*ptr1 = block->data;
 290             U8*ptr2 = list[s].data;
 291             int sum2 = 0;
 292             // notice: we treat r,g,b as equal here.
 293             do {
 294                 int a = (*ptr1++)-(*ptr2++);
 295                 sum2 += a*a;
 296             } while(--t);
 297             if(bestsum < 0 || bestsum > sum2) {
 298                 bestid = s;
 299                 bestsum = sum2;
 300             }
 301         }
 302         if(bestsum<0) {
 303             misses++;
 304             return -1;
 305         }
 306         best = bestsum/block->len;
 307
 308         if(best > 96.0) {
 309             misses++;
 310             return -1;
 311         }
 312         expire[bestid]= cache_size;
 313         hits++;
 314         cxform->a0 = 256;
 315         cxform->r0 = 256;
 316         cxform->g0 = 256;
 317         cxform->b0 = 256;
 318         cxform->a1 = 0;
 319         cxform->r1 = 0;
 320         cxform->g1 = 0;
 321         cxform->b1 = 0;
 322         return ids[bestid];
 323     }
 324     void newframe()
 325     {
 326         int t;
 327         for(t=0;t<size;t++)
 328             if(expire[t])
 329                 expire[t]--;
 330
 331     }
 332     ~GfxBlockCache()
 333     {
 334         int t;
 335         printf("destroying cache...\n");
 336         if(hits+misses) {
 337             printf("hits:%d (%02d%%)\n", hits, hits*100/(hits+misses));
 338             printf("misses:%d (%02d%%)\n", misses, misses*100/(hits+misses));
 339         }
 340         for(t=0;t<size;t++)
 341             if(expire[t] && list[t].data)
 342                 free(list[t].data);
 343         free(list);
 344         free(expire);
 345         free(ids);
 346     }
 347 } * cache = 0;
 348
 349 class GfxBlockEncoder {
 350     int sizex;
 351     int sizey;
 352     int posx;
 353     int posy;
 354     int basedepth;
 355     int depth[3];
 356     public:
 357     void init(int depth, int posx,int posy, int sizex, int sizey)
 358     {
 359         this->basedepth = depth;
 360         this->posx = posx;
 361         this->posy = posy;
 362         this->sizex = sizex;
 363         this->sizey = sizey;
 364         this->depth[0] = this->depth[1] = this->depth[2] = -1;
 365     }
 366     void clear(int file)
 367     {
 368         /* clear everything in the block */
 369         int t;
 370         for(t=0;t<3;t++)
 371         if(depth[t]>=0)
 372         {
 373             TAG*tag;
 374             tag = swf_InsertTag(NULL, ST_REMOVEOBJECT2);
 375             swf_SetU16(tag, basedepth+t); //depth
 376             filesize += swf_WriteTag(file, tag);
 377             swf_DeleteTag(tag);
 378             depth[t] = -1;
 379         }
 380     }
 381     void writeiframe(int file, GfxBlock*block)
 382     {
 383         clear(file);
 384
 385         int gfxid = get_free_id();
 386         int shapeid = get_free_id();
 387
 388         //memset(data,0,sizex*sizey*3);
 389         TAG*tag = swf_InsertTag(NULL, ST_DEFINEBITS);
 390         JPEGBITS * jb = swf_SetJPEGBitsStart(tag,sizex,sizey,jpeg_quality);
 391         tag->len = 0; //bad hack
 392         swf_SetU16(tag, gfxid);
 393         int y;
 394         for(y=0;y<sizey;y++)
 395             swf_SetJPEGBitsLine(jb,&block->data[y*sizex*3]);
 396         swf_SetJPEGBitsFinish(jb);
 397         filesize += swf_WriteTag(file, tag);
 398         swf_DeleteTag(tag);
 399
 400         cache->insert(block, shapeid);
 401
 402         makeshape(file, shapeid, gfxid, sizex, sizey);
 403         setshape(file, shapeid, basedepth+1, posx, posy, 0);
 404         depth[1] = shapeid;
 405     }
 406     void writereference(int file, int shapeid, CXFORM*form)
 407     {
 408         if(depth[1]!=shapeid)
 409         {
 410             clear(file);
 411             setshape(file, shapeid, basedepth+1, posx, posy, form);
 412             depth[1] = shapeid;
 413         }
 414     }
 415     void compress(int file, GfxBlock*block)
 416     {
 417         CXFORM form;
 418         int id = cache->find(block, &form);
 419         if(id<0)
 420             writeiframe(file, block);
 421         else {
 422             writereference(file, id, &form);
 423         }
 424     }
 425 } *blocks = 0;
 426
 427 void initdisplay(int file)
 428 {
 429     if(blockbuffer)
 430         free(blockbuffer);
 431     if(blocks) {
 432         int t;
 433         for(t=0;t<xblocks;t++)
 434             blocks[t].clear(file);
 435         free(blocks);
 436     }
 437     if(cache)
 438         delete cache;
 439     xblocksize = (width/3)&~7;
 440     yblocksize = (height/2)&~7;
 441     xblocks = width/xblocksize;
 442     yblocks = height/yblocksize;
 443     printf("%dx%d blocks of size %dx%d\n", xblocks,yblocks, xblocksize, yblocksize);
 444     printf("cutting lower %d lines, right %d columns\n",
 445             height-yblocks*yblocksize, width-xblocks*xblocksize);
 446     blocks = new GfxBlockEncoder[xblocks*yblocks];
 447     blockbuffer = new U8[xblocksize*yblocksize*4]; //should be 3
 448     cache = new GfxBlockCache(file);
 449     int t;
 450     for(t=0;t<xblocks*yblocks;t++) {
 451         blocks[t].init(t*64,
 452                        (t%xblocks)*xblocksize,
 453                        (t/xblocks)*yblocksize,
 454                        xblocksize, yblocksize);
 455     }
 456
 457     TAG*tag = swf_InsertTag(NULL, ST_JPEGTABLES);
 458     JPEGBITS * jpeg = swf_SetJPEGBitsStart(tag, xblocksize, yblocksize, jpeg_quality);
 459     filesize += swf_WriteTag(file, tag);
 460     swf_DeleteTag(tag);
 461     free(jpeg);
 462 }
 463
 464 void destroydisplay(int file)
 465 {
 466     delete cache;
 467     free(blocks);
 468     free(blockbuffer);
 469 }
 470
 471 SWF swf;
 472 TAG*tag;
 473
 474 class SoundReader
 475 {
 476
 477     short int* sound_buffer;
 478     int mp3_block_size;
 479     int write_pos;
 480     int read_pos;
 481     IAviReadStream* astream;
 482     void readBlock()
 483     {
 484         unsigned samples_read, bytes_read;
 485         int ret;
 486         short int tmpbuf[4096];
 487         ret = astream->ReadFrames(tmpbuf, 4096*sizeof(short int),
 488                 4096, samples_read, bytes_read);
 489         if(ret<0) {
 490             printf("couldn't read %d samples\n", mp3_block_size);
 491             exit(1);
 492         }
 493         int t;
 494         samples_read = bytes_read/sizeof(short int);
 495         for(t=0;t<samples_read/2;t++) {
 496             sound_buffer[write_pos+t] = tmpbuf[t*2];
 497         }
 498         write_pos += samples_read/2;
 499
 500         if(write_pos >= mp3_block_size*8)
 501         {
 502             if(write_pos > mp3_block_size*8)
 503                 memcpy(&sound_buffer[0],&sound_buffer[mp3_block_size*8],write_pos - mp3_block_size*8);
 504             write_pos %= (mp3_block_size*8);
 505         }
 506     }
 507     public:
 508
 509     SoundReader(IAviReadStream*astream)
 510     {
 511         this->astream = astream;
 512         this->write_pos = 0;
 513         this->read_pos = 0;
 514         this->mp3_block_size = 2304;
 515         this->sound_buffer = new short int[mp3_block_size*16];
 516     }
 517     ~SoundReader()
 518     {
 519         delete sound_buffer;
 520     }
 521     int available()
 522     {
 523         if(read_pos<=write_pos)
 524             return write_pos-read_pos;
 525         else
 526             return (write_pos+mp3_block_size*8)-read_pos;
 527     }
 528     short int* readFrame()
 529     {
 530         int tmp;
 531         while(available()<mp3_block_size) {
 532             readBlock();
 533         }
 534         tmp = read_pos;
 535         read_pos += mp3_block_size;
 536         read_pos %= mp3_block_size*8;
 537         return &sound_buffer[tmp];
 538     }
 539 };
 540
 541
 542 static int mp3_block_size = 2304;
 543
 544 static int do_video = 1;
 545 static int do_audio = 1;
 546
 547 int main (int argc,char ** argv)
 548 {
 549   int file;
 550   IAviReadFile* player;
 551   IAviReadStream* astream;
 552   IAviReadStream* vstream;
 553   SRECT r;
 554   double samplesperframe;
 555   int samplerate;
 556   int samplefix;
 557   double fps;
 558   int oldwidth;
 559   int oldheight;
 560   double reziscale;
 561
 562   processargs(argc, argv);
 563   lastframe += firstframe;
 564   if(!filename)
 565       exit(0);
 566
 567   memset(idtab, 0, sizeof(idtab));
 568
 569   player = CreateIAviReadFile(filename);
 570   astream = player->GetStream(0, AviStream::Audio);
 571   vstream = player->GetStream(0, AviStream::Video);
 572   if(!vstream)
 573       do_video = 0;
 574   if(!astream)
 575       do_audio = 0;
 576 #ifndef VERSION6
 577   MainAVIHeader head;
 578   int dwMicroSecPerFrame = 0;
 579   player->GetFileHeader(&head);
 580   printf("fps: %d\n", 1000000/head.dwMicroSecPerFrame);
 581   printf("frames: %d\n", head.dwTotalFrames);
 582   printf("streams: %d\n", head.dwStreams);
 583   printf("width: %d\n", head.dwWidth);
 584   printf("height: %d\n", head.dwHeight);
 585   printf("sound: %u samples (%f seconds)\n", astream->GetEndPos(),
 586           astream->GetEndTime());
 587   oldwidth = head.dwWidth;
 588   oldheight = head.dwHeight;
 589   dwMicroSecPerFrame = head.dwMicroSecPerFrame;
 590   samplesperframe = astream->GetEndPos()/astream->GetEndTime()*head.dwMicroSecPerFrame/1000000;
 591   samplerate = (int)(astream->GetEndPos()/astream->GetEndTime());
 592   fps = 1000000.0/dwMicroSecPerFrame;
 593 #else
 594   StreamInfo*audioinfo;
 595   StreamInfo*videoinfo;
 596   if(do_video)
 597   {
 598     videoinfo = vstream->GetStreamInfo();
 599     oldwidth = videoinfo->GetVideoWidth();
 600     oldheight = videoinfo->GetVideoHeight();
 601     fps = (double)(videoinfo->GetFps());
 602     delete(videoinfo);
 603   }
 604   if(do_audio)
 605   {
 606     audioinfo = astream->GetStreamInfo();
 607     samplerate = audioinfo->GetAudioSamplesPerSec();
 608     samplesperframe = audioinfo->GetAudioSamplesPerSec()/videoinfo->GetFps();
 609     delete(audioinfo);
 610   }
 611 #endif
 612   width = (int)(oldwidth*scale);
 613   height = (int)(oldheight*scale);
 614   reziscale = 1/scale;
 615
 616   vstream -> StartStreaming();
 617   if(do_audio)
 618   {
 619     astream -> StartStreaming();
 620     printf("%f framerate\n", fps);
 621     printf("%f samples/frame\n", samplesperframe);
 622     printf("%d samplerate\n", samplerate);
 623   }
 624
 625   if(zlib)
 626     file = open("__tmp__.swf", O_WRONLY|O_CREAT|O_TRUNC, 0644);
 627   else
 628     file = open(outputfilename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
 629
 630   memset(&swf, 0, sizeof(swf));
 631   swf.frameRate = (int)(fps*256);
 632   swf.fileVersion = 4;
 633   swf.fileSize = 0x0fffffff;
 634   swf.frameCount = lastframe - firstframe;
 635   r.xmin = 0;
 636   r.ymin = 0;
 637   r.xmax = width*20;
 638   r.ymax = height*20;
 639   swf.movieSize = r;
 640
 641   filesize += swf_WriteHeader(file, &swf);
 642
 643   tag = swf_InsertTag(NULL, ST_SETBACKGROUNDCOLOR);
 644   swf_SetU8(tag,0); //black
 645   swf_SetU8(tag,0);
 646   swf_SetU8(tag,0);
 647   filesize += swf_WriteTag(file, tag);
 648   swf_DeleteTag(tag);
 649
 650   tag = swf_InsertTag(NULL, ST_SOUNDSTREAMHEAD2);
 651   swf_SetSoundStreamHead(tag, (int)samplesperframe/4);
 652   filesize += swf_WriteTag(file, tag);
 653   swf_DeleteTag(tag);
 654
 655   int frame = 0;
 656   initdisplay(file);
 657
 658   double movie_sound_pos = 0;
 659   int mp3_sound_pos = 0;
 660
 661   if(do_audio)
 662   {
 663       WAVEFORMATEX wave;
 664       astream->GetAudioFormatInfo(&wave,0);
 665
 666       printf("nChannels:%d\n", wave.nChannels);
 667       printf("nSamplesPerSec:%d\n", wave.nSamplesPerSec);
 668       printf("nAvgBytesPerSec:%d\n", wave.nAvgBytesPerSec);
 669       printf("nBlockAlign:%d\n", wave.nBlockAlign);
 670       printf("wBitsPerSample:%d\n", wave.wBitsPerSample);
 671       printf("cbSize:%d\n", wave.cbSize);
 672   }
 673
 674   SoundReader* sound = new SoundReader(astream);
 675
 676   while(1) {
 677     if(vstream->ReadFrame()<0) {
 678         printf("\n");
 679         break;
 680     }
 681
 682     if(frame < firstframe)
 683     {
 684         movie_sound_pos += samplesperframe;
 685         if(do_audio)
 686         while(mp3_sound_pos<movie_sound_pos) {
 687             short int* samples = sound->readFrame();
 688             mp3_sound_pos += mp3_block_size;
 689         }
 690         printf("\rskipping frame %d",frame);
 691         fflush(stdout);
 692         frame++;
 693         if(frame == firstframe)
 694             printf("\n");
 695         continue;
 696     }
 697
 698     printf("\rconvert frame %d",frame);
 699     fflush(stdout);
 700
 701     // audio
 702     movie_sound_pos += samplesperframe;
 703
 704     int first=1;
 705     if(do_audio)
 706     while(mp3_sound_pos<movie_sound_pos) {
 707         // rawplay -s 44100 -f s16_le -c 2 samples.test
 708         short int* samples = sound->readFrame();
 709         int s;
 710         int c=0;
 711         if(first) { //first run
 712               tag = swf_InsertTag(NULL, ST_SOUNDSTREAMBLOCK);
 713               swf_SetSoundStreamBlock(tag, samples, 1);
 714         } else {
 715               swf_SetSoundStreamBlock(tag, samples, 0);
 716         }
 717
 718         mp3_sound_pos += mp3_block_size;
 719
 720         if(mp3_sound_pos>=movie_sound_pos) { // last run
 721             filesize += swf_WriteTag(file, tag);
 722             swf_DeleteTag(tag);
 723         }
 724         first = 0;
 725     }
 726
 727     // video
 728
 729     CImage*img = vstream->GetFrame();
 730     img->ToRGB();
 731     U8*data = img->Data();
 732     int bpp = img->Bpp();
 733     int x,y;
 734     int xx,yy;
 735     int fs,ls;
 736     SHAPE*s;
 737     MATRIX m;
 738     SRECT r;
 739     RGBA rgb;
 740
 741     /* some movies have changing dimensions */
 742     if(img->Width() != oldwidth ||
 743        img->Height() != oldheight) {
 744         printf("\n");
 745         oldwidth = img->Width();
 746         oldheight = img->Height();
 747         width = (int)(oldwidth*scale);
 748         height = (int)(oldheight*scale);
 749         initdisplay(file);
 750     }
 751
 752     for(yy=0;yy<yblocks;yy++)
 753     for(xx=0;xx<xblocks;xx++)
 754     {
 755         int x,y;
 756         for(y=0;y<yblocksize;y++) {
 757 #ifdef VERSION6
 758             U8*mydata = img->At(oldheight-(int)((yy*yblocksize+y)*reziscale));
 759 #else
 760             U8*mydata = img->At((int)((yy*yblocksize+y)*reziscale));
 761 #endif
 762             for(x=0;x<xblocksize;x++) {
 763                 blockbuffer[(y*xblocksize+x)*3+2] = mydata[((int)(((xx*xblocksize+x)*reziscale)))*3+0];
 764                 blockbuffer[(y*xblocksize+x)*3+1] = mydata[((int)(((xx*xblocksize+x)*reziscale)))*3+1];
 765                 blockbuffer[(y*xblocksize+x)*3+0] = mydata[((int)(((xx*xblocksize+x)*reziscale)))*3+2];
 766             }
 767         }
 768         GfxBlock b;
 769         b.data = blockbuffer;
 770         b.len = xblocksize*yblocksize*3;
 771         blocks[yy*xblocks+xx].compress(file, &b);
 772     }
 773
 774     tag = swf_InsertTag(NULL, ST_SHOWFRAME);
 775     filesize += swf_WriteTag(file, tag);
 776     swf_DeleteTag(tag);
 777
 778     cache->newframe();
 779
 780     frame++;
 781     if(frame == lastframe)
 782         break;
 783   }
 784   delete sound;
 785   printf("\n");
 786   destroydisplay(file);
 787
 788   tag = swf_InsertTag(NULL, ST_END);
 789   filesize += swf_WriteTag(file, tag);
 790   swf_DeleteTag(tag);
 791
 792   close(file);
 793
 794   FILE*fi;
 795   if(zlib)
 796     fi=fopen("tmp.swf", "r+");
 797   else
 798     fi=fopen(outputfilename, "r+");
 799
 800   if(fi)
 801   {
 802        fseek(fi,4,SEEK_SET);
 803        unsigned char f;
 804        f = filesize      ;fwrite(&f,1,1,fi);
 805        f = filesize >> 8 ;fwrite(&f,1,1,fi);
 806        f = filesize >> 16;fwrite(&f,1,1,fi);
 807        f = filesize >> 24;fwrite(&f,1,1,fi);
 808        fclose(fi);
 809   }
 810
 811   if(zlib) {
 812       char buffer[1024];
 813       snprintf(buffer, 1024, "swfcombine -dz __tmp__.swf -o %s", outputfilename);
 814       printf("%s\n", buffer);
 815       system(buffer);
 816       sprintf(buffer, "rm __tmp__.swf");
 817       printf("%s\n", buffer);
 818       system(buffer);
 819   }
 820
 821   return 0;
 822 }
 823