* Don't rely on jpeglib to do any conversions anymore.
[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  
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 <jpeglib.h>
17 #include "../lib/rfxswf.h"
18 #include "../lib/args.h" // not really a header ;-)
19
20 #define MAX_INPUT_FILES 1024
21 #define VERBOSE(x) (global.verbose>=x)
22
23 struct
24 { int quality;
25   int framerate;
26   int max_image_width;
27   int max_image_height;
28   int force_width;
29   int force_height;
30   int prescale;
31   int nfiles;
32   int verbose;
33   char * outfile;
34 } global;
35
36 struct
37 { char * filename;
38   int scale;
39   int quality;
40 } image[MAX_INPUT_FILES];
41
42 TAG * MovieStart(SWF * swf,int framerate,int dx,int dy)
43 { TAG * t;
44   RGBA rgb;
45
46   memset(swf,0x00,sizeof(SWF));
47
48   swf->fileVersion       = 4;
49   swf->frameRate         = (25600/framerate);
50   swf->movieSize.xmax    = dx*20;
51   swf->movieSize.ymax    = dy*20;
52
53   t = swf->firstTag = swf_InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
54
55   rgb.r = rgb.g = rgb.b = rgb.a  = 0x00;
56   swf_SetRGB(t,&rgb);
57
58   return t;
59 }
60
61 int MovieFinish(SWF * swf,TAG * t,char * sname)
62 {  int handle, so = fileno(stdout);
63    t = swf_InsertTag(t,ST_END);
64
65    if ((!isatty(so))&&(!sname)) handle = so;
66    else
67    { if (!sname) sname = "out.swf";
68      handle = open(sname,O_RDWR|O_CREAT|O_TRUNC,0666);
69    }
70    if FAILED(swf_WriteSWF(handle,swf)) if (VERBOSE(1)) fprintf(stderr,"Unable to write output file: %s\n",sname);
71    if (handle!=so) close(handle);
72    
73    swf_FreeTags(swf);
74    return 0;
75 }
76
77 TAG * MovieAddFrame(SWF * swf,TAG * t,char * sname,int quality,int scale,int id)
78 { SHAPE * s;
79   SRECT r;
80   MATRIX m;
81   int fs;
82   
83   struct jpeg_decompress_struct cinfo;
84   struct jpeg_error_mgr jerr;
85   LPJPEGBITS out;
86   FILE * f;
87   U8 * scanline;
88
89   if ((f=fopen(sname,"rb"))==NULL)
90   { if (VERBOSE(1)) fprintf(stderr,"Read access failed: %s\n",sname);
91     return t;
92   }
93   
94   cinfo.err = jpeg_std_error(&jerr);
95   jpeg_create_decompress(&cinfo); 
96   jpeg_stdio_src(&cinfo,f);
97   jpeg_read_header(&cinfo, TRUE);
98   
99   if (scale>1)
100   { cinfo.scale_num = 1;
101     cinfo.scale_denom = scale;
102   }
103     
104   jpeg_start_decompress(&cinfo);
105
106   t = swf_InsertTag(t,ST_DEFINEBITSJPEG2);
107
108         swf_SetU16(t,id);  // id
109   
110         out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
111         scanline = (U8*)malloc(4*cinfo.output_width);
112   
113         if (scanline)
114         { int y;
115           U8 * js = scanline;
116           for (y=0;y<cinfo.output_height;y++)
117           { jpeg_read_scanlines(&cinfo,&js,1);
118             swf_SetJPEGBitsLines(out,(U8**)&js,1);
119           }
120           free(scanline);
121         }
122         
123         swf_SetJPEGBitsFinish(out);
124     
125   t = swf_InsertTag(t,ST_DEFINESHAPE);
126
127         swf_ShapeNew(&s);
128         swf_GetMatrix(NULL,&m);
129         m.sx = 20*0x10000;
130         m.sy = 20*0x10000;
131         fs = swf_ShapeAddBitmapFillStyle(s,&m,id,0);
132         
133         swf_SetU16(t,id+1); // id
134
135
136         r.xmin = r.ymin = 0;
137         r.xmax = cinfo.output_width*20;
138         r.ymax = cinfo.output_height*20;
139         swf_SetRect(t,&r);
140         
141         swf_SetShapeHeader(t,s);
142
143         swf_ShapeSetAll(t,s,0,0,0,fs,0);
144         swf_ShapeSetLine(t,s,r.xmax,0);
145         swf_ShapeSetLine(t,s,0,r.ymax);
146         swf_ShapeSetLine(t,s,-r.xmax,0);
147         swf_ShapeSetLine(t,s,0,-r.ymax);
148         
149         swf_ShapeSetEnd(t);
150         
151   t = swf_InsertTag(t,ST_REMOVEOBJECT2);
152         swf_SetU16(t,1); // depth
153
154   t = swf_InsertTag(t,ST_PLACEOBJECT2);
155
156         swf_GetMatrix(NULL,&m);
157         m.tx = (swf->movieSize.xmax-(int)cinfo.output_width*20)/2;
158         m.ty = (swf->movieSize.ymax-(int)cinfo.output_height*20)/2;
159         swf_ObjectPlace(t,id+1,1,&m,NULL,NULL);
160
161   t = swf_InsertTag(t,ST_SHOWFRAME);
162
163   jpeg_finish_decompress(&cinfo);
164   fclose(f);
165
166   return t;
167 }
168
169 int CheckInputFile(char * fname,char ** realname)
170 { struct jpeg_decompress_struct cinfo;
171   struct jpeg_error_mgr jerr;
172   FILE * f;
173   char * s = malloc(strlen(fname)+5);
174   int width, height;
175   
176   if (!s) exit(2);
177   (*realname) = s;
178   strcpy(s,fname);
179
180   // Check whether file exists (with typical extensions)
181
182   if ((f=fopen(s,"rb"))==NULL)
183   { sprintf(s,"%s.jpg",fname);
184     if ((f=fopen(s,"rb"))==NULL)
185     { sprintf(s,"%s.jpeg",fname);
186       if ((f=fopen(s,"rb"))==NULL)
187       { sprintf(s,"%s.JPG",fname);
188         if ((f=fopen(s,"rb"))==NULL)
189         { sprintf(s,"%s.JPEG",fname);
190           if ((f=fopen(s,"rb"))==NULL)
191             return -1;
192         }
193       }
194     }
195   }
196   
197   cinfo.err = jpeg_std_error(&jerr);
198   jpeg_create_decompress(&cinfo); 
199   jpeg_stdio_src(&cinfo,f);
200   jpeg_read_header(&cinfo, TRUE);
201
202   // Apply scaling (scale option can be used several times to set different scales)
203
204   if (global.prescale>1)
205   { cinfo.scale_num = 1;
206     cinfo.scale_denom = global.prescale;
207
208     jpeg_calc_output_dimensions(&cinfo);
209
210     width  = cinfo.output_width;
211     height = cinfo.output_height;
212   }
213   else
214   { width  = cinfo.image_width;
215     height = cinfo.image_height;
216   }
217
218   // Get image dimensions
219
220   if (global.max_image_width<width) global.max_image_width = width;
221   if (global.max_image_height<height) global.max_image_height = height;
222   
223   jpeg_destroy_decompress(&cinfo);
224   fclose(f);
225
226   return 0;
227 }
228
229 int args_callback_option(char*arg,char*val)
230 { int res = 0;
231   if (arg[1]) res = -1;
232   else switch (arg[0])
233   { case 'q':
234       if (val) global.quality = atoi(val);
235       if ((global.quality<1)||(global.quality>100))
236       { if (VERBOSE(1)) fprintf(stderr,"Error: You must specify a valid quality between 1 and 100.\n");
237         exit(1);
238       }
239       res = 1;
240       break;
241
242     case 'r':
243       if (val) global.framerate = atoi(val);
244       if ((global.framerate<1)||(global.framerate>5000))
245       { if (VERBOSE(1)) fprintf(stderr,"Error: You must specify a valid framerate between 1 and 10000.\n");
246         exit(1);
247       }
248       res = 1;
249       break;
250
251     case 's':
252       if (val) global.prescale = atoi(val);
253       if (!((global.prescale==1)||(global.prescale==2)||(global.prescale==4)||(global.prescale==8)))
254       { if (VERBOSE(1)) fprintf(stderr,"Error: Prescale denominator is limited to 2, 4 or 8\n");
255         exit(1);
256       }
257       res = 1;
258       break;
259
260     case 'o':
261       if (val) global.outfile = val; res = 1; break;
262
263     case 'v':
264       if (val) global.verbose = atoi(val); res = 1; break;
265
266     case 'X':
267       if (val) global.force_width = atoi(val); res = 1; break;
268
269     case 'Y':
270       if (val) global.force_height = atoi(val); res = 1; break;
271
272     case 'V':
273       printf("jpeg2swf - part of %s %s\n", PACKAGE, VERSION);exit(0);
274       
275     default:
276       res = -1;
277       break;
278   }
279   
280   if (res<0)
281   { if (VERBOSE(1)) fprintf(stderr,"Unknown option: -v%s\n",arg);
282     return 0;
283   }
284   return res;
285 }
286
287 struct options_t options[] =
288 {{"q","quality"},
289  {"o","output"},
290  {"r","rate"},
291  {"v","verbose"},
292  {"X","width"},
293  {"Y","height"},
294  {"V","version"},
295  {"s","scale"}
296  };
297
298 int args_callback_longoption(char*name,char*val) {
299     return args_long2shortoption(options, name, val);
300 }
301
302 int args_callback_command(char*arg,char*next)  // actually used as filename
303 { char * s;
304   int scale;
305   if (CheckInputFile(arg,&s)<0)
306   { if (VERBOSE(1)) fprintf(stderr, "Unable to open input file: %s\n",arg);
307     free(s);
308   }
309   else
310   { image[global.nfiles].filename = s;
311     image[global.nfiles].scale   = global.prescale;
312     image[global.nfiles].quality = global.quality;
313     global.nfiles++;
314     if (global.nfiles>=MAX_INPUT_FILES)
315     { if (VERBOSE(1)) fprintf(stderr, "Error: Too many input files.\n");
316       exit(1);
317     }
318   }
319   return 0;
320 }
321
322 void args_callback_usage(char*name)
323 { fprintf(stderr,"Usage: %s  [-options [value]] imagefiles[.jpg]|[.jpeg] [...]\n",name);
324   fprintf(stderr,"-q quality            (quality) Set JPEG compression quality (1-100)\n");
325   fprintf(stderr,"-s denominator        (scale) 2, 4 or 8: Reduce image size to 1/2, 1/4, 1/8\n");
326   fprintf(stderr,"-r framerate          (rate) Set movie framerate (100/sec)\n");
327   fprintf(stderr,"-o outputfile         (output) Set name for SWF output file\n");
328   fprintf(stderr,"-X pixel              (width) Force movie width to scale (default: autodetect)\n");
329   fprintf(stderr,"-Y pixel              (height) Force movie height to scale (default: autodetect)\n");
330   fprintf(stderr,"-v level              (verbose) Set verbose level (0=quiet, 1=default, 2=debug)\n");
331   fprintf(stderr,"-V                    (version) Print version information and exit\n");
332   fprintf(stderr,"The following options can be set independently for each image: -q -s\n");
333 }
334
335
336 int main(int argc, char ** argv)
337 { SWF swf;
338   TAG * t;
339
340   memset(&global,0x00,sizeof(global));
341     
342   global.quality                = 60;
343   global.framerate              = 100;
344   global.verbose                = 1;
345   global.prescale               = 1;
346   
347   processargs(argc, argv);
348
349   if (VERBOSE(2)) fprintf(stderr,"Processing %i file(s)...\n",global.nfiles);
350
351   t = MovieStart(&swf,global.framerate,
352                       global.force_width?global.force_width:global.max_image_width,
353                       global.force_height?global.force_height:global.max_image_height);
354
355   { int i;
356     for (i=0;i<global.nfiles;i++)
357     { if (VERBOSE(3)) fprintf(stderr,"[%03i] %s (%i%%, 1/%i)\n",i,image[i].filename,image[i].quality,image[i].scale);
358       t = MovieAddFrame(&swf,t,image[i].filename,
359                                image[i].quality,
360                                image[i].scale,(i*2)+1);
361       free(image[i].filename);
362     }
363   }
364
365   MovieFinish(&swf,t,global.outfile);
366
367   return 0;
368 }
369
370
371 // Old main routine
372
373 /*
374 int ConvertJPEG2SWF(char * sname,char * dname,int quality)
375 { RGBA rgb;
376   SWF swf;
377   TAG * t;
378   
379   SHAPE * s;
380   SRECT r;
381   MATRIX m;
382   int fs;
383   
384   struct jpeg_decompress_struct cinfo;
385   struct jpeg_error_mgr jerr;
386   LPJPEGBITS out;
387   FILE * f;
388   U8 * scanline;
389
390   int handle;
391
392   cinfo.err = jpeg_std_error(&jerr);
393   jpeg_create_decompress(&cinfo); 
394
395   if ((f=fopen(sname,"rb"))==NULL)
396   { fprintf(stderr,"Read access failed: %s\n",sname);
397     return -1;
398   }
399   
400   jpeg_stdio_src(&cinfo,f);
401   jpeg_read_header(&cinfo, TRUE);
402   jpeg_start_decompress(&cinfo);
403   
404   memset(&swf,0x00,sizeof(SWF));
405
406   swf.FileVersion       = 4;
407   swf.FrameRate         = 0x1000;
408   swf.MovieSize.xmax    = cinfo.output_width*20;
409   swf.MovieSize.ymax    = cinfo.output_height*20;
410
411   printf("dx = %i, dy = %i\n",cinfo.output_width,cinfo.output_height);
412
413   t = swf.FirstTag = InsertTag(NULL,ST_SETBACKGROUNDCOLOR);
414
415         rgb.r = rgb.g = rgb.b = rgb.a  = 0x00;
416         SetRGB(t,&rgb);
417
418   t = InsertTag(t,ST_DEFINEBITSJPEG2);
419
420         SetU16(t,1);  // id
421   
422         out = SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
423         scanline = (U8*)malloc(4*cinfo.output_width);
424   
425         if (scanline)
426         { int y;
427           U8 * js = scanline;
428           for (y=0;y<cinfo.output_height;y++)
429           { jpeg_read_scanlines(&cinfo,&js,1);
430             SetJPEGBitsLines(out,(U8**)&js,1);
431           }
432           free(scanline);
433         }
434         
435         SetJPEGBitsFinish(out);
436
437         printf("JPEG Tag-Length: %06x\n",GetDataSize(t));
438
439   t = InsertTag(t,ST_DEFINESHAPE);
440
441         NewShape(&s);
442         GetMatrix(NULL,&m);
443         m.sx = 20*0x10000;
444         m.sy = 20*0x10000;
445         rgb.r = 0xff;
446         fs = ShapeAddBitmapFillStyle(s,&m,1,0);
447 //        fs = ShapeAddSolidFillStyle(s,&rgb);
448         
449         SetU16(t,2); // id
450         SetRect(t,&swf.MovieSize);
451         SetShapeHeader(t,s);
452
453         ShapeSetAll(t,s,0,0,0,fs,0);
454         ShapeSetLine(t,s,swf.MovieSize.xmax,0);
455         ShapeSetLine(t,s,0,swf.MovieSize.ymax);
456         ShapeSetLine(t,s,-swf.MovieSize.xmax,0);
457         ShapeSetLine(t,s,0,-swf.MovieSize.ymax);
458         
459         ShapeSetEnd(t);
460
461   t = InsertTag(t,ST_PLACEOBJECT2);
462
463         ObjectPlace(t,2,1,NULL,NULL,NULL);
464
465   t = InsertTag(t,ST_SHOWFRAME);
466   
467   t = InsertTag(t,ST_END);
468
469   jpeg_finish_decompress(&cinfo);
470   fclose(f);
471   
472   handle = open(dname,O_RDWR|O_CREAT|O_TRUNC,0666);
473   if FAILED(WriteSWF(handle,&swf)) fprintf(stderr,"WriteSWF() failed.\n");
474   close(handle);
475
476   return 0;
477 }
478 */
479