added new files
[swftools.git] / src / jpeg2swf.c
1 /* jpeg2swf.c
2
3    JPEG to SWF converter tool
4
5    Part of the swftools package.
6
7    Copyright (c) 2001 Rainer Böhme <rfxswf@reflex-studio.de>
8    Copyright (c) 2002,2003 Matthias Kramm <kramm@quiss.org>
9  
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
23  
24 #include <stdio.h>
25 #include <math.h>
26 #include <fcntl.h>
27 #include <jpeglib.h>
28 #include "../lib/rfxswf.h"
29 #include "../lib/args.h"        // not really a header ;-)
30
31 #define MAX_INPUT_FILES 1024
32 #define VERBOSE(x) (global.verbose>=x)
33
34 struct {
35     int quality;
36     float framerate;
37     int max_image_width;
38     int max_image_height;
39     int force_width;
40     int force_height;
41     int nfiles;
42     int verbose;
43     char *outfile;
44     int mx;
45     int next_id;
46     char *asset_name;
47     int version;
48     int xoffset;
49     int yoffset;
50     int fit_to_movie;
51 } global;
52
53 typedef struct _image {
54     char *filename;
55     int quality;
56     int width;
57     int height;
58 } image_t;
59 image_t image[MAX_INPUT_FILES];
60
61 VIDEOSTREAM stream;
62
63 TAG *MovieStart(SWF * swf, float framerate, int dx, int dy)
64 {
65     TAG *t;
66     RGBA rgb;
67
68     memset(swf, 0x00, sizeof(SWF));
69
70     swf->fileVersion = global.version;
71     swf->frameRate = (int)(256.0 * framerate);
72     swf->movieSize.xmin = global.xoffset * 20;
73     swf->movieSize.ymin = global.yoffset * 20;
74     swf->movieSize.xmax = swf->movieSize.xmin + dx * 20;
75     swf->movieSize.ymax = swf->movieSize.ymin + dy * 20;
76
77     t = swf->firstTag = swf_InsertTag(NULL, ST_SETBACKGROUNDCOLOR);
78
79     rgb.r = rgb.g = rgb.b = rgb.a = 0x00;
80     swf_SetRGB(t, &rgb);
81
82     if (global.mx) {
83         t = swf_InsertTag(t, ST_DEFINEVIDEOSTREAM);
84         swf_SetU16(t, 0xf00d);
85         swf_SetVideoStreamDefine(t, &stream, 65535, dx, dy);
86     } else if (global.asset_name) {
87         t = swf_InsertTag(t, ST_DEFINESPRITE);
88         swf_SetU16(t, 1);
89         swf_SetU16(t, global.next_id++);
90     }
91
92     return t;
93 }
94
95 int MovieFinish(SWF * swf, TAG * t, char *sname)
96 {
97     int handle, so = fileno(stdout);
98
99     if (global.asset_name) {
100         SWFPLACEOBJECT obj;
101
102         t = swf_InsertTag(t, ST_END);
103         t = swf_InsertTag(t, ST_EXPORTASSETS);
104         swf_SetU16(t, 1);
105         swf_SetU16(t, 1);
106         swf_SetString(t, global.asset_name);
107
108         t = swf_InsertTag(t, ST_PLACEOBJECT2);
109         swf_GetPlaceObject(0, &obj);
110         obj.depth = 1;
111         obj.id = 1;
112         swf_SetPlaceObject(t, &obj);
113
114         t = swf_InsertTag(t, ST_SHOWFRAME);
115     }
116
117     t = swf_InsertTag(t, ST_END);
118
119     if ((!isatty(so)) && (!sname))
120         handle = so;
121     else {
122         if (!sname)
123             sname = "output.swf";
124         handle = open(sname, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
125     }
126     if(global.version >= 6) {
127         if (swf_WriteSWC(handle, swf)<0) 
128                 fprintf(stderr, "Unable to write output file: %s\n", sname);
129     } else {
130         if (swf_WriteSWF(handle, swf)<0) 
131                 fprintf(stderr, "Unable to write output file: %s\n", sname);
132     }
133
134     if (handle != so)
135         close(handle);
136
137     swf_FreeTags(swf);
138     return 0;
139 }
140
141 int getJPEG(char*filename, int* width, int* height, RGBA**pic2)
142 {
143     struct jpeg_decompress_struct cinfo;
144     struct jpeg_error_mgr jerr;
145     struct jpeg_source_mgr mgr;
146     int x,y;
147     FILE*f;
148     RGBA*pic,*js;
149     U8*buf;
150
151     if ((f=fopen(filename,"rb"))==NULL) {
152         fprintf(stderr, "rfxswf: file open error\n");
153         return 0;
154     }
155
156     cinfo.err = jpeg_std_error(&jerr);
157     jpeg_create_decompress(&cinfo); 
158     jpeg_stdio_src(&cinfo, f);
159     jpeg_read_header(&cinfo, TRUE);
160     jpeg_start_decompress(&cinfo);
161
162     pic = malloc(cinfo.output_width*cinfo.output_height*sizeof(RGBA));
163     buf = malloc(cinfo.output_width*4);
164     memset(pic, 255, cinfo.output_width*cinfo.output_height*sizeof(RGBA));
165     js = pic;
166
167     *width = cinfo.output_width;
168     *height = cinfo.output_height;
169     
170     for (y=0;y<cinfo.output_height;y++) {
171         int x;
172         jpeg_read_scanlines(&cinfo,&buf,1);
173
174         if(cinfo.out_color_space == JCS_GRAYSCALE) {
175             for(x=0;x<cinfo.output_width;x++) {
176                 js[x].r = js[x].g = js[x].b = buf[x];
177             }
178         } else if(cinfo.out_color_space == JCS_RGB) {
179             for (x=0;x<cinfo.output_width;x++)
180             { 
181                 js[x].r = buf[x*3+0];
182                 js[x].g = buf[x*3+1];
183                 js[x].b = buf[x*3+2];
184             }
185         } else if(cinfo.out_color_space == JCS_YCCK) {
186             //FIXME
187             fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
188             return -1;
189         } else if(cinfo.out_color_space == JCS_YCbCr) {
190             for(x=0;x<cinfo.output_width;x++) {
191                 int y = buf[x*3+0];
192                 int u = buf[x*3+1];
193                 int v = buf[x*3+1];
194                 js[x].r = y + ((360*(v-128))>>8);
195                 js[x].g = y - ((88*(u-128)+183*(v-128))>>8);
196                 js[x].b = y + ((455 * (u-128))>>8);
197             }
198         }
199         else if(cinfo.out_color_space == JCS_CMYK) 
200         { 
201             for(x=0;x<cinfo.output_width;x++) {
202                   int white = 255 - buf[x*4+3];
203                   js[x].r = white - ((buf[x*4]*white)>>8);
204                   js[x].g = white - ((buf[x*4+1]*white)>>8);
205                   js[x].b = white - ((buf[x*4+2]*white)>>8);
206             }
207         }
208         js += cinfo.output_width;
209     }
210
211     jpeg_finish_decompress(&cinfo);
212     jpeg_destroy_decompress(&cinfo);
213     
214     free(buf);
215     *pic2 = pic;
216     return 1;
217 }
218
219
220 int frame = 0;
221 TAG *MovieAddFrame(SWF * swf, TAG * t, char *sname, int quality, 
222                    int width, int height)
223 {
224     SHAPE *s;
225     SRECT r;
226     MATRIX m;
227     int fs;
228     int movie_width = swf->movieSize.xmax - swf->movieSize.xmin;
229     int movie_height = swf->movieSize.ymax - swf->movieSize.ymin;
230
231     if(global.mx) {
232         int sizex, sizey;
233         RGBA * pic2;
234         SWFPLACEOBJECT obj;
235         int quant=0;
236         getJPEG(sname, &sizex, &sizey, &pic2);
237         if(sizex != stream.owidth || sizey != stream.oheight) {
238             fprintf(stderr, "All images must have the same dimensions if using -m!");
239             exit(1);
240         }
241
242         t = swf_InsertTag(t, ST_VIDEOFRAME);
243         swf_SetU16(t, 0xf00d);
244         quant = 1+(30-(30*quality)/100);
245         if(!(frame%20)) {
246             swf_SetVideoStreamIFrame(t, &stream, pic2, quant);
247         } else {
248             swf_SetVideoStreamPFrame(t, &stream, pic2, quant);
249         }
250
251         t = swf_InsertTag(t, ST_PLACEOBJECT2);
252         swf_GetPlaceObject(0, &obj);
253         if(frame==0) {
254             obj.depth = 1;
255             obj.id = 0xf00d;
256         } else {
257             obj.depth = 1;
258             obj.move = 1;
259             obj.ratio = frame;
260         }
261         swf_SetPlaceObject(t,&obj);
262
263         t = swf_InsertTag(t, ST_SHOWFRAME);
264     } else {
265         t = swf_InsertTag(t, ST_DEFINEBITSJPEG2);
266         swf_SetU16(t, global.next_id);          // id
267         swf_SetJPEGBits(t,sname,quality);
268
269         t = swf_InsertTag(t, ST_DEFINESHAPE);
270         swf_ShapeNew(&s);
271         swf_GetMatrix(NULL, &m);
272         if (global.fit_to_movie) {
273             m.sx = 0x10000 * movie_width / width;
274             m.sy = 0x10000 * movie_height / height;
275             width = movie_width / 20;
276             height = movie_height / 20;
277         } else {
278                 m.sx = 20 * 0x10000;
279                 m.sy = 20 * 0x10000;
280         }
281         m.tx = global.xoffset * 20;
282         m.ty = global.yoffset * 20;
283         fs = swf_ShapeAddBitmapFillStyle(s, &m, global.next_id, 1);
284         global.next_id++;
285         swf_SetU16(t, global.next_id);  // id
286         r.xmin = global.xoffset * 20;
287         r.ymin = global.yoffset * 20;
288         r.xmax = r.xmin + width * 20;
289         r.ymax = r.ymin + height * 20;
290         swf_SetRect(t, &r);
291         swf_SetShapeHeader(t, s);
292         swf_ShapeSetAll(t, s, r.xmin, r.ymin, 0, fs, 0);
293         swf_ShapeSetLine(t, s, r.xmax - r.xmin, 0);
294         swf_ShapeSetLine(t, s, 0, r.ymax - r.ymin);
295         swf_ShapeSetLine(t, s, -r.xmax + r.xmin, 0);
296         swf_ShapeSetLine(t, s, 0, -r.ymax + r.ymin);
297         swf_ShapeSetEnd(t);
298
299         if(frame) {
300             t = swf_InsertTag(t, ST_REMOVEOBJECT2);
301             swf_SetU16(t, 1);           // depth
302         }
303
304         t = swf_InsertTag(t, ST_PLACEOBJECT2);
305         swf_GetMatrix(NULL, &m);
306         m.tx = (movie_width - width * 20) / 2;
307         m.ty = (movie_height - height * 20) / 2;
308         swf_ObjectPlace(t, global.next_id, 1, &m, NULL, NULL);
309         global.next_id++;
310         t = swf_InsertTag(t, ST_SHOWFRAME);
311     }
312     frame++;
313
314     return t;
315 }
316
317 int CheckInputFile(image_t* i, char *fname, char **realname)
318 {
319     struct jpeg_decompress_struct cinfo;
320     struct jpeg_error_mgr jerr;
321     FILE *f;
322     char *s = malloc(strlen(fname) + 5);
323     int width, height;
324
325     if (!s)
326         exit(2);
327     (*realname) = s;
328     strcpy(s, fname);
329
330     // Check whether file exists (with typical extensions)
331
332     if ((f = fopen(s, "rb")) == NULL) {
333         sprintf(s, "%s.jpg", fname);
334         if ((f = fopen(s, "rb")) == NULL) {
335             sprintf(s, "%s.jpeg", fname);
336             if ((f = fopen(s, "rb")) == NULL) {
337                 sprintf(s, "%s.JPG", fname);
338                 if ((f = fopen(s, "rb")) == NULL) {
339                     sprintf(s, "%s.JPEG", fname);
340                     if ((f = fopen(s, "rb")) == NULL)
341                         return -1;
342                 }
343             }
344         }
345     }
346
347     cinfo.err = jpeg_std_error(&jerr);
348     jpeg_create_decompress(&cinfo);
349     jpeg_stdio_src(&cinfo, f);
350     jpeg_read_header(&cinfo, TRUE);
351
352     width = cinfo.image_width;
353     height = cinfo.image_height;
354
355     i->width = width;
356     i->height = height;
357
358     // Get image dimensions
359
360     if (global.max_image_width < width)
361         global.max_image_width = width;
362     if (global.max_image_height < height)
363         global.max_image_height = height;
364
365     jpeg_destroy_decompress(&cinfo);
366     fclose(f);
367
368     return 0;
369 }
370
371 int args_callback_option(char *arg, char *val)
372 {
373     int res = 0;
374     if (arg[1])
375         res = -1;
376     else
377         switch (arg[0]) {
378         case 'q':
379             if (val)
380                 global.quality = atoi(val);
381             if ((global.quality < 1) ||(global.quality > 100)) {
382                 if (VERBOSE(1))
383                     fprintf(stderr,
384                             "Error: You must specify a valid quality between 1 and 100.\n");
385                 exit(1);
386             }
387             res = 1;
388             break;
389
390         case 'r':
391             if (val)
392                 global.framerate = atof(val);
393             if ((global.framerate < 1.0/256) || (global.framerate >= 256.0)) {
394                 if (VERBOSE(1))
395                     fprintf(stderr,
396                             "Error: You must specify a valid framerate between 1 and 10000.\n");
397                 exit(1);
398             }
399             res = 1;
400             break;
401
402         case 'o':
403             if (val)
404                 global.outfile = val;
405             res = 1;
406             break;
407
408         case 'v':
409             if (val)
410                 global.verbose = atoi(val);
411             res = 1;
412             break;
413
414         case 'X':
415             if (val)
416                 global.force_width = atoi(val);
417             res = 1;
418             break;
419
420         case 'm':
421             global.mx = 1;
422             global.version = 6;
423             return 0;
424
425         case 'z':
426             global.version = 6;
427             return 0;
428
429         case 'Y':
430             if (val)
431                 global.force_height = atoi(val);
432             res = 1;
433             break;
434
435         case 'V':
436             printf("jpeg2swf - part of %s %s\n", PACKAGE, VERSION);
437             exit(0);
438
439         case 'e':
440             if (val)
441                 global.asset_name = val;
442             res = 1;
443             break;
444
445         case 'x':
446             if (val) {
447                 global.xoffset = atoi(val);
448             }
449             res = 1;
450             break;
451
452         case 'y':
453             if (val) {
454                 global.yoffset = atoi(val);
455             }
456             res = 1;
457             break;
458
459         case 'f':
460             global.fit_to_movie = 1;
461             res = 0;
462             break;
463
464         default:
465             res = -1;
466             break;
467         }
468
469     if (res < 0) {
470         if (VERBOSE(1))
471             fprintf(stderr, "Unknown option: -%s\n", arg);
472         exit(1);
473         return 0;
474     }
475     return res;
476 }
477
478 static struct options_t options[] = {
479 {"o", "output"},
480 {"m", "mx"},
481 {"q", "quality"},
482 {"r", "rate"},
483 {"z", "zlib"},
484 {"X", "width"},
485 {"Y", "height"},
486 {"x", "xoffset"},
487 {"y", "yoffset"},
488 {"e", "export"},
489 {"f", "fit-to-movie"},
490 {"v", "verbose"},
491 {"V", "version"},
492 {0,0}
493 };
494
495 int args_callback_longoption(char *name, char *val)
496 {
497     return args_long2shortoption(options, name, val);
498 }
499
500 int args_callback_command(char *arg, char *next)        // actually used as filename
501 {
502     char *s;
503     image_t* i = &image[global.nfiles];
504     if (CheckInputFile(i, arg, &s) < 0) {
505         if (VERBOSE(1))
506             fprintf(stderr, "Unable to open input file: %s\n", arg);
507         free(s);
508     } else {
509         i->filename = s;
510         i->quality = global.quality;
511         global.nfiles++;
512         if (global.nfiles >= MAX_INPUT_FILES) {
513             if (VERBOSE(1))
514                 fprintf(stderr, "Error: Too many input files.\n");
515             exit(1);
516         }
517     }
518     return 0;
519 }
520
521 void args_callback_usage(char *name)
522 {
523     printf("\n");
524     printf("Usage: %s [-options [value]] imagefiles[.jpg]|[.jpeg] [...]\n", name);
525     printf("\n");
526     printf("-o , --output <outputfile>     Explicitly specify output file. (otherwise, output.swf will be used)\n");
527     printf("-m , --mx                      Use Flash MX H.263 compression (use for correlated images)\n");
528     printf("-q , --quality <quality>       Set compression quality (1-100, 1=worst, 100=best)\n");
529     printf("-r , --rate <framerate>         Set movie framerate (frames per second)\n");
530     printf("-z , --zlib <zlib>             Enable Flash 6 (MX) Zlib Compression\n");
531     printf("-x , --xoffset <offset>        horizontally offset images by <offset>\n");
532     printf("-y , --yoffset <offset>        vertically offset images by <offset>\n");
533     printf("-X , --width <width>           Force movie width to <width> (default: autodetect)\n");
534     printf("-Y , --height <height>         Force movie height to <height> (default: autodetect)\n");
535     printf("-f , --fit-to-movie            Fit images to movie size\n");
536     printf("-e , --export <assetname>      Make importable as asset with <assetname>\n");
537     printf("-v , --verbose <level>         Set verbose level to <level> (0=quiet, 1=default, 2=debug)\n");
538     printf("-V , --version                 Print version information and exit\n");
539     printf("\n");
540 }
541
542
543 int main(int argc, char **argv)
544 {
545     SWF swf;
546     TAG *t;
547
548     memset(&global, 0x00, sizeof(global));
549
550     global.quality = 60;
551     global.framerate = 1.0;
552     global.verbose = 1;
553     global.version = 4;
554     global.asset_name = NULL;
555     global.next_id = 1;
556     global.xoffset = 0;
557     global.yoffset = 0;
558     global.fit_to_movie = 0;
559         
560     processargs(argc, argv);
561
562     if (VERBOSE(2))
563         fprintf(stderr, "Processing %i file(s)...\n", global.nfiles);
564
565     t = MovieStart(&swf, global.framerate,
566                    global.force_width ? global.force_width : global.
567                    max_image_width,
568                    global.force_height ? global.force_height : global.
569                    max_image_height);
570
571     {
572         int i;
573         for (i = 0; i < global.nfiles; i++) {
574             if (VERBOSE(3))
575                 fprintf(stderr, "[%03i] %s (%i%%, 1/%i)\n", i,
576                         image[i].filename, image[i].quality);
577             t = MovieAddFrame(&swf, t, image[i].filename, image[i].quality,
578                               image[i].width, image[i].height);
579             free(image[i].filename);
580         }
581     }
582
583     MovieFinish(&swf, t, global.outfile);
584
585     return 0;
586 }