added "SHARED".
[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 version;
46 } global;
47
48 typedef struct _image {
49     char *filename;
50     int quality;
51     int width;
52     int height;
53 } image_t;
54 image_t image[MAX_INPUT_FILES];
55
56 VIDEOSTREAM stream;
57
58 TAG *MovieStart(SWF * swf, float framerate, int dx, int dy)
59 {
60     TAG *t;
61     RGBA rgb;
62
63     memset(swf, 0x00, sizeof(SWF));
64
65     swf->fileVersion = global.version;
66     swf->frameRate = (int)(256.0 * framerate);
67     swf->movieSize.xmax = dx * 20;
68     swf->movieSize.ymax = dy * 20;
69
70     t = swf->firstTag = swf_InsertTag(NULL, ST_SETBACKGROUNDCOLOR);
71
72     rgb.r = rgb.g = rgb.b = rgb.a = 0x00;
73     swf_SetRGB(t, &rgb);
74
75     if (global.mx) {
76         t = swf_InsertTag(t, ST_DEFINEVIDEOSTREAM);
77         swf_SetU16(t, 0xf00d);
78         swf_SetVideoStreamDefine(t, &stream, 65535, dx, dy);
79     }
80
81     return t;
82 }
83
84 int MovieFinish(SWF * swf, TAG * t, char *sname)
85 {
86     int handle, so = fileno(stdout);
87     t = swf_InsertTag(t, ST_END);
88
89     if ((!isatty(so)) && (!sname))
90         handle = so;
91     else {
92         if (!sname)
93             sname = "output.swf";
94         handle = open(sname, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
95     }
96     if(global.version >= 6) {
97         if (swf_WriteSWC(handle, swf)<0) 
98                 fprintf(stderr, "Unable to write output file: %s\n", sname);
99     } else {
100         if (swf_WriteSWF(handle, swf)<0) 
101                 fprintf(stderr, "Unable to write output file: %s\n", sname);
102     }
103
104     if (handle != so)
105         close(handle);
106
107     swf_FreeTags(swf);
108     return 0;
109 }
110
111 int getJPEG(char*filename, int* width, int* height, RGBA**pic2)
112 {
113     struct jpeg_decompress_struct cinfo;
114     struct jpeg_error_mgr jerr;
115     struct jpeg_source_mgr mgr;
116     int x,y;
117     FILE*f;
118     RGBA*pic,*js;
119     U8*buf;
120
121     if ((f=fopen(filename,"rb"))==NULL) {
122         fprintf(stderr, "rfxswf: file open error\n");
123         return 0;
124     }
125
126     cinfo.err = jpeg_std_error(&jerr);
127     jpeg_create_decompress(&cinfo); 
128     jpeg_stdio_src(&cinfo, f);
129     jpeg_read_header(&cinfo, TRUE);
130     jpeg_start_decompress(&cinfo);
131
132     pic = malloc(cinfo.output_width*cinfo.output_height*sizeof(RGBA));
133     buf = malloc(cinfo.output_width*4);
134     memset(pic, 255, cinfo.output_width*cinfo.output_height*sizeof(RGBA));
135     js = pic;
136
137     *width = cinfo.output_width;
138     *height = cinfo.output_height;
139     
140     for (y=0;y<cinfo.output_height;y++) {
141         int x;
142         jpeg_read_scanlines(&cinfo,&buf,1);
143
144         if(cinfo.out_color_space == JCS_GRAYSCALE) {
145             for(x=0;x<cinfo.output_width;x++) {
146                 js[x].r = js[x].g = js[x].b = buf[x];
147             }
148         } else if(cinfo.out_color_space == JCS_RGB) {
149             for (x=0;x<cinfo.output_width;x++)
150             { 
151                 js[x].r = buf[x*3+0];
152                 js[x].g = buf[x*3+1];
153                 js[x].b = buf[x*3+2];
154             }
155         } else if(cinfo.out_color_space == JCS_YCCK) {
156             //FIXME
157             fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
158             return -1;
159         } else if(cinfo.out_color_space == JCS_YCbCr) {
160             for(x=0;x<cinfo.output_width;x++) {
161                 int y = buf[x*3+0];
162                 int u = buf[x*3+1];
163                 int v = buf[x*3+1];
164                 js[x].r = y + ((360*(v-128))>>8);
165                 js[x].g = y - ((88*(u-128)+183*(v-128))>>8);
166                 js[x].b = y + ((455 * (u-128))>>8);
167             }
168         }
169         else if(cinfo.out_color_space == JCS_CMYK) 
170         { 
171             for(x=0;x<cinfo.output_width;x++) {
172                   int white = 255 - buf[x*4+3];
173                   js[x].r = white - ((buf[x*4]*white)>>8);
174                   js[x].g = white - ((buf[x*4+1]*white)>>8);
175                   js[x].b = white - ((buf[x*4+2]*white)>>8);
176             }
177         }
178         js += cinfo.output_width;
179     }
180
181     jpeg_finish_decompress(&cinfo);
182     jpeg_destroy_decompress(&cinfo);
183     
184     free(buf);
185     *pic2 = pic;
186     return 1;
187 }
188
189
190 int frame = 0;
191 TAG *MovieAddFrame(SWF * swf, TAG * t, char *sname, int quality, 
192                    int id, int width, int height)
193 {
194     SHAPE *s;
195     SRECT r;
196     MATRIX m;
197     int fs;
198
199
200     if(global.mx) {
201         int sizex, sizey;
202         RGBA * pic2;
203         SWFPLACEOBJECT obj;
204         int quant=0;
205         getJPEG(sname, &sizex, &sizey, &pic2);
206         if(sizex != stream.owidth || sizey != stream.oheight) {
207             fprintf(stderr, "All images must have the same dimensions if using -m!");
208             exit(1);
209         }
210
211         t = swf_InsertTag(t, ST_VIDEOFRAME);
212         swf_SetU16(t, 0xf00d);
213         quant = 1+(30-(30*quality)/100);
214         if(!(frame&127)) {
215             swf_SetVideoStreamIFrame(t, &stream, pic2, quant);
216         } else {
217             swf_SetVideoStreamPFrame(t, &stream, pic2, quant);
218         }
219
220         t = swf_InsertTag(t, ST_PLACEOBJECT2);
221         swf_GetPlaceObject(0, &obj);
222         if(frame==0) {
223             obj.depth = 1;
224             obj.id = 0xf00d;
225         } else {
226             obj.depth = 1;
227             obj.move = 1;
228             obj.ratio = frame;
229         }
230         swf_SetPlaceObject(t,&obj);
231
232         t = swf_InsertTag(t, ST_SHOWFRAME);
233     } else {
234         t = swf_InsertTag(t, ST_DEFINEBITSJPEG2);
235         swf_SetU16(t, id);              // id
236         swf_SetJPEGBits(t,sname,quality);
237
238         t = swf_InsertTag(t, ST_DEFINESHAPE);
239         swf_ShapeNew(&s);
240         swf_GetMatrix(NULL, &m);
241         m.sx = 20 * 0x10000;
242         m.sy = 20 * 0x10000;
243         fs = swf_ShapeAddBitmapFillStyle(s, &m, id, 0);
244         swf_SetU16(t, id + 1);  // id
245         r.xmin = r.ymin = 0;
246         r.xmax = width * 20;
247         r.ymax = height * 20;
248         swf_SetRect(t, &r);
249         swf_SetShapeHeader(t, s);
250         swf_ShapeSetAll(t, s, 0, 0, 0, fs, 0);
251         swf_ShapeSetLine(t, s, r.xmax, 0);
252         swf_ShapeSetLine(t, s, 0, r.ymax);
253         swf_ShapeSetLine(t, s, -r.xmax, 0);
254         swf_ShapeSetLine(t, s, 0, -r.ymax);
255         swf_ShapeSetEnd(t);
256
257         if(frame) {
258             t = swf_InsertTag(t, ST_REMOVEOBJECT2);
259             swf_SetU16(t, 1);           // depth
260         }
261
262         t = swf_InsertTag(t, ST_PLACEOBJECT2);
263         swf_GetMatrix(NULL, &m);
264         m.tx = (swf->movieSize.xmax - (int) width * 20) / 2;
265         m.ty = (swf->movieSize.ymax - (int) height * 20) / 2;
266         swf_ObjectPlace(t, id + 1, 1, &m, NULL, NULL);
267
268         t = swf_InsertTag(t, ST_SHOWFRAME);
269     }
270     frame++;
271
272     return t;
273 }
274
275 int CheckInputFile(image_t* i, char *fname, char **realname)
276 {
277     struct jpeg_decompress_struct cinfo;
278     struct jpeg_error_mgr jerr;
279     FILE *f;
280     char *s = malloc(strlen(fname) + 5);
281     int width, height;
282
283     if (!s)
284         exit(2);
285     (*realname) = s;
286     strcpy(s, fname);
287
288     // Check whether file exists (with typical extensions)
289
290     if ((f = fopen(s, "rb")) == NULL) {
291         sprintf(s, "%s.jpg", fname);
292         if ((f = fopen(s, "rb")) == NULL) {
293             sprintf(s, "%s.jpeg", fname);
294             if ((f = fopen(s, "rb")) == NULL) {
295                 sprintf(s, "%s.JPG", fname);
296                 if ((f = fopen(s, "rb")) == NULL) {
297                     sprintf(s, "%s.JPEG", fname);
298                     if ((f = fopen(s, "rb")) == NULL)
299                         return -1;
300                 }
301             }
302         }
303     }
304
305     cinfo.err = jpeg_std_error(&jerr);
306     jpeg_create_decompress(&cinfo);
307     jpeg_stdio_src(&cinfo, f);
308     jpeg_read_header(&cinfo, TRUE);
309
310     width = cinfo.image_width;
311     height = cinfo.image_height;
312
313     i->width = width;
314     i->height = height;
315
316     // Get image dimensions
317
318     if (global.max_image_width < width)
319         global.max_image_width = width;
320     if (global.max_image_height < height)
321         global.max_image_height = height;
322
323     jpeg_destroy_decompress(&cinfo);
324     fclose(f);
325
326     return 0;
327 }
328
329 int args_callback_option(char *arg, char *val)
330 {
331     int res = 0;
332     if (arg[1])
333         res = -1;
334     else
335         switch (arg[0]) {
336         case 'q':
337             if (val)
338                 global.quality = atoi(val);
339             if ((global.quality < 1) ||(global.quality > 100)) {
340                 if (VERBOSE(1))
341                     fprintf(stderr,
342                             "Error: You must specify a valid quality between 1 and 100.\n");
343                 exit(1);
344             }
345             res = 1;
346             break;
347
348         case 'r':
349             if (val)
350                 global.framerate = atof(val);
351             if ((global.framerate < 1.0/256) || (global.framerate >= 256.0)) {
352                 if (VERBOSE(1))
353                     fprintf(stderr,
354                             "Error: You must specify a valid framerate between 1 and 10000.\n");
355                 exit(1);
356             }
357             res = 1;
358             break;
359
360         case 'o':
361             if (val)
362                 global.outfile = val;
363             res = 1;
364             break;
365
366         case 'v':
367             if (val)
368                 global.verbose = atoi(val);
369             res = 1;
370             break;
371
372         case 'X':
373             if (val)
374                 global.force_width = atoi(val);
375             res = 1;
376             break;
377
378         case 'm':
379             global.mx = 1;
380             global.version = 6;
381             return 0;
382
383         case 'z':
384             global.version = 6;
385             return 0;
386
387         case 'Y':
388             if (val)
389                 global.force_height = atoi(val);
390             res = 1;
391             break;
392
393         case 'V':
394             printf("jpeg2swf - part of %s %s\n", PACKAGE, VERSION);
395             exit(0);
396
397         default:
398             res = -1;
399             break;
400         }
401
402     if (res < 0) {
403         if (VERBOSE(1))
404             fprintf(stderr, "Unknown option: -%s\n", arg);
405         exit(1);
406         return 0;
407     }
408     return res;
409 }
410
411 static struct options_t options[] = {
412 {"o", "output"},
413 {"m", "mx"},
414 {"q", "quality"},
415 {"r", "rate"},
416 {"z", "zlib"},
417 {"X", "width"},
418 {"Y", "height"},
419 {"v", "verbose"},
420 {"V", "version"},
421 {0,0}
422 };
423
424 int args_callback_longoption(char *name, char *val)
425 {
426     return args_long2shortoption(options, name, val);
427 }
428
429 int args_callback_command(char *arg, char *next)        // actually used as filename
430 {
431     char *s;
432     image_t* i = &image[global.nfiles];
433     if (CheckInputFile(i, arg, &s) < 0) {
434         if (VERBOSE(1))
435             fprintf(stderr, "Unable to open input file: %s\n", arg);
436         free(s);
437     } else {
438         i->filename = s;
439         i->quality = global.quality;
440         global.nfiles++;
441         if (global.nfiles >= MAX_INPUT_FILES) {
442             if (VERBOSE(1))
443                 fprintf(stderr, "Error: Too many input files.\n");
444             exit(1);
445         }
446     }
447     return 0;
448 }
449
450 void args_callback_usage(char *name)
451 {
452     printf("\n");
453     printf("Usage: %s [-options [value]] imagefiles[.jpg]|[.jpeg] [...]\n", name);
454     printf("\n");
455     printf("-o , --output <outputfile>     Explicitly specify output file. (otherwise, output.swf will be used)\n");
456     printf("-m , --mx                      Use Flash MX H.263 compression (use for correlated images)\n");
457     printf("-q , --quality <quality>       Set compression quality (1-100, 1=worst, 100=best)\n");
458     printf("-r , --rate <framerate>         Set movie framerate (frames per second)\n");
459     printf("-z , --zlib <zlib>             Enable Flash 6 (MX) Zlib Compression\n");
460     printf("-X , --width <width>           Force movie width to <width> (default: autodetect)\n");
461     printf("-Y , --height <height>         Force movie height to <height> (default: autodetect)\n");
462     printf("-v , --verbose <level>         Set verbose level to <level> (0=quiet, 1=default, 2=debug)\n");
463     printf("-V , --version                 Print version information and exit\n");
464     printf("\n");
465 }
466
467
468 int main(int argc, char **argv)
469 {
470     SWF swf;
471     TAG *t;
472
473     memset(&global, 0x00, sizeof(global));
474
475     global.quality = 60;
476     global.framerate = 1.0;
477     global.verbose = 1;
478     global.version = 4;
479
480     processargs(argc, argv);
481
482     if (VERBOSE(2))
483         fprintf(stderr, "Processing %i file(s)...\n", global.nfiles);
484
485     t = MovieStart(&swf, global.framerate,
486                    global.force_width ? global.force_width : global.
487                    max_image_width,
488                    global.force_height ? global.force_height : global.
489                    max_image_height);
490
491     {
492         int i;
493         for (i = 0; i < global.nfiles; i++) {
494             if (VERBOSE(3))
495                 fprintf(stderr, "[%03i] %s (%i%%, 1/%i)\n", i,
496                         image[i].filename, image[i].quality);
497             t = MovieAddFrame(&swf, t, image[i].filename, image[i].quality,
498                               (i * 2) + 1, 
499                               image[i].width, image[i].height);
500             free(image[i].filename);
501         }
502     }
503
504     MovieFinish(&swf, t, global.outfile);
505
506     return 0;
507 }