can now extract jpeg images (into jpeg files).
[swftools.git] / src / swfcombine.c
1 /* swfcombine.c
2    main routine for swfcombine(1), which is a tool for merging .swf-files.
3
4    Part of the swftools package.
5    
6    Copyright (c) 2001 Matthias Kramm <kramm@quiss.org> 
7
8    This file is distributed under the GPL, see file COPYING for details */
9
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13 #include "../lib/args.h"
14 #include "combine.h"
15 #include "settings.h"
16 #include "types.h"
17 #include "flash.h"
18 #include "../config.h"
19
20 char * master_filename = 0;
21 char * master_name = 0;
22 char * slave_filename[128];
23 char * slave_name[128];
24 int slave_movex[128];
25 int slave_movey[128];
26 float slave_scalex[128];
27 float slave_scaley[128];
28 char slave_isframe[128];
29 int numslaves = 0;
30
31 char * outputname = "output.swf";
32
33 int args_callback_option(char*name,char*val) {
34     if(!strcmp(name,"c"))
35     {
36         config.clip = 1;
37         return 0;
38     }
39     else if(!strcmp(name,"l"))
40     {
41         config.overlay = 1;
42         return 0;
43     }
44     else if (!strcmp(name, "o"))
45     {
46         outputname = val;
47         return 1;
48     }
49     else if (!strcmp(name, "v"))
50     {
51         config.loglevel ++;
52         return 0;
53     }
54     else if (!strcmp(name, "a"))
55     {
56         config.cat = 1;
57         return 0;
58     }
59     else if (!strcmp(name, "A"))
60     {
61         config.alloctest = 1;
62         return 0;
63     }
64     else if (!strcmp(name, "x"))
65     {
66         config.movex = atoi(val);
67         return 1;
68     }
69     else if (!strcmp(name, "y"))
70     {
71         config.movey = atoi(val);
72         return 1;
73     }
74     else if (!strcmp(name, "m"))
75     {
76         config.merge = 1;
77         return 0;
78     }
79     else if (!strcmp(name, "f"))
80     {
81         config.isframe = 1;
82         return 0;
83     }
84     else if (!strcmp(name, "d"))
85     {
86         config.dummy = 1;
87         return 0;
88     }
89     else if (!strcmp(name, "r"))
90     {
91         config.framerate = atoi(val)*256/100;
92         return 1;
93     }
94     else if (!strcmp(name, "X"))
95     {
96         config.sizex = atoi(val)*20;
97         config.hassizex = 1;
98         return 1;
99     }
100     else if (!strcmp(name, "Y"))
101     {
102         config.sizey = atoi(val)*20;
103         config.hassizey = 1;
104         return 1;
105     }
106     else if (!strcmp(name, "s"))
107     {
108         config.scalex = config.scaley = atoi(val)/100.0;
109         return 1;
110     }
111     else if (!strcmp(name, "t") || !strcmp(name, "T"))
112     {
113         if(master_filename) {
114             fprintf(stderr, "error with arguments. Try --help.\n");
115             exit(1);
116         }
117         config.stack = 1;
118         if(!strcmp(name,"T"))
119             config.stack1 = 1;
120         master_filename = "__none__";
121         return 0;
122     }
123     else if (!strcmp(name, "V"))
124     {   
125         printf("swfcombine - part of %s %s\n", PACKAGE, VERSION);
126         exit(0);
127     }
128     else 
129     {
130         fprintf(stderr, "Unknown option: -%s\n", name);
131         exit(1);
132     }
133 }
134
135 struct options_t options[] =
136 {{"o","output"},
137  {"s","scale"},
138  {"d","dummy"},
139  {"x","xpos"},
140  {"y","ypos"},
141  {"X","width"},
142  {"Y","height"},
143  {"r","rate"},
144  {"f","frame"},
145  {"l","overlay"},
146  {"m","merge"},
147  {"t","stack"},
148  {"T","stack1"},
149  {"v","verbose"},
150  {"V","version"},
151  {"c","clip"},
152  {"a","cat"},
153  {0,0}
154 };
155
156 int args_callback_longoption(char*name,char*val) {
157     return args_long2shortoption(options, name, val);
158 }
159
160 int args_callback_command(char*name, char*val) {
161     char*myname = strdup(name);
162     char*filename;
163     filename = strchr(myname, '=');
164     if(filename) {
165         *filename = 0;
166         filename++;
167     } else {
168         // argument has no explicit name field. guess one from the file name
169         char*path = strrchr(myname, '/');
170         char*ext = strrchr(myname, '.');
171         if(!path) path = myname;
172         else path ++;
173         if(ext) *ext = 0;
174         myname = path;
175         filename = name;
176     }
177
178     if(!master_filename) {
179         master_filename = filename;
180         master_name = myname;
181     } else {             
182         logf("<verbose> slave entity %s (named \"%s\")\n", filename, myname);
183
184         slave_filename[numslaves] = filename;
185         slave_name[numslaves] = myname;
186         slave_movex[numslaves] = config.movex;
187         slave_movey[numslaves] = config.movey;
188         slave_scalex[numslaves] = config.scalex;
189         slave_scaley[numslaves] = config.scaley;
190         slave_isframe[numslaves] = config.isframe; 
191         config.isframe = 0;
192         config.movex = config.movey = 0;
193         config.scalex = config.scaley = 1.0;
194         numslaves ++;
195     }
196     return 0;
197 }
198
199 void args_callback_usage(char*name)
200 {
201     printf("Usage: %s [-rXYomlcv] [-f] masterfile] [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
202     printf("OR:    %s [-rXYomv] --stack[1] [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
203     printf("OR:    %s [-rXYov] --cat [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
204     printf("OR:    %s [-rXYomlcv] --dummy [-xys] [file]\n", name);
205     printf("\n");
206     printf("-o outputfile       --output    explicitly specify output file. (otherwise, output.swf will be used\n");
207     printf("-t                  --stack     place each slave in a seperate frame (no master movie\n");
208     printf("-T                  --stack1    place each slave in the first frame (no master movie\n");
209     printf("-m                  --merge     Don't store the slaves in Sprites/MovieClips\n");
210     printf("-a                  --cat       concatenate all slave files (no master movie\n");
211     printf("-l                  --overlay   Don't remove any master objects, only overlay new objects\n");
212     printf("-c                  --clip      Clip the slave objects by the corresponding master objects\n");
213     printf("-v                  --verbose   Use more than one -v for greater effect \n");
214     printf("-d                  --dummy     Don't require slave objects \n");
215     printf("-f                  --frame     The following identifier is a frame or framelabel, not an id or objectname\n");
216     printf("-x xpos             --movex     x Adjust position of slave by xpos twips (1/20 pixel\n");
217     printf("-y ypos             --movey     y Adjust position of slave by ypos twips (1/20 pixel\n");
218     printf("-s scale            --scale     Adjust size of slave by scale%\n");
219     printf("-r framerate        --rate      Set movie framerate (100 frames/sec\n");
220     printf("-X width            --width     Force movie width to scale (default: use master width (not with -t\n");
221     printf("-Y height           --height    Force movie height to scale (default: use master height (not with -t\n");
222 }
223
224 /* read a whole file in memory */
225 char* fi_slurp(FILE*fi, unsigned int * setlength)
226 {
227     char * mem;
228     long long int length; //;)  
229     long long int pos = 0;
230     fseek(fi,0,SEEK_END);
231     length = ftell(fi);
232     fseek(fi,0,SEEK_SET);
233     if(!length)
234         return 0;
235     mem = malloc(length);
236     if(!mem)
237         return 0;
238     while(!feof(fi))
239     {
240         pos += fread(&mem[pos], 1, 65536, fi);
241     }
242     if (setlength) 
243         *setlength = length;
244     return mem;
245 }
246
247 void fi_dump(FILE*fi, void*_mem, int length)
248 {
249     char*mem = (char*)_mem;
250     int pos = 0;
251     while(pos < length)
252     {
253         int size = 65536;
254         if (size > (length - pos))
255                 size = (length - pos);
256         pos += fwrite(&mem[pos], 1, size, fi);
257     }
258 }
259
260 void makestackmaster(u8**masterdata, int*masterlength)
261 {
262     u8 head[] = {'F','W','S'};
263     u8 *pos;
264     u32 * fixpos;
265     int t;
266     struct RECT box;
267     int strlength = 0;
268     int fileversion = 1;
269
270     /* scan all slaves for bounding box */
271     for(t=0;t<numslaves;t++)
272     {
273         FILE*fi=fopen(slave_filename[t],"rb");
274         u8 data[256];
275         int ret;
276         struct flash_header head;
277         strlength += strlen(slave_name[t]) + 9;
278         if(!fi) {
279             logf("<fatal> Couldn't open %s.", slave_filename[t]);
280             exit(1);
281         }
282         ret = fread(data,1,256,fi);
283         if(ret < 13) {
284             logf("<fatal> File %s is to small (%d bytes)", slave_filename[t], ret);
285             exit(1);
286         }
287         swf_init(data,256);
288         head = swf_read_header();
289         logf("<verbose> File %s has bounding box %d:%d:%d:%d\n",
290                 slave_filename[t], 
291                 head.boundingBox.x1, head.boundingBox.y1,
292                 head.boundingBox.x2, head.boundingBox.y2);
293         if(head.version > fileversion)
294             fileversion = head.version;
295         if(!t)
296             box = head.boundingBox;
297         else {
298             if(head.boundingBox.x1 < box.x1)
299                 box.x1 = head.boundingBox.x1;
300             if(head.boundingBox.y1 < box.y1)
301                 box.y1 = head.boundingBox.y1;
302             if(head.boundingBox.x2 > box.x2)
303                 box.x2 = head.boundingBox.x2;
304             if(head.boundingBox.y2 > box.y2)
305                 box.y2 = head.boundingBox.y2;
306         }
307         logf("<verbose> New master bounding box is %d:%d:%d:%d\n",
308                 box.x1, box.y1,
309                 box.x2, box.y2);
310         fclose(fi);
311     }
312
313     /* we don't have a master, so we create one ourselves. */
314     /* (please notice the philosophical content) */
315     *masterlength = (numslaves + 1) * 32 + strlength;
316     *masterdata = (u8*)malloc(*masterlength);
317     pos = *masterdata;
318     memcpy(pos, head, sizeof(head));
319     pos += sizeof(head);
320     *pos++ = fileversion;
321     fixpos = (u32*)pos;
322     *(u32*)pos = 0x12345678; // to be overwritten
323     pos += 4;
324     writeRECT(&pos, &box);
325     *(u16*)pos = 0x2000; // framerate
326     pos += 2;
327     *(u16*)pos = numslaves;
328     pos += 2;
329     for(t=0;t<numslaves;t++)
330     {
331         char buf[128];
332         int namelen;
333
334         if(1) {
335             sprintf(buf, "Frame%02d", t);
336             slave_name[t] = strdup(buf);
337         } 
338         namelen = strlen(slave_name[t]);
339
340         *(u16*)&pos[0] = (u16)(TAGID_DEFINESPRITE<<6) + 6;
341         *(u16*)&pos[2] = t+1; //ID
342         *(u16*)&pos[4] = 0; // Frames
343         *(u16*)&pos[6] = 0; // TAG1
344         *(u16*)&pos[8] = (u16)(TAGID_PLACEOBJECT2<<6) + 6 + namelen;
345         *(u16*)&pos[10]= 34; //flags: id+name
346         *(u16*)&pos[11]= 1+t; // depth
347         *(u16*)&pos[13]= t+1; // id
348         sprintf(&pos[15],slave_name[t]);
349         pos += 15 + namelen + 1;
350         if(!config.stack1 || t == numslaves-1) {
351             *(u16*)&pos[0]= (u16)(TAGID_SHOWFRAME<<6) + 0;
352             pos += 2;
353         }
354         if(!config.stack)
355         if(t!=numslaves-1)
356         {
357             *(u16*)&pos[0]= (u16)(TAGID_REMOVEOBJECT2<<6) + 2;
358             *(u16*)&pos[2]= 1+t; // depth;
359             pos += 4;
360         }
361     }
362     *(u16*)pos = TAGID_END<<6 + 0;
363     *masterlength = pos - *masterdata;
364     *fixpos = *masterlength;
365 }
366
367 struct config_t config;
368 int main(int argn, char *argv[])
369 {
370     FILE*fi;
371     u8*masterdata;
372     unsigned int masterlength;
373     u8*slavedata;
374     unsigned int slavelength;
375     u8*newdata;
376     unsigned int newlength;
377     int t;
378
379     config.overlay = 0; 
380     config.antistream = 0; 
381     config.alloctest = 0;
382     config.cat = 0;
383     config.merge = 0;
384     config.clip = 0;
385     config.loglevel = 2; 
386     config.movex = 0;
387     config.movey = 0;
388     config.scalex = 1.0;
389     config.scaley = 1.0;
390     config.sizex = 0;
391     config.sizey = 0;
392     config.hassizex = 0;
393     config.hassizey = 0;
394     config.framerate = 0;
395     config.stack = 0;
396     config.stack1 = 0;
397     config.dummy = 0;
398
399     processargs(argn, argv);
400     initLog(0,-1,0,0,-1,config.loglevel);
401
402     if(config.merge && config.cat) {
403         logf("<error> Can't combine --cat and --merge");
404         exit(1);
405     }
406
407     if(config.stack) {
408
409         if(config.overlay) {
410             logf("<error> Can't combine -l and -t");
411             exit(1);
412         }
413         if(config.clip) {
414             logf("<error> Can't combine -c and -t");
415             exit(1);
416         }
417         logf("<verbose> (stacking) %d files found\n", numslaves);
418
419         makestackmaster(&masterdata,&masterlength);
420
421         logf("<verbose> Generated %d bytes of master data", masterlength);
422     }
423     else {
424         logf("<verbose> master entity %s (named \"%s\")\n", master_filename, master_name);
425         fi = fopen(master_filename, "rb");
426         if(!fi) {
427             fprintf(stderr, "Failed to open %s\n", master_filename);
428             return 1;
429         }
430         masterdata = fi_slurp(fi, &masterlength);
431         if(!masterdata) {
432             fprintf(stderr, "Failed to read from %s\n", master_filename);
433             return 1;
434         }
435         logf("<debug> Read %d bytes from masterfile\n", masterlength);
436         fclose(fi);
437     }
438
439     for(t=0;t<numslaves;t++) {
440             logf("<verbose> slave entity(%d) %s (%s \"%s\")\n", t+1, slave_filename[t], 
441                     slave_isframe[t]?"frame":"object", slave_name[t]);
442     }
443
444     if(config.dummy)
445     {
446         if(numslaves)
447         {
448             logf("<error> --dummy (-d) implies there are zero slave objects. You supplied %d.", numslaves);
449             exit(1);
450         }
451         numslaves = 1;
452         slave_filename[0] = "!!dummy!!";
453         slave_name[0] = "!!dummy!!";
454         slave_isframe[0] = 0;
455     }
456
457     if (config.alloctest)
458     {
459         int*bitmap = malloc(sizeof(int)*65536);
460         memset(bitmap, -1, 65536*sizeof(int));
461         memset(bitmap, 1, 101*sizeof(int));
462         swf_relocate(masterdata, masterlength, bitmap);
463         newdata = masterdata;
464         newlength = masterlength;
465         free(bitmap);
466     }
467     else
468     {
469         if (!numslaves)
470         {
471             logf("<error> You must have at least one slave entity.");
472             return 0;
473         }
474         for(t = 0; t < numslaves; t++)
475         {
476             config.movex = slave_movex[t];
477             config.movey = slave_movey[t];
478             config.scalex = slave_scalex[t];
479             config.scaley = slave_scaley[t];
480             config.isframe = slave_isframe[t];
481
482             logf("<notice> Combine [%s]%s and [%s]%s", master_name, master_filename,
483                     slave_name[t], slave_filename[t]);
484             if(!config.dummy)
485             {
486                 fi = fopen(slave_filename[t], "rb");
487                 if(!fi) {
488                     fprintf(stderr, "Failed to open %s\n", slave_filename[t]);
489                     return 1;
490                 }
491                 slavedata = fi_slurp(fi, &slavelength);
492                 if(!slavedata) {
493                     fprintf(stderr, "Failed to read from %s\n", slave_filename[t]);
494                     return 1;
495                 }
496                 logf("<debug> Read %d bytes from slavefile\n", slavelength);
497                 fclose(fi);
498             }
499             else
500             {
501                 slavedata = (u8*)malloc(16);
502                 slavedata[0] = 'F';
503                 slavedata[1] = 'W';
504                 slavedata[2] = 'S';
505                 slavedata[3] = 4; //version
506                 *(u32*)&slavedata[4] = 14; // length
507                 slavedata[8] = 0; // boundingbox
508                 *(u16*)&slavedata[9] = 0; // rate
509                 *(u16*)&slavedata[11] = 0; // count
510                 *(u16*)&slavedata[13] = 0; // end tag
511                 slavelength = 17;
512             }
513
514             newdata = combine(masterdata, masterlength, slave_name[t], slavedata, slavelength, &newlength);
515             if(!newdata) { 
516                 logf("<fatal> Aborting.");
517                 return 1;
518             }
519
520             free(masterdata);
521             masterdata = newdata;
522             masterlength = newlength;
523         }
524     }
525
526     logf("<debug> New File is %d bytes \n", newlength);
527     if(newdata && newlength) {
528         FILE*fi = fopen(outputname, "wb");
529         fi_dump(fi, newdata, newlength);
530         fclose(fi);
531     }
532     return 0;
533 }
534