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