optimized freetype detection.
[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     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     memset(i->buffer, 255, i->width*i->height*4);
575     for(y=0,yv=0;y<i->height;y++,yv+=ym) {
576         int*src = &((int*)i->vrbuffer)[(yv>>16)*i->video->width];
577         int*dest = &((int*)i->buffer)[y*i->width];
578         for(x=0,xv=0;x<i->width;x++,xv+=xm) {
579             dest[x] = src[xv>>16];
580         }
581     }
582     //memcpy(i->buffer, i->vrbuffer, i->width*i->height*4);
583 }
584
585 static int writeAudioOnly(v2swf_internal_t*i)
586 {
587     if(i->showframe) {
588         i->fpspos += i->fpsratio;
589         /* skip frames */
590         if(i->fpspos<1.0) {
591             return 0;
592         }
593         writeShowFrame(i);
594     }
595     i->showframe = 1;
596     return 1;
597 }
598
599 static int encodeoneframe(v2swf_internal_t*i)
600 {
601     videoreader_t*video = i->video;
602     int ret;
603
604     checkInit(i);
605
606     if(i->video_eof && i->audio_eof) {
607         if(!i->finished)
608             finish(i);
609         return 0;
610     }
611
612     if(!i->audio_eof && i->video_eof) {
613         return writeAudioOnly(i);
614     }
615
616     if(!videoreader_getimage(i->video, i->vrbuffer)) 
617     {
618         i->video_eof = 1;
619         msg("videoreader returned eof\n");
620         if(i->audio_eof) {
621             finish(i);
622             return 0;
623         } else {
624             return writeAudioOnly(i);
625         }
626     }
627
628     msg("encoding image for frame %d\n", i->frames);
629     if(i->showframe) {
630         i->fpspos += i->fpsratio;
631         /* skip frames */
632         if(i->fpspos<1.0) {
633             return 0;
634         }
635         writeShowFrame(i);
636     }
637     
638     msg("scaling\n");
639
640     scaleimage(i);
641
642     msg("version is %d\n", i->version);
643
644     if(i->version <= 4) {
645
646         int bmid = i->id++;
647         int shapeid = i->id++;
648         int width2 = i->width * 4;
649
650         if(i->id>=4) {
651             swf_ResetTag(i->tag, ST_REMOVEOBJECT2);
652             swf_SetU16(i->tag, i->id-3);
653             i->filesize += swf_WriteTag2(&i->out, i->tag);
654             swf_ResetTag(i->tag, ST_FREECHARACTER);
655             swf_SetU16(i->tag, i->id-4);
656             i->filesize += swf_WriteTag2(&i->out, i->tag);
657         }
658
659         swf_ResetTag(i->tag, ST_DEFINEBITSJPEG2);
660         swf_SetU16(i->tag, bmid);
661         swf_SetJPEGBits2(i->tag, i->width, i->height, (RGBA*)i->buffer, i->quality);
662         i->filesize += swf_WriteTag2(&i->out, i->tag);
663         
664         writeShowTags(i, shapeid, bmid, i->width, i->height);
665
666     } else if(i->version == 5) {
667         int width2 = i->width * 4;
668         int width8 = (i->width+7)/8;
669         int height8 = (i->height+7)/8;
670
671         /* the idea is here to only update those jpeg 8x8 blocks
672            which actually have changed. This means that we have to keep
673            the bitmap from the last frame for the comparison. */
674
675         (i->keyframe)--;
676         if(!i->lastbitmap || !i->keyframe) {
677             int t, bmid,shapeid;
678             cleanup(i);
679
680             if(!i->lastbitmap) {
681                 msg("Creating bitmap buffer for %dx%d (%dx%d), (%dx%d)\n", i->width, i->height, width2, i->height, width8, height8);
682                 i->lastbitmap = (U8*)malloc(width2*i->height);
683             }
684             memcpy(i->lastbitmap, i->buffer, width2*i->height);
685
686             i->keyframe = i->keyframe_interval;
687
688             bmid = i->id++;
689             shapeid = i->id++;
690             width2 = i->width * 4;
691             swf_ResetTag(i->tag, ST_DEFINEBITSJPEG2);
692             swf_SetU16(i->tag, bmid);
693             swf_SetJPEGBits2(i->tag, i->width, i->height, (RGBA*)i->buffer, i->quality);
694             i->filesize += swf_WriteTag2(&i->out, i->tag);
695            
696             writeShowTags(i, shapeid, bmid, i->width, i->height);
697             return 1;
698         } else {
699             /* The following looks so ugly because it's somewhat optimized. 
700                What it does is walk through all the 8x8 blocks, find those
701                which have changed too much and set all others to (R,G,B,A)=(0,0,0,0). 
702                It also set's alpha to 255 in those who haven't changed, and
703                copies them to lastbitmap.
704              */
705
706             int x8, y8;
707             //int maxdiff = ((100 - i->quality)*256)/100;
708             int maxdiff = i->blockdiff*3;
709             for(y8=0;y8<height8;y8++)
710             for(x8=0;x8<width8;x8++) {
711                 int x,y;
712                 int xl=8,yl=8;
713                 int yadd;
714                 U8*d1,*d1b,*d2,*d2b;
715                 if(x8*8+xl > i->width)
716                     xl = i->width - x8*8;
717                 if(y8*8+yl > i->height)
718                     yl = i->height - y8*8;
719                 d1 = &i->buffer[width2*y8*8+x8*8*4];
720                 d1b = d1;
721                 d2 = &i->lastbitmap[width2*y8*8+x8*8*4];
722                 d2b = d2;
723                 yadd = width2 - (xl*4);
724
725                 if(i->diffmode == DIFFMODE_MAX) {
726                     if(blockdiff_max(d1, d2, yadd, maxdiff, xl, yl))
727                         goto differ;
728                 } else if(i->diffmode == DIFFMODE_MEAN) {
729                     if(blockdiff_mean(d1, d2, yadd, maxdiff, xl, yl))
730                         goto differ;
731                 } else if(i->diffmode == DIFFMODE_EXACT) {
732                     if(blockdiff_exact(d1, d2, yadd, xl, yl))
733                         goto differ;
734                 } else if(i->diffmode == DIFFMODE_QMEAN) {
735                     if(blockdiff_qmean(d1, d2, yadd, maxdiff, xl, yl))
736                         goto differ;
737                 }
738
739                 for(y=0;y<yl;y++) {
740                     for(x=0;x<xl;x++) {
741                         *(U32*)d1b = 0;
742                         d1b+=4;
743                     }
744                     d1b += yadd;
745                 }
746                 continue;
747     differ:
748                 for(y=0;y<yl;y++) {
749                     for(x=0;x<xl;x++) {
750                         *(U32*)d2b = *(U32*)d1b;
751                         d1b[0] = 255;
752                         d1b+=4;d2b+=4;
753                     }
754                     d1b += yadd; d2b += yadd;
755                 }
756             }
757
758             /* ok, done. Now a) data is zeroed out in regions which haven't changed
759                              b) lastbitmap equals the bitmap we were called with
760                              c) data's alpha value is set to 255 in regions which did change */
761
762         }
763
764         {
765             int bmid = i->id++;
766             int shapeid = i->id++;
767
768             swf_ResetTag(i->tag, ST_DEFINEBITSJPEG3);
769             swf_SetU16(i->tag, bmid);
770             swf_SetJPEGBits3(i->tag, i->width, i->height, (RGBA*)i->buffer, i->quality);
771             i->filesize += swf_WriteTag2(&i->out, i->tag);
772
773             writeShowTags(i, shapeid, bmid, i->width, i->height);
774         }
775     } else {
776         int quant = 1+(30-(30*i->quality)/100);
777         SWFPLACEOBJECT obj;
778
779         swf_GetPlaceObject(0, &obj);
780         if(!i->prescale) {
781             obj.matrix.sx = obj.matrix.sy = i->scale;
782         }
783
784         if(i->stream.frame==0) {
785             obj.depth = 1;
786             obj.id = 99;
787         } else {
788             obj.move = 1;
789             obj.depth = 1;
790             obj.ratio = i->stream.frame;
791         }
792
793         swf_ResetTag(i->tag, ST_VIDEOFRAME);
794         swf_SetU16(i->tag, 99);
795         if(!(--i->keyframe)) {
796             msg("setting video I-frame, ratio=%d\n", i->stream.frame);
797             swf_SetVideoStreamIFrame(i->tag, &i->stream, (RGBA*)i->buffer, quant);
798             i->keyframe = i->keyframe_interval;
799         } else {
800             msg("setting video P-frame, ratio=%d\n", i->stream.frame);
801             swf_SetVideoStreamPFrame(i->tag, &i->stream, (RGBA*)i->buffer, quant);
802         }
803         i->filesize += swf_WriteTag2(&i->out, i->tag);
804
805         swf_ResetTag(i->tag, ST_PLACEOBJECT2);
806         swf_SetPlaceObject(i->tag,&obj);
807         i->filesize += swf_WriteTag2(&i->out, i->tag);
808         i->showframe = 1;
809     }
810     return 1;
811 }
812
813 int v2swf_init(v2swf_t*v2swf, videoreader_t * video)
814 {
815     int ret = 0;
816     int t=0;
817     v2swf_internal_t* i;
818     msg("v2swf_init()\n");
819     memset(v2swf, 0, sizeof(v2swf_t));
820     i = (v2swf_internal_t*)malloc(sizeof(v2swf_internal_t));
821     memset(i, 0, sizeof(v2swf_internal_t));
822     v2swf->internal = i;
823
824     ringbuffer_init(&i->r);
825
826     msg("video: %dx%d, fps %f\n", video->width, video->height, video->fps);
827
828     i->video = video;
829     i->blockdiff = 64;
830     i->keyframe_interval = 8;
831     i->quality = 20;
832     i->scale = 65536;
833     i->samplerate = 11025;
834     i->prescale = 0;
835     i->head_done = 0;
836     i->diffmode = DIFFMODE_QMEAN;
837     i->audio_fix = 1.0;
838     i->fixheader = 0;
839     i->framerate = video->fps;
840     i->fpsratio = 1.00000000000;
841     i->fpspos = 0.0;
842     i->bitrate = 32;
843     i->version = 6;
844     i->buffer = 0;
845     i->lastbitmap = 0;
846     i->filesize = 8;
847     i->frames = 0;
848     i->id = 1;
849     i->lastid = 1;
850     i->keyframe = 1;
851     i->showframe = 0;
852
853     memset(&i->out, 0, sizeof(struct writer_t));
854     memset(&i->out2, 0, sizeof(struct writer_t));
855
856     return 0;
857 }
858 int v2swf_read(v2swf_t*v2swf, void*buffer, int len)
859 {
860     v2swf_internal_t* i;
861     int l;
862     msg("v2swf_read(%d)\n", len);
863     i = (v2swf_internal_t*)v2swf->internal;
864
865     while(!i->finished && i->r.available < len) {
866         if(!encodeoneframe(i)) {
867             break;
868         }
869     }
870     msg("v2swf_read() done: %d bytes available in ringbuffer\n", i->r.available);
871     l = ringbuffer_read(&i->r, buffer, len);
872
873     return l;
874 }
875 void v2swf_close(v2swf_t*v2swf)
876 {
877     v2swf_internal_t* i = (v2swf_internal_t*)v2swf->internal;
878     msg("close(): i->finished=%d\n", i->finished);
879
880     /* needed only if aborting: */
881     finish(i);
882
883     msg("freeing memory\n");
884     free(v2swf->internal);
885     memset(v2swf, 0, sizeof(v2swf_t));
886     msg("close() done\n");
887 }
888
889 static int mp3_bitrates[] =
890 { 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0};
891
892 void v2swf_setparameter(v2swf_t*v2swf, char*name, char*value)
893 {
894     v2swf_internal_t* i;
895
896     msg("set parameters %s to %s\n", name, value);
897
898     if(!strcmp(name, "verbose")) {
899         verbose = 1;
900         msg("set parameters %s to %s\n", name, value);
901         return;
902     }
903
904     if(!v2swf || !v2swf->internal) {
905         printf("error- couldn't set parameter %s: not initialized yet\n", name);fflush(stdout);
906         return;
907     }
908     i = (v2swf_internal_t*)v2swf->internal;
909
910     if(!strcmp(name, "flash_version")) {
911         i->version = atoi(value);
912     } else if(!strcmp(name, "audiosync")) {
913         i->audio_fix = (int)(atof(value));
914     } else if(!strcmp(name, "scale")) {
915         i->scale = (int)(atof(value)*65536);
916     } else if(!strcmp(name, "scale65536")) {
917         i->scale = atoi(value);
918     } else if(!strcmp(name, "quality")) {
919         i->quality = atoi(value);
920     } else if(!strcmp(name, "motioncompensation")) {
921         i->domotion = atoi(value);
922     } else if(!strcmp(name, "prescale")) {
923         i->prescale = atoi(value);
924     } else if(!strcmp(name, "blockdiff")) {
925         i->blockdiff = atoi(value);
926     } else if(!strcmp(name, "fixheader")) {
927         i->fixheader = atoi(value);
928     } else if(!strcmp(name, "samplerate")) {
929         i->samplerate = atoi(value);
930     } else if(!strcmp(name, "framerate")) {
931         i->framerate = atof(value);
932         i->fpsratio = i->framerate / i->video->fps;
933     }
934     else if(!strcmp(name, "mp3_bitrate")) {
935         int t=0,o;
936         i->bitrate = o = atoi(value);
937         if(i->bitrate>160)
938             i->bitrate = 160;
939         while(mp3_bitrates[t]) {
940             if(i->bitrate <= mp3_bitrates[t]) {
941                 i->bitrate = mp3_bitrates[t];
942                 break;
943             }
944             t++;
945         }
946         msg("bitrate %d requested, setting to %d", o, i->bitrate);
947     }
948     else if(!strcmp(name, "blockdiff_mode")) {
949         if(!strcmp(value, "max")) i->diffmode = DIFFMODE_MAX;
950         else if(!strcmp(value, "mean")) i->diffmode = DIFFMODE_MEAN;
951         else if(!strcmp(value, "qmean")) i->diffmode = DIFFMODE_QMEAN;
952         else if(!strcmp(value, "exact")) i->diffmode = DIFFMODE_EXACT;
953         else {
954             printf("diffmode %s not recognized\n", value);
955             printf("valid diffmodes are: %s\n", "max, mean, qmean, exact");
956         }
957     }
958     else if(!strcmp(name, "keyframe_interval")
959             || !strcmp(name, "keyframe")) {
960         int k = atoi(value);if(k<=0) k=1;
961         i->keyframe_interval = k;
962     }
963     else {
964         printf("Setting encoder.%s not recognized!\n", name);fflush(stdout);
965         return;
966     }
967 }
968 void v2swf_backpatch(v2swf_t*v2swf, char*filename)
969 {
970     FILE* fi;
971     unsigned char f;
972     v2swf_internal_t* i = (v2swf_internal_t*)v2swf->internal;
973     msg("v2swf_backpatch %s\n", filename);
974     if(!i) {
975         printf("call backpatch before close\n");fflush(stdout);
976     }
977     fi = fopen(filename, "rb+");
978     if(!fi) {
979         printf("can't open %s\n", filename);
980         exit(1);
981     }
982     fseek(fi, 4, SEEK_SET);
983     f = i->filesize      ;fwrite(&f,1,1,fi);
984     f = i->filesize >> 8 ;fwrite(&f,1,1,fi);
985     f = i->filesize >> 16;fwrite(&f,1,1,fi);
986     f = i->filesize >> 24;fwrite(&f,1,1,fi);
987     if(i->version<6) {
988         /* no compression- we can backpatch the frames too */
989         fseek(fi, i->headersize-2, SEEK_SET);
990         f = i->frames        ;fwrite(&f,1,1,fi);
991         f = i->frames >> 8   ;fwrite(&f,1,1,fi);
992     }
993     fclose(fi);
994     if(i->fixheader) {
995         SWF tmp;
996         int fi;
997         msg("v2swf_backpatch %s - fix header\n", filename);
998         memset(&tmp, 0, sizeof(tmp));
999         fi = open(filename, O_RDONLY|O_BINARY);
1000         if(fi>=0) {
1001             if(swf_ReadSWF(fi, &tmp)>=0) {
1002                 close(fi);
1003                 fi = open(filename, O_WRONLY|O_BINARY|O_TRUNC|O_CREAT, 0666);
1004                 if(fi>=0) {
1005                     swf_WriteSWC(fi, &tmp);
1006                     close(fi);
1007                     msg("v2swf_backpatch %s - fix header: success\n", filename);
1008                 }
1009             }
1010         }
1011     }
1012 }
1013
1014 void v2swf_setvideoparameter(videoreader_t*v, char*name, char*value)
1015 {
1016     msg("v2swf_setvideoparameter()");
1017     videoreader_setparameter(v, name, value);
1018 }