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