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