upgrade to xpdf 1.01.
[swftools.git] / src / png2swf.c
1 /* png2swf.c
2
3    PNG to SWF converter tool
4
5    Part of the swftools package.
6
7    Copyright (c) 2002 Matthias Kramm <kramm@quiss.org>
8  
9    This file is distributed under the GPL, see file COPYING for details 
10
11 */
12
13 #include <stdio.h>
14 #include <math.h>
15 #include <fcntl.h>
16 #include <zlib.h>
17 #include "../lib/rfxswf.h"
18 #include "../lib/args.h"
19
20 #define MAX_INPUT_FILES 1024
21 #define VERBOSE(x) (global.verbose>=x)
22
23 struct {
24     int framerate;
25     int max_image_width;
26     int max_image_height;
27     int force_width;
28     int force_height;
29     int nfiles;
30     int verbose;
31     char *outfile;
32 } global;
33
34 struct {
35     char *filename;
36 } image[MAX_INPUT_FILES];
37
38 TAG *MovieStart(SWF * swf, int framerate, int dx, int dy)
39 {
40     TAG *t;
41     RGBA rgb;
42
43     memset(swf, 0x00, sizeof(SWF));
44
45     swf->fileVersion = 4;
46     swf->frameRate = (25600 / framerate);
47     swf->movieSize.xmax = dx * 20;
48     swf->movieSize.ymax = dy * 20;
49
50     t = swf->firstTag = swf_InsertTag(NULL, ST_SETBACKGROUNDCOLOR);
51
52     rgb.r = rgb.g = rgb.b = rgb.a = 0x00;
53     swf_SetRGB(t, &rgb);
54
55     return t;
56 }
57
58 int MovieFinish(SWF * swf, TAG * t, char *sname)
59 {
60     int handle, so = fileno(stdout);
61     t = swf_InsertTag(t, ST_END);
62
63     if ((!isatty(so)) && (!sname))
64         handle = so;
65     else {
66         if (!sname)
67             sname = "output.swf";
68         handle = open(sname, O_RDWR | O_CREAT | O_TRUNC, 0666);
69     }
70     if FAILED
71         (swf_WriteSWF(handle, swf)) if (VERBOSE(1))
72             fprintf(stderr, "Unable to write output file: %s\n", sname);
73     if (handle != so)
74         close(handle);
75
76     swf_FreeTags(swf);
77     return 0;
78 }
79
80 int png_read_chunk(char (*head)[4], int*destlen, U8**destdata, FILE*fi)
81 {
82     unsigned int len;
83     if(destlen) *destlen=0;
84     if(destdata) *destdata=0;
85     if(!fread(&len, 4, 1, fi))
86         return 0;
87     if(!fread(head, 4, 1, fi))
88         return 0;
89     len = REVERSESWAP32(len);
90     if(destlen) *destlen = len;
91     if(destdata) {
92         if(len)
93             *destdata = malloc(len);
94         else 
95             *destdata = 0;
96         if(!fread(*destdata, len, 1, fi)) {
97             *destdata = 0;
98             if(destlen) *destlen=0;
99             return 0;
100         }
101         fseek(fi, 4, SEEK_CUR);
102
103     } else {
104         fseek(fi, len+4, SEEK_CUR);
105     }
106     return 1;
107 }
108
109 unsigned int png_get_dword(FILE*fi)
110 {
111     unsigned int a;
112     fread(&a,4,1,fi);
113     return REVERSESWAP32(a);
114 }
115
116 struct png_header
117 {
118     int width;
119     int height;
120     int bpp;
121     int mode;
122 };
123
124 int png_read_header(FILE*fi, struct png_header*header)
125 {
126     char id[4];
127     int len;
128     U8 head[8] = {137,80,78,71,13,10,26,10};
129     U8 head2[8];
130     U8*data;
131     fread(head2,8,1,fi);
132     if(strncmp(head,head2,4))
133         return 0;
134    
135     while(png_read_chunk(&id, &len, &data, fi))
136     {
137         if(VERBOSE(2))
138             printf("%c%c%c%c %d\n", id[0],id[1],id[2],id[3],len);
139         if(!strncasecmp(id, "IHDR", 4)) {
140             char a,b,c,f,i;
141             if(len < 8) exit(1);
142             header->width = REVERSESWAP32(*(U32*)&data[0]);
143             header->height = REVERSESWAP32(*(U32*)&data[4]);
144             a = data[8];      // should be 8
145             b = data[9];      // should be 3(indexed) or 2(rgb)
146
147             c = data[10];     // compression mode (0)
148             f = data[11];     // filter mode (0)
149             i = data[12];     // interlace mode (0)
150
151             if(b!=2 && b!=3) {
152                 fprintf(stderr, "Image mode %d not supported!\n", b);
153                 exit(1);
154             }
155             if(a!=8) {
156                 fprintf(stderr, "Bpp %d not supported!\n", a);
157                 exit(1);
158             }
159             if(c!=0) {
160                 fprintf(stderr, "Compression mode %d not supported!\n", c);
161                 exit(1);
162             }
163             if(f!=0) {
164                 fprintf(stderr, "Filter mode %d not supported!\n", f);
165                 exit(1);
166             }
167             if(i!=0) {
168                 fprintf(stderr, "Interlace mode %d not supported!\n", i);
169                 exit(1);
170             }
171             if(VERBOSE(2))
172                 printf("%dx%d %d %d %d %d %d\n",header->width, header->height, a,b,c,f,i);
173             header->bpp = a;
174             header->mode = b;
175             return 1;
176         } else {
177             fseek(fi, len, SEEK_CUR);
178         }
179         free(data);
180     }
181     return 0;
182 }
183
184 typedef unsigned char byte;
185 #define ABS(a) ((a)>0?(a):(-(a)))
186 byte inline PaethPredictor (byte a,byte b,byte c)
187 {
188         // a = left, b = above, c = upper left
189         int p = a + b - c;        // initial estimate
190         int pa = ABS(p - a);      // distances to a, b, c
191         int pb = ABS(p - b);
192         int pc = ABS(p - c);
193         // return nearest of a,b,c,
194         // breaking ties in order a,b,c.
195         if (pa <= pb && pa <= pc) 
196                 return a;
197         else if (pb <= pc) 
198                 return b;
199         else return c;
200 }
201
202 void applyfilter(int mode, U8*src, U8*old, U8*dest, int width)
203 {
204     int x;
205     unsigned char lastr=0;
206     unsigned char lastg=0;
207     unsigned char lastb=0;
208     unsigned char upperlastr=0;
209     unsigned char upperlastg=0;
210     unsigned char upperlastb=0;
211
212     if(mode==0) {
213         for(x=0;x<width;x++) {
214             dest[0] = 255;
215             dest[1] = src[0];
216             dest[2] = src[1];
217             dest[3] = src[2];
218             dest+=4;
219             src+=3;
220         }
221     }
222     else if(mode==1) {
223         for(x=0;x<width;x++) {
224             dest[0] = 255;
225             dest[1] = src[0]+lastr;
226             dest[2] = src[1]+lastg;
227             dest[3] = src[2]+lastb;
228             lastr = dest[1];
229             lastg = dest[2];
230             lastb = dest[3];
231             dest+=4;
232             src+=3;
233         }
234     }
235     else if(mode==2) {
236         for(x=0;x<width;x++) {
237             dest[0] = 255;
238             dest[1] = src[0]+old[1];
239             dest[2] = src[1]+old[2];
240             dest[3] = src[2]+old[3];
241             dest+=4;
242             old+=4;
243             src+=3;
244         }
245     }
246     else if(mode==3) {
247         for(x=0;x<width;x++) {
248             dest[0] = 255;
249             dest[1] = src[0]+(old[1]+lastr)/2;
250             dest[2] = src[1]+(old[2]+lastg)/2;
251             dest[3] = src[2]+(old[3]+lastb)/2;
252             lastr = dest[1];
253             lastg = dest[2];
254             lastb = dest[3];
255             dest+=4;
256             old+=4;
257             src+=3;
258         }
259     }
260     else if(mode==4) {
261         for(x=0;x<width;x++) {
262             dest[0] = 255;
263             dest[1] = src[0]+PaethPredictor(lastr,old[1],upperlastr);
264             dest[2] = src[1]+PaethPredictor(lastg,old[2],upperlastg);
265             dest[3] = src[2]+PaethPredictor(lastb,old[3],upperlastb);
266             lastr = dest[1];
267             lastg = dest[2];
268             lastb = dest[3];
269             upperlastr = old[1];
270             upperlastg = old[2];
271             upperlastb = old[3];
272             dest+=4;
273             old+=4;
274             src+=3;
275         }
276     }    
277
278 }
279
280 void applyfilter1(int mode, U8*src, U8*old, U8*dest, int width)
281 {
282     int x;
283     unsigned char last=0;
284     unsigned char upperlast=0;
285
286     if(mode==0) {
287         for(x=0;x<width;x++) {
288             *dest = *src;
289             dest++;
290             src++;
291         }
292     }
293     else if(mode==1) {
294         for(x=0;x<width;x++) {
295             *dest = *src+last;
296             last = *dest;
297             dest++;
298             src++;
299         }
300     }
301     else if(mode==2) {
302         for(x=0;x<width;x++) {
303             *dest = *src+*old;
304             dest++;
305             old++;
306             src++;
307         }
308     }
309     else if(mode==3) {
310         for(x=0;x<width;x++) {
311             *dest = *src+(*old+last)/2;
312             dest++;
313             old++;
314             src++;
315         }
316     }
317     else if(mode==4) {
318         for(x=0;x<width;x++) {
319             *dest = *src+PaethPredictor(last,*old,upperlast);
320             last = *dest;
321             upperlast = *old;
322             dest++;
323             old++;
324             src++;
325         }
326     }    
327
328 }
329
330 TAG *MovieAddFrame(SWF * swf, TAG * t, char *sname, int id)
331 {
332     SHAPE *s;
333     SRECT r;
334     MATRIX m;
335     int fs;
336
337     char tagid[4];
338     int len;
339     U8*data;
340     U8*imagedata;
341     unsigned long int imagedatalen;
342     U8*palette = 0;
343     int palettelen = 0;
344     struct png_header header;
345     int bypp;
346
347     FILE *fi;
348     U8 *scanline;
349
350     if ((fi = fopen(sname, "rb")) == NULL) {
351         if (VERBOSE(1))
352             fprintf(stderr, "Read access failed: %s\n", sname);
353         return t;
354     }
355
356     if(!png_read_header(fi, &header))
357         return 0;
358
359     if(header.mode == 3) bypp = 1;
360     else
361     if(header.mode == 2) bypp = 3;
362     else
363         return 0;
364     imagedatalen = bypp * header.width * header.height + 65536;
365     imagedata = malloc(imagedatalen);
366
367     fseek(fi,8,SEEK_SET);
368     while(!feof(fi))
369     {
370         if(!png_read_chunk(&tagid, &len, &data, fi))
371             break;
372         if(!strncmp(tagid, "IEND", 4)) {
373             break;
374         }
375         if(!strncmp(tagid, "PLTE", 4)) {
376             palette = data;
377             palettelen = len/3;
378             data = 0;
379             if(VERBOSE(2))
380                 printf("%d colors in palette\n", palettelen);
381         }
382         if(!strncmp(tagid, "IDAT", 4)) {
383             if(uncompress(imagedata, &imagedatalen, data, len) != Z_OK) {
384                 fprintf(stderr, "Couldn't uncompress %s!\n", sname);
385                 return 0;
386             }
387         }
388         if(data)
389             free(data);
390     }
391
392     t = swf_InsertTag(t, ST_DEFINEBITSLOSSLESS);
393     swf_SetU16(t, id);          // id
394     if(header.mode == 2) {
395         U8*data2 = malloc(header.width*header.height*4);
396         int i,s=0;
397         int x,y;
398         int pos=0;
399         /* 24->32 bit conversion */
400         for(y=0;y<header.height;y++) {
401             int mode = imagedata[pos++]; //filter mode
402
403             U8*src = &imagedata[pos];
404             U8*dest = &data2[(y*header.width)*4];
405             U8*old;
406             if(!y) {
407                 memset(data2,0,header.width*4);
408                 old = &data2[y*header.width*4];
409             } else {
410                 old = &data2[(y-1)*header.width*4];
411             }
412             applyfilter(mode, src, old, dest, header.width);
413             pos+=header.width*3;
414         }
415         swf_SetLosslessBits(t, header.width, header.height, data2, BMF_32BIT);
416         free(data2);
417     }
418     else {
419         RGBA*rgba = (RGBA*)malloc(palettelen*sizeof(RGBA));
420         int swf_width = BYTES_PER_SCANLINE(header.width);
421         U8*data2 = malloc(swf_width*header.height);
422         int i,x,y;
423         int pos=0;
424         if(!palette) {
425             fprintf(stderr, "Error: No palette found!\n");
426             exit(1);
427         }
428         /* 24->32 bit conversion */
429         for(i=0;i<palettelen;i++) {
430             rgba[i].r = palette[i*3+0];
431             rgba[i].g = palette[i*3+1];
432             rgba[i].b = palette[i*3+2];
433             rgba[i].a = 255;
434         }
435         for(y=0;y<header.height;y++) {
436             int mode = imagedata[pos++]; //filter mode
437             U8*src = &imagedata[pos];
438             U8*dest = &data2[y*swf_width];
439             U8*old;
440             if(!y) {
441                 memset(data2,0,swf_width);
442                 old = &data2[y*swf_width];
443             } else {
444                 old = &data2[(y-1)*swf_width];
445             }
446             applyfilter1(mode, src, old, dest, header.width);
447             pos+=header.width;
448         }
449         swf_SetLosslessBitsIndexed(t, header.width, header.height, data2, rgba, palettelen);
450         free(rgba);
451         free(data2);
452     }
453
454     t = swf_InsertTag(t, ST_DEFINESHAPE);
455
456     swf_ShapeNew(&s);
457     swf_GetMatrix(NULL, &m);
458     m.sx = 20 * 0x10000;
459     m.sy = 20 * 0x10000;
460     fs = swf_ShapeAddBitmapFillStyle(s, &m, id, 0);
461
462     swf_SetU16(t, id + 1);      // id
463
464     r.xmin = r.ymin = 0;
465     r.xmax = header.width * 20;
466     r.ymax = header.height * 20;
467     swf_SetRect(t, &r);
468
469     swf_SetShapeHeader(t, s);
470
471     swf_ShapeSetAll(t, s, 0, 0, 0, fs, 0);
472     swf_ShapeSetLine(t, s, r.xmax, 0);
473     swf_ShapeSetLine(t, s, 0, r.ymax);
474     swf_ShapeSetLine(t, s, -r.xmax, 0);
475     swf_ShapeSetLine(t, s, 0, -r.ymax);
476
477     swf_ShapeSetEnd(t);
478
479     t = swf_InsertTag(t, ST_REMOVEOBJECT2);
480     swf_SetU16(t, 1);           // depth
481
482     t = swf_InsertTag(t, ST_PLACEOBJECT2);
483
484     swf_GetMatrix(NULL, &m);
485     m.tx = (swf->movieSize.xmax - (int) header.width * 20) / 2;
486     m.ty = (swf->movieSize.ymax - (int) header.height * 20) / 2;
487     swf_ObjectPlace(t, id + 1, 1, &m, NULL, NULL);
488
489     t = swf_InsertTag(t, ST_SHOWFRAME);
490
491     fclose(fi);
492
493     return t;
494 }
495
496
497 int CheckInputFile(char *fname, char **realname)
498 {
499     FILE *fi;
500     char *s = malloc(strlen(fname) + 5);
501     struct png_header head;
502
503     if (!s)
504         exit(2);
505     (*realname) = s;
506     strcpy(s, fname);
507
508     // Check whether file exists (with typical extensions)
509
510     if ((fi = fopen(s, "rb")) == NULL) {
511         sprintf(s, "%s.png", fname);
512         if ((fi = fopen(s, "rb")) == NULL) {
513             sprintf(s, "%s.PNG", fname);
514             if ((fi = fopen(s, "rb")) == NULL) {
515                 sprintf(s, "%s.Png", fname);
516                 if ((fi = fopen(s, "rb")) == NULL)
517                     fprintf(stderr, "Couldn't open %s!\n", fname);
518                     return -1;
519             }
520         }
521     }
522
523     if(!png_read_header(fi, &head)) {
524         fprintf(stderr, "%s is not a PNG file!\n", fname);
525         return -1;
526     }
527
528     if (global.max_image_width < head.width)
529         global.max_image_width = head.width;
530     if (global.max_image_height < head.height)
531         global.max_image_height = head.height;
532
533     fclose(fi);
534
535     return 0;
536 }
537
538 int args_callback_option(char *arg, char *val)
539 {
540     int res = 0;
541     if (arg[1])
542         res = -1;
543     else
544         switch (arg[0]) {
545         case 'r':
546             if (val)
547                 global.framerate = atoi(val);
548             if ((global.framerate < 1) ||(global.framerate > 5000)) {
549                 if (VERBOSE(1))
550                     fprintf(stderr,
551                             "Error: You must specify a valid framerate between 1 and 10000.\n");
552                 exit(1);
553             }
554             res = 1;
555             break;
556
557         case 'o':
558             if (val)
559                 global.outfile = val;
560             res = 1;
561             break;
562
563         case 'v':
564             if (val)
565                 global.verbose = atoi(val);
566             res = 1;
567             break;
568
569         case 'X':
570             if (val)
571                 global.force_width = atoi(val);
572             res = 1;
573             break;
574
575         case 'Y':
576             if (val)
577                 global.force_height = atoi(val);
578             res = 1;
579             break;
580
581         case 'V':
582             printf("png2swf - part of %s %s\n", PACKAGE, VERSION);
583             exit(0);
584
585         default:
586             res = -1;
587             break;
588         }
589
590     if (res < 0) {
591         if (VERBOSE(1))
592             fprintf(stderr, "Unknown option: -%s\n", arg);
593         exit(1);
594         return 0;
595     }
596     return res;
597 }
598
599 struct options_t options[] = 
600
601 {"o", "output"},
602 {"r", "rate"},
603 {"v", "verbose"},
604 {"X", "width"},
605 {"Y", "height"},
606 {"V", "version"},
607 };
608
609 int args_callback_longoption(char *name, char *val)
610 {
611     return args_long2shortoption(options, name, val);
612 }
613
614 int args_callback_command(char *arg, char *next)        // actually used as filename
615 {
616     char *s;
617     if (CheckInputFile(arg, &s) < 0) {
618         if (VERBOSE(1))
619             fprintf(stderr, "Error opening input file: %s\n", arg);
620         free(s);
621     } else {
622         image[global.nfiles].filename = s;
623         global.nfiles++;
624         if (global.nfiles >= MAX_INPUT_FILES) {
625             if (VERBOSE(1))
626                 fprintf(stderr, "Error: Too many input files.\n");
627             exit(1);
628         }
629     }
630     return 0;
631 }
632
633 void args_callback_usage(char *name)
634 {
635     printf("Usage: %s  [-options [value]] imagefiles[.png] [...]\n", name);
636     printf("-r framerate          (rate) Set movie framerate (100/sec)\n");
637     printf("-o outputfile         (output) Set name for SWF output file\n");
638     printf("-X pixel              (width) Force movie width to pixel (default: autodetect)\n");
639     printf("-Y pixel              (height) Force movie height to pixel (default: autodetect)\n");
640     printf("-v level              (verbose) Set verbose level (0=quiet, 1=default, 2=debug)\n");
641     printf("-V                    (version) Print version information and exit\n");
642 }
643
644
645 int main(int argc, char **argv)
646 {
647     SWF swf;
648     TAG *t;
649
650     memset(&global, 0x00, sizeof(global));
651
652     global.framerate = 100;
653     global.verbose = 1;
654
655     processargs(argc, argv);
656
657     if (VERBOSE(2))
658         fprintf(stderr, "Processing %i file(s)...\n", global.nfiles);
659
660     t = MovieStart(&swf, global.framerate,
661                    global.force_width ? global.force_width : global.
662                    max_image_width,
663                    global.force_height ? global.force_height : global.
664                    max_image_height);
665
666     {
667         int i;
668         for (i = 0; i < global.nfiles; i++) {
669             if (VERBOSE(3))
670                 fprintf(stderr, "[%03i] %s\n", i,
671                         image[i].filename);
672             t = MovieAddFrame(&swf, t, image[i].filename, (i * 2) + 1);
673             free(image[i].filename);
674         }
675     }
676
677     MovieFinish(&swf, t, global.outfile);
678
679     return 0;
680 }