1f10f65824ec72999801ac27b602f9bdcbbefc80
[swftools.git] / src / swfcombine.c
1 /* swfcombine.c
2    main routine for swfcombine(1), 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 <zlib.h>
14 #include "../lib/rfxswf.h"
15 #include "../lib/args.h"
16 #include "../lib/log.h"
17 #include "../config.h"
18
19 struct config_t
20 {
21    char overlay;
22    char alloctest;
23    char clip;
24    char stack;
25    char stack1;
26    char antistream;
27    char dummy;
28    char zlib;
29    char cat;
30    char merge;
31    char isframe;
32    int loglevel;
33    int movex;
34    int movey;
35    int sizex;
36    char hassizex;
37    int sizey;
38    char hassizey;
39    int framerate;
40    float scalex;
41    float scaley;
42 };
43 struct config_t config;
44
45 char * master_filename = 0;
46 char * master_name = 0;
47 char * slave_filename[128];
48 char * slave_name[128];
49 int slave_movex[128];
50 int slave_movey[128];
51 float slave_scalex[128];
52 float slave_scaley[128];
53 char slave_isframe[128];
54 int numslaves = 0;
55
56 char * outputname = "output.swf";
57
58 int args_callback_option(char*name,char*val) {
59     if(!strcmp(name,"c"))
60     {
61         config.clip = 1;
62         return 0;
63     }
64     else if(!strcmp(name,"l"))
65     {
66         config.overlay = 1;
67         return 0;
68     }
69     else if (!strcmp(name, "o"))
70     {
71         outputname = val;
72         return 1;
73     }
74     else if (!strcmp(name, "v"))
75     {
76         config.loglevel ++;
77         return 0;
78     }
79     else if (!strcmp(name, "a"))
80     {
81         config.cat = 1;
82         return 0;
83     }
84     else if (!strcmp(name, "A"))
85     {
86         config.alloctest = 1;
87         return 0;
88     }
89     else if (!strcmp(name, "x"))
90     {
91         config.movex = atoi(val);
92         return 1;
93     }
94     else if (!strcmp(name, "y"))
95     {
96         config.movey = atoi(val);
97         return 1;
98     }
99     else if (!strcmp(name, "m"))
100     {
101         config.merge = 1;
102         return 0;
103     }
104     else if (!strcmp(name, "f"))
105     {
106         config.isframe = 1;
107         return 0;
108     }
109     else if (!strcmp(name, "d"))
110     {
111         config.dummy = 1;
112         return 0;
113     }
114     else if (!strcmp(name, "z"))
115     {
116         config.zlib = 1;
117         return 0;
118     }
119     else if (!strcmp(name, "r"))
120     {
121         config.framerate = atoi(val)*256/100;
122         return 1;
123     }
124     else if (!strcmp(name, "X"))
125     {
126         config.sizex = atoi(val)*20;
127         config.hassizex = 1;
128         return 1;
129     }
130     else if (!strcmp(name, "Y"))
131     {
132         config.sizey = atoi(val)*20;
133         config.hassizey = 1;
134         return 1;
135     }
136     else if (!strcmp(name, "s"))
137     {
138         config.scalex = config.scaley = atoi(val)/100.0;
139         return 1;
140     }
141     else if (!strcmp(name, "t") || !strcmp(name, "T"))
142     {
143         if(master_filename) {
144             fprintf(stderr, "error with arguments. Try --help.\n");
145             exit(1);
146         }
147         config.stack = 1;
148         if(!strcmp(name,"T"))
149             config.stack1 = 1;
150         master_filename = "__none__";
151         return 0;
152     }
153     else if (!strcmp(name, "V"))
154     {   
155         printf("swfcombine - part of %s %s\n", PACKAGE, VERSION);
156         exit(0);
157     }
158     else 
159     {
160         fprintf(stderr, "Unknown option: -%s\n", name);
161         exit(1);
162     }
163 }
164
165 struct options_t options[] =
166 {{"o","output"},
167  {"s","scale"},
168  {"d","dummy"},
169  {"x","xpos"},
170  {"y","ypos"},
171  {"X","width"},
172  {"Y","height"},
173  {"r","rate"},
174  {"f","frame"},
175  {"l","overlay"},
176  {"m","merge"},
177  {"t","stack"},
178  {"T","stack1"},
179  {"v","verbose"},
180  {"V","version"},
181  {"c","clip"},
182  {"a","cat"},
183  {"z","zlib"},
184  {0,0}
185 };
186
187 int args_callback_longoption(char*name,char*val) {
188     return args_long2shortoption(options, name, val);
189 }
190
191 int args_callback_command(char*name, char*val) {
192     char*myname = strdup(name);
193     char*filename;
194     filename = strchr(myname, '=');
195     if(filename) {
196         *filename = 0;
197         filename++;
198     } else {
199         // argument has no explicit name field. guess one from the file name
200         char*path = strrchr(myname, '/');
201         char*ext = strrchr(myname, '.');
202         if(!path) path = myname;
203         else path ++;
204         if(ext) *ext = 0;
205         myname = path;
206         filename = name;
207     }
208
209     if(!master_filename) {
210         master_filename = filename;
211         master_name = myname;
212     } else {             
213         logf("<verbose> slave entity %s (named \"%s\")\n", filename, myname);
214
215         slave_filename[numslaves] = filename;
216         slave_name[numslaves] = myname;
217         slave_movex[numslaves] = config.movex;
218         slave_movey[numslaves] = config.movey;
219         slave_scalex[numslaves] = config.scalex;
220         slave_scaley[numslaves] = config.scaley;
221         slave_isframe[numslaves] = config.isframe; 
222         config.isframe = 0;
223         config.movex = config.movey = 0;
224         config.scalex = config.scaley = 1.0;
225         numslaves ++;
226     }
227     return 0;
228 }
229
230 void args_callback_usage(char*name)
231 {
232     printf("Usage: %s [-rXYomlcv] [-f] masterfile [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
233     printf("OR:    %s [-rXYomv] --stack[1] [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
234     printf("OR:    %s [-rXYov] --cat [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
235     printf("OR:    %s [-rXYomlcv] --dummy [-xys] [file]\n", name);
236     printf("\n");
237     printf("-o outputfile       --output    explicitly specify output file. (otherwise, output.swf will be used\n");
238     printf("-t                  --stack     place each slave in a seperate frame (no master movie)\n");
239     printf("-T                  --stack1    place each slave in the first frame (no master movie)\n");
240     printf("-m                  --merge     Don't store the slaves in Sprites/MovieClips\n");
241     printf("-a                  --cat       concatenate all slave files (no master movie)\n");
242     printf("-l                  --overlay   Don't remove any master objects, only overlay new objects\n");
243     printf("-c                  --clip      Clip the slave objects by the corresponding master objects\n");
244     printf("-v                  --verbose   Use more than one -v for greater effect \n");
245     printf("-d                  --dummy     Don't require slave objects \n");
246     printf("-f                  --frame     The following identifier is a frame or framelabel, not an id or objectname\n");
247     printf("-x xpos             --movex     x Adjust position of slave by xpos twips (1/20 pixel)\n");
248     printf("-y ypos             --movey     y Adjust position of slave by ypos twips (1/20 pixel)\n");
249     printf("-s scale            --scale     Adjust size of slave by scale%\n");
250     printf("-r framerate        --rate      Set movie framerate (100 frames/sec)\n");
251     printf("-X width            --width     Force movie width to scale (default: use master width (not with -t))\n");
252     printf("-Y height           --height    Force movie height to scale (default: use master height (not with -t))\n");
253     printf("-z zlib             --zlib      Enable Flash 6 (MX) Zlib Compression\n");
254 }
255
256 static void makestackmaster(SWF*swf)
257 {
258     TAG*tag;
259     int t;
260     SRECT box;
261     int fileversion = 1;
262     int frameRate = 256;
263     RGBA rgb;
264     rgb.r=rgb.b=rgb.g=0;
265     memset(&box, 0, sizeof(box));
266
267     /* scan all slaves for bounding box */
268     for(t=numslaves-1;t>=0;t--)
269     {
270         SWF head;
271         int ret;
272         int fi=open(slave_filename[t],O_RDONLY);
273         TAG*tag;
274         if(fi<0 || swf_ReadSWF(fi, &head)<0) {
275             logf("<fatal> Couldn't open/read %s.", slave_filename[t]);
276             exit(1);
277         }
278         close(fi);
279         logf("<verbose> File %s has bounding box %d:%d:%d:%d\n",
280                 slave_filename[t], 
281                 head.movieSize.xmin, head.movieSize.ymin,
282                 head.movieSize.xmax, head.movieSize.ymax);
283
284         tag = head.firstTag;
285         while(tag) {
286             if(tag->id == ST_SETBACKGROUNDCOLOR && tag->len>=3) {
287                 rgb.r = tag->data[0];
288                 rgb.g = tag->data[1];
289                 rgb.b = tag->data[2];
290             }
291             tag=tag->next;
292         }
293         frameRate = head.frameRate;
294         if(head.fileVersion > fileversion)
295             fileversion = head.fileVersion;
296         if(!t)
297             box = head.movieSize;
298         else {
299             if(head.movieSize.xmin < box.xmin)
300                 box.xmin = head.movieSize.xmin;
301             if(head.movieSize.ymin < box.ymin)
302                 box.ymin = head.movieSize.ymin;
303             if(head.movieSize.xmax > box.xmax)
304                 box.xmax = head.movieSize.xmax;
305             if(head.movieSize.ymax > box.ymax)
306                 box.ymax = head.movieSize.ymax;
307         }
308         logf("<verbose> New master bounding box is %d:%d:%d:%d\n",
309                 box.xmin, box.ymin,
310                 box.xmax, box.ymax);
311         swf_FreeTags(&head);
312     }
313
314     memset(swf, 0, sizeof(SWF));
315     swf->fileVersion = fileversion;
316     swf->movieSize = box;
317     swf->frameRate = frameRate;
318
319     swf->firstTag = swf_InsertTag(0, ST_SETBACKGROUNDCOLOR);
320     tag = swf->firstTag;
321     swf_SetRGB(tag, &rgb);
322     
323     for(t=0;t<numslaves;t++)
324     {
325         char buf[128];
326         sprintf(buf, "Frame%02d", t);
327         slave_name[t] = strdup(buf);
328
329         tag = swf_InsertTag(tag, ST_DEFINESPRITE);
330         swf_SetU16(tag, t+1);
331         swf_SetU16(tag, 0);
332         tag = swf_InsertTag(tag, ST_END);
333         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
334         swf_ObjectPlace(tag, t+1, 1+t,0,0, slave_name[t]);
335
336         if(!config.stack1 || t == numslaves-1) {
337             tag = swf_InsertTag(tag, ST_SHOWFRAME);
338         }
339         if(!config.stack)
340         if(t!=numslaves-1)
341         {
342             tag = swf_InsertTag(tag, ST_REMOVEOBJECT2);
343             swf_SetU16(tag, 1+t);
344         }
345     }
346     tag = swf_InsertTag(tag, ST_END);
347     logf("<verbose> temporary SWF created");
348 }
349
350 static char* slavename = 0;
351 static int slaveid = -1;
352 static int slaveframe = -1;
353 static char masterbitmap[65536];
354
355 #define FLAGS_WRITEDEFINES 1
356 #define FLAGS_WRITENONDEFINES 2
357 #define FLAGS_WRITESPRITE 4
358 #define FLAGS_WRITESLAVE 8
359
360 int get_free_id(char*bitmap)
361 {
362     int t;
363     for(t=1;t<65536;t++)
364         if(!bitmap[t]) {
365             bitmap[t] = 1;
366             return t;
367         }
368     return -1;
369 }
370
371 void jpeg_assert(SWF*master, SWF*slave)
372 {
373     /* TODO: if there's a jpegtable found, store it
374        and handle it together with the flash file
375        headers */
376
377     /* check that master and slave don't have both
378        jpegtables (which would be fatal) */
379     int pos;
380     TAG *mpos=0, *spos=0;
381     TAG *mtag,*stag;
382     pos = 0;
383     mtag = master->firstTag;
384     stag = slave->firstTag;
385     while(mtag)
386     {
387         if(mtag->id  == ST_JPEGTABLES)
388             mpos = mtag;
389         mtag = mtag->next;
390     }
391     while(stag)
392     {
393         if(stag->id == ST_JPEGTABLES)
394             spos = stag;
395         stag = stag->next;
396     }
397     if(mpos && spos)
398     {
399         if(spos->len == mpos->len &&
400         !memcmp(spos->data, mpos->data, mpos->len))
401         {
402             // ok, both have jpegtables, but they're identical.
403             // delete one and don't throw an error
404             swf_DeleteTag(spos);
405             spos = 0;
406         }
407     }
408     if(spos && mpos) {
409         logf("<error> Master and slave have incompatible JPEGTABLES.");
410     }
411 }
412
413 TAG* write_sprite_defines(TAG*tag, SWF*sprite)
414 {
415     TAG*rtag = sprite->firstTag;
416     while(rtag && rtag->id!=ST_END) {
417         if(!swf_isAllowedSpriteTag(rtag)) {
418             logf("<debug> processing sprite tag %02x", tag->id);
419             if(swf_isDefiningTag(rtag))
420             {
421                 logf("<debug> [sprite defs] write tag %02x (%d bytes in body)", 
422                         tag->id, tag->len);
423                 tag = swf_InsertTag(tag, rtag->id);
424                 swf_SetBlock(tag, rtag->data, rtag->len);
425             }
426             else if(swf_isPseudoDefiningTag(rtag))
427             {
428                 logf("<debug> [sprite defs] write tag %02x (%d bytes in body)", 
429                         tag->id, tag->len);
430                 tag = swf_InsertTag(tag, rtag->id);
431                 swf_SetBlock(tag, rtag->data, rtag->len);
432             }
433             else {
434                 switch(rtag->id)
435                 {
436                     case ST_JPEGTABLES:
437                            /* if we get here, jpeg_assert has already run,
438                               ensuring this is the only one of it's kind,
439                               so we may safely write it out */
440                            tag = swf_InsertTag(tag, rtag->id);
441                            swf_SetBlock(tag, rtag->data, rtag->len);
442                        break;
443                     case ST_EXPORTASSETS:
444                        logf("<debug> deliberately ignoring EXPORTASSETS tag");
445                        break;
446                     case ST_ENABLEDEBUGGER:
447                        logf("<debug> deliberately ignoring ENABLEDEBUGGER tag");
448                        break;
449                     case ST_SETBACKGROUNDCOLOR:
450                        logf("<debug> deliberately ignoring BACKGROUNDCOLOR tag");
451                        break;
452                     case 40:
453                     case 49:
454                     case 51:
455                        logf("<notice> found tag %d. This is a Generator template, isn't it?", tag->id);
456                        break;
457                     default:
458                        logf("<notice> funny tag: %d is neither defining nor sprite", tag->id);
459                 }
460             }
461         }
462         rtag = rtag->next;
463     }
464     return tag;
465 }
466
467 void changedepth(TAG*tag, int add)
468 {
469     /* fucking byteorders */
470     if(tag->id == ST_PLACEOBJECT)
471         PUT16(&tag->data[2],GET16(&tag->data[2])+add);
472     if(tag->id == ST_PLACEOBJECT2)
473         PUT16(&tag->data[1],GET16(&tag->data[1])+add);
474     if(tag->id == ST_REMOVEOBJECT)
475         PUT16(&tag->data[2],GET16(&tag->data[2])+add);
476     if(tag->id == ST_REMOVEOBJECT2)
477         PUT16(&tag->data[0],GET16(&tag->data[0])+add);
478 }
479
480 void matrix_adjust(MATRIX*m)
481 {
482     m->sx = (int)(m->sx*config.scalex);
483     m->sy = (int)(m->sy*config.scaley);
484     m->r0 = (int)(m->r0*config.scalex);
485     m->r1 = (int)(m->r1*config.scaley);
486     m->tx += config.movex;
487     m->ty += config.movey;
488 }
489
490 void write_changepos(TAG*output, TAG*tag)
491 {
492     if(config.movex || config.movey || config.scalex != 1 || config.scaley != 1)
493     {
494         switch(tag->id)
495         {
496             case ST_PLACEOBJECT2: {
497                 MATRIX m;
498                 U8 flags;
499                 swf_GetMatrix(0, &m);
500
501                 flags = swf_GetU8(tag);
502                 swf_SetU8(output, flags|4);
503                 swf_SetU16(output, swf_GetU16(tag)); //depth
504                 //flags&1: move
505                 if(flags&2) {
506                     swf_SetU16(output, swf_GetU16(tag)); //id
507                 }
508                 // flags & 4
509                 swf_GetMatrix(tag, &m);
510                 matrix_adjust(&m);
511                 swf_SetMatrix(output, &m);
512
513                 //swf_ResetReadBits(tag);
514                 swf_SetBlock(output, &tag->data[tag->pos], tag->len - tag->pos);
515                 break;
516             }
517             case ST_PLACEOBJECT: {
518                 MATRIX m;
519                 swf_SetU16(output, swf_GetU16(tag)); //id
520                 swf_SetU16(output, swf_GetU16(tag)); //depth
521                 
522                 swf_GetMatrix(tag, &m);
523                 matrix_adjust(&m);
524                 swf_SetMatrix(output, &m);
525                 
526                 //swf_ResetReadBits(tag);
527                 swf_SetBlock(output, &tag->data[tag->pos], tag->len - tag->pos);
528                 break;
529             }
530             default:
531             swf_SetBlock(output, tag->data, tag->len);
532         }
533     } 
534     else 
535     {
536             swf_SetBlock(output, tag->data, tag->len);
537     }
538 }
539
540 TAG* write_sprite(TAG*tag, SWF*sprite, int spriteid, int replaceddefine)
541 {
542     TAG* definespritetag;
543     TAG* rtag;
544     int tmp;
545
546     definespritetag = tag = swf_InsertTag(tag, ST_DEFINESPRITE);
547     swf_SetU16(tag, spriteid);
548     swf_SetU16(tag, sprite->frameCount);
549     logf ("<notice> sprite id is %d", spriteid);
550
551     tmp = sprite->frameCount;
552     logf("<debug> %d frames to go",tmp);
553
554     if(config.clip) {
555         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
556         swf_SetU8(tag, 2+64); //flags: character+clipdepth
557         swf_SetU16(tag, 0); //depth
558         swf_SetU16(tag, replaceddefine); //id
559         swf_SetU16(tag, 65535); //clipdepth
560     }
561
562     if(config.overlay && !config.isframe) {
563         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
564         swf_SetU8(tag, 2); //flags: character
565         swf_SetU16(tag, 0); //depth
566         swf_SetU16(tag, replaceddefine); //id
567     }
568
569     rtag = sprite->firstTag;
570     while(rtag && rtag->id!=ST_END)
571     {
572         if (swf_isAllowedSpriteTag(rtag)) {
573
574             logf("<debug> [sprite main] write tag %02x (%d bytes in body)", 
575                     rtag->id, rtag->len);
576             tag = swf_InsertTag(tag, rtag->id);
577             write_changepos(tag, rtag);
578           
579             changedepth(tag, +1);
580
581             if(tag->id == ST_SHOWFRAME)
582             {
583                 tmp--;
584                 logf("<debug> %d frames to go",tmp);
585             }
586         }
587         rtag = rtag->next;
588     }
589     tag = swf_InsertTag(tag, ST_END);
590     return tag;
591 }
592
593 static char tag_ok_for_slave(int id)
594 {
595     if(id == ST_SETBACKGROUNDCOLOR)
596         return 0;
597     return 1;
598 }
599
600 TAG* write_master(TAG*tag, SWF*master, SWF*slave, int spriteid, int replaceddefine, int flags)
601 {
602     int outputslave = 0;
603     int frame = 0;
604     int sframe = 0;
605     int slavewritten = 0;
606
607     TAG* rtag = master->firstTag;
608     TAG* stag = slave->firstTag;
609
610     while(rtag && rtag->id!=ST_END)
611     {
612         if(rtag->id == ST_SHOWFRAME && outputslave)
613         {
614             while(stag && stag->id!=ST_END) {
615                 if(stag->id == ST_SHOWFRAME) {
616                     stag = stag->next;
617                     sframe++;
618                     break;
619                 }
620                 if(tag_ok_for_slave(stag->id)) {
621                     tag = swf_InsertTag(tag, stag->id);
622                     swf_SetBlock(tag, stag->data, stag->len);
623                 }
624                 stag = stag->next;
625             }
626         }
627         if(rtag->id == ST_SHOWFRAME)
628         {
629             frame ++;
630         }
631
632         if(swf_isDefiningTag(rtag) && (flags&FLAGS_WRITEDEFINES))
633         {
634             logf("<debug> [master] write tag %02x (%d bytes in body)", 
635                     rtag->id, rtag->len);
636             if(swf_GetDefineID(rtag) == spriteid && !config.isframe)
637             {
638                 if(config.overlay)
639                 {
640                     tag = swf_InsertTag(tag, rtag->id);
641                     swf_SetBlock(tag, rtag->data, rtag->len);
642                     swf_SetDefineID(tag, replaceddefine);
643                 } else {
644                     /* don't write this tag */
645                     logf("<verbose> replacing tag %d id %d with sprite", rtag->id
646                             ,spriteid);
647                 }
648
649                 if(flags&FLAGS_WRITESPRITE)
650                 {
651                     tag = write_sprite_defines(tag, slave);
652                     tag = write_sprite(tag, slave, spriteid, replaceddefine);
653                 }
654                 if(flags&FLAGS_WRITESLAVE)
655                 {
656                     outputslave = 1;
657                 }
658             } else { 
659                 tag = swf_InsertTag(tag, rtag->id);
660                 swf_SetBlock(tag, rtag->data, rtag->len);
661             }
662         }
663         if(frame == slaveframe)
664         {
665             if(flags&FLAGS_WRITESLAVE) {
666                 outputslave = 1;
667                 slavewritten = 1;
668             }
669             if((flags&FLAGS_WRITESPRITE) && !slavewritten)
670             {
671                 int id = get_free_id(masterbitmap);
672                 int depth = 0;
673                 if(config.clip) {
674                     logf("<fatal> Can't combine --clip and --frame");
675                 }
676                 
677                 tag = write_sprite_defines(tag, slave);
678                 tag = write_sprite(tag, slave, id, -1);
679
680                 tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
681                     swf_SetU8(tag, 2); //flags: id
682                     swf_SetU16(tag, depth);
683                     swf_SetU16(tag, id);
684
685                 slavewritten = 1;
686             }
687         }
688         if(!swf_isDefiningTag(rtag) && (flags&FLAGS_WRITENONDEFINES))
689         {
690             int dontwrite = 0;
691             switch(rtag->id) {
692                 case ST_PLACEOBJECT:
693                 case ST_PLACEOBJECT2:
694                     if(frame == slaveframe && !config.overlay)
695                         dontwrite = 1;
696                 case ST_REMOVEOBJECT:
697 //              case ST_REMOVEOBJECT2:
698                     /* place/removetags for the object we replaced
699                        should be discarded, too, as the object to insert 
700                        isn't a sprite 
701                      */
702                     if(spriteid>=0 && swf_GetPlaceID(rtag) == spriteid && 
703                             !config.isframe && config.merge)
704                         dontwrite = 1;
705                 break;
706             }
707             if(!dontwrite) {
708                 logf("<debug> [master] write tag %02x (%d bytes in body)", 
709                         rtag->id, rtag->len);
710                 tag = swf_InsertTag(tag, rtag->id);
711                 swf_SetBlock(tag, rtag->data, rtag->len);
712             }
713         }
714         rtag = rtag->next;
715     }
716    
717     if(outputslave) 
718     while(stag && stag->id!=ST_END)
719     {
720             if(tag_ok_for_slave(stag->id)) {
721                 tag = swf_InsertTag(tag, stag->id);
722                 swf_SetBlock(tag, stag->data, stag->len);
723             }
724             stag = stag->next;
725     }
726     if(!slavewritten && config.isframe && (flags&(FLAGS_WRITESLAVE|FLAGS_WRITESPRITE)))
727     {
728         if(slaveframe>=0)
729             logf("<warning> Frame %d doesn't exist in file. No substitution will occur",
730                     slaveframe);
731         else
732             logf("<warning> Frame \"%s\" doesn't exist in file. No substitution will occur",
733                     slavename);
734     }
735     tag = swf_InsertTag(tag, ST_END);
736     return tag;
737 }
738
739 void adjustheader(SWF*swf)
740 {
741     if(config.framerate)
742         swf->frameRate = config.framerate;
743     if(config.hassizex) {
744         swf->movieSize.xmax = 
745         swf->movieSize.xmin + config.sizex;
746     }
747     if(config.hassizey) {
748         swf->movieSize.ymax = 
749         swf->movieSize.ymin + config.sizey;
750     }
751 }
752
753 void catcombine(SWF*master, char*slave_name, SWF*slave, SWF*newswf)
754 {
755     char* depths;
756     int t;
757     TAG*tag;
758     TAG*mtag,*stag;
759     if(config.isframe) {
760         logf("<fatal> Can't combine --cat and --frame");
761         exit(1);
762     }
763    
764     tag = master->firstTag;
765     while(tag)
766     {
767         if(swf_isDefiningTag(tag)) {
768             int defineid = swf_GetDefineID(tag);
769             logf("<debug> tagid %02x defines object %d", tag->id, defineid);
770             masterbitmap[defineid] = 1;
771         }
772         tag = tag->next;
773     }
774     
775     swf_Relocate(slave, masterbitmap);
776     jpeg_assert(master, slave);
777     
778     memcpy(newswf, master, sizeof(SWF));
779     adjustheader(newswf);
780
781     tag = newswf->firstTag = swf_InsertTag(0, ST_REFLEX); // to be removed later
782
783     depths = malloc(65536);
784     if(!depths) {
785         logf("<fatal> Couldn't allocate %d bytes of memory", 65536);
786         return;
787     }
788     memset(depths, 0, 65536);
789     mtag = master->firstTag;
790     while(mtag && mtag->id!=ST_END)
791     {
792         int num=1;
793         U16 depth;
794         logf("<debug> [master] write tag %02x (%d bytes in body)", 
795                 mtag->id, mtag->len);
796         switch(mtag->id) {
797             case ST_PLACEOBJECT2:
798                 num++;
799             case ST_PLACEOBJECT: {
800                depth = swf_GetDepth(mtag);
801                depths[depth] = 1;
802             }
803             break;
804             case ST_REMOVEOBJECT: {
805                depth = swf_GetDepth(mtag);
806                depths[depth] = 0;
807             }
808             break;
809             case ST_REMOVEOBJECT2: {
810                depth = swf_GetDepth(mtag);
811                depths[depth] = 0;
812             }
813             break;
814         }
815         tag = swf_InsertTag(tag, mtag->id);
816         swf_SetBlock(tag, mtag->data, mtag->len);
817
818         mtag = mtag->next;
819     }
820
821     for(t=0;t<65536;t++) 
822     if(depths[t])
823     {
824         char data[16];
825         int len;
826         tag = swf_InsertTag(tag, ST_REMOVEOBJECT2);
827         swf_SetU16(tag, t);
828     }
829     free(depths);
830
831     stag = slave->firstTag;
832     while(stag && stag->id!=ST_END)
833     {
834         logf("<debug> [slave] write tag %02x (%d bytes in body)", 
835                 stag->id, stag->len);
836         tag = swf_InsertTag(tag, stag->id);
837         swf_SetBlock(tag, stag->data, stag->len);
838         stag = stag->next;
839     }
840     tag = swf_InsertTag(tag, ST_END);
841
842     tag = newswf->firstTag;
843     newswf->firstTag = newswf->firstTag->next; //remove temporary tag
844     swf_DeleteTag(tag);
845 }
846
847 void normalcombine(SWF*master, char*slave_name, SWF*slave, SWF*newswf)
848 {
849     int spriteid = -1;
850     int replaceddefine = -1;
851     int frame = 0;
852     char*framelabel;
853     TAG * tag = master->firstTag;
854     
855     // set the idtab
856     while(tag)
857     {
858         if(swf_isDefiningTag(tag)) {
859             int defineid = swf_GetDefineID(tag);
860             logf("<debug> tagid %02x defines object %d", tag->id, defineid);
861             masterbitmap[defineid] = 1;
862         } else if(tag->id == ST_PLACEOBJECT2) {
863             char * name = swf_GetName(tag);
864             int id = swf_GetPlaceID(tag);
865
866             if(name)
867               logf("<verbose> tagid %02x places object %d named \"%s\"", tag->id, id, name);
868             else
869               logf("<verbose> tagid %02x places object %d (no name)", tag->id, id);
870
871             if ((name && slavename && !strcmp(name,slavename)) || 
872                 (!slavename && id==slaveid)) {
873                 if(id>=0) {
874                   spriteid = id;
875                   logf("<notice> Slave file attached to object %d.", id);
876                 }
877             }
878         } else if(tag->id == ST_SHOWFRAME) {
879             if(slaveframe>=0 && frame==slaveframe) {
880                 logf("<notice> Slave file attached to frame %d.", frame);
881             }
882             frame++;
883         } else if(tag->id == ST_FRAMELABEL) {
884             char * name = tag->data;
885             if(name && slavename && config.isframe && !strcmp(name, slavename)) {
886                 slaveframe = frame;
887                 logf("<notice> Slave file attached to frame %d (%s).", frame, name);
888             }
889         }
890         tag = tag->next;
891     };
892
893     if (spriteid<0 && !config.isframe) {
894         if(slavename) {
895             if(strcmp(slavename,"!!dummy!!"))
896                 logf("<warning> Didn't find anything named %s in file. No substitutions will occur.", slavename);
897         }
898         else
899             logf("<warning> Didn't find id %d in file. No substitutions will occur.", slaveid);
900         spriteid = get_free_id(masterbitmap);
901     }
902
903     swf_Relocate (slave, masterbitmap);
904     jpeg_assert(slave, master);
905     
906     if (config.overlay)
907         replaceddefine = get_free_id(masterbitmap);
908     
909     // write file 
910
911     memcpy(newswf, master, sizeof(SWF));
912     adjustheader(newswf);
913
914     newswf->firstTag = tag = swf_InsertTag(0, ST_REFLEX); // to be removed later
915
916     if (config.antistream) {
917         if (config.merge) {
918             logf("<fatal> Can't combine --antistream and --merge");
919         }
920         tag = write_sprite_defines(tag, slave);
921         tag = write_sprite(tag, slave, spriteid, replaceddefine);
922         tag = write_master(tag, master, slave, spriteid, replaceddefine, FLAGS_WRITEDEFINES);
923         tag = write_master(tag, master, slave, spriteid, replaceddefine, FLAGS_WRITENONDEFINES);
924     } else {
925         if (config.merge)
926             tag = write_master(tag, master, slave, spriteid, replaceddefine, 
927                 FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESLAVE);
928         else
929             tag = write_master(tag, master, slave, spriteid, replaceddefine, 
930                 FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESPRITE);
931     }
932
933     tag = newswf->firstTag;
934     newswf->firstTag = newswf->firstTag->next; //remove temporary tag
935     swf_DeleteTag(tag);
936 }
937
938 void combine(SWF*master, char*slave_name, SWF*slave, SWF*newswf)
939 {
940     slavename = slave_name;
941     slaveid = -1;
942     slaveframe = -1;
943
944     swf_FoldAll(master);
945     swf_FoldAll(slave);
946
947     if(slavename[0] == '#')
948     {
949         slaveid = atoi(&slavename[1]);
950         slavename = 0;
951     }
952
953     if(config.isframe)
954     {
955         int tmp;
956         if(slavename && slavename[0]!='#' && (sscanf(slavename, "%d", &tmp) ==
957                 strlen(slavename))) {
958         /* if the name the slave should replace 
959            consists only of digits and the -f
960            option is given, it probably is not
961            a frame name but a frame number.
962          */
963             slaveid = tmp;
964             slavename = 0;
965         }
966
967         if(slaveid>=0) {
968             slaveframe = slaveid;
969             slaveid = -1;
970         } else {
971         /* if id wasn't given as either #number or number,
972            the name is a frame label. BTW: The user wouldn't have
973            needed to supply the -f option in this case */
974         }
975     }
976
977     logf("<debug> move x (%d)", config.movex);
978     logf("<debug> move y (%d)", config.movey);
979     logf("<debug> scale x (%f)", config.scalex);
980     logf("<debug> scale y (%f)", config.scaley);
981     logf("<debug> is frame (%d)", config.isframe);
982     
983     memset(masterbitmap, 0, sizeof(masterbitmap));
984
985     if(config.cat) 
986         return catcombine(master, slave_name, slave, newswf);
987     else
988         return normalcombine(master, slave_name, slave, newswf);
989 }
990
991 int main(int argn, char *argv[])
992 {
993     int fi;
994     SWF master;
995     SWF slave;
996     SWF newswf;
997     int t;
998
999     config.overlay = 0; 
1000     config.antistream = 0; 
1001     config.alloctest = 0;
1002     config.cat = 0;
1003     config.merge = 0;
1004     config.clip = 0;
1005     config.loglevel = 2; 
1006     config.movex = 0;
1007     config.movey = 0;
1008     config.scalex = 1.0;
1009     config.scaley = 1.0;
1010     config.sizex = 0;
1011     config.sizey = 0;
1012     config.hassizex = 0;
1013     config.hassizey = 0;
1014     config.framerate = 0;
1015     config.stack = 0;
1016     config.stack1 = 0;
1017     config.dummy = 0;
1018     config.zlib = 0;
1019
1020     processargs(argn, argv);
1021     initLog(0,-1,0,0,-1,config.loglevel);
1022
1023     if(config.merge && config.cat) {
1024         logf("<error> Can't combine --cat and --merge");
1025         exit(1);
1026     }
1027
1028     if(config.stack) {
1029         if(config.overlay) {
1030             logf("<error> Can't combine -l and -t");
1031             exit(1);
1032         }
1033         if(config.clip) {
1034             logf("<error> Can't combine -c and -t");
1035             exit(1);
1036         }
1037         logf("<verbose> (stacking) %d files found\n", numslaves);
1038
1039         makestackmaster(&master);
1040     }
1041     else {
1042         int ret;
1043         logf("<verbose> master entity %s (named \"%s\")\n", master_filename, master_name);
1044         fi = open(master_filename, O_RDONLY);
1045         if(fi<0) {
1046             logf("<fatal> Failed to open %s\n", master_filename);
1047             exit(1);
1048         }
1049         ret = swf_ReadSWF(fi, &master);
1050         if(ret<0) {
1051             logf("<fatal> Failed to read from %s\n", master_filename);
1052             exit(1);
1053         }
1054         logf("<debug> Read %d bytes from masterfile\n", ret);
1055         close(fi);
1056     }
1057
1058     for(t=0;t<numslaves;t++) {
1059             logf("<verbose> slave entity(%d) %s (%s \"%s\")\n", t+1, slave_filename[t], 
1060                     slave_isframe[t]?"frame":"object", slave_name[t]);
1061     }
1062
1063     if(config.dummy)
1064     {
1065         if(numslaves)
1066         {
1067             logf("<error> --dummy (-d) implies there are zero slave objects. You supplied %d.", numslaves);
1068             exit(1);
1069         }
1070         numslaves = 1;
1071         slave_filename[0] = "!!dummy!!";
1072         slave_name[0] = "!!dummy!!";
1073         slave_isframe[0] = 0;
1074     }
1075
1076     if (config.alloctest)
1077     {
1078         char*bitmap = malloc(sizeof(char)*65536);
1079         memset(bitmap, 0, 65536*sizeof(char));
1080         memset(bitmap, 1, 101*sizeof(char));
1081         swf_Relocate(&master, bitmap);
1082         newswf = master;
1083         free(bitmap);
1084 //      makestackmaster(&newswf);
1085     }
1086     else
1087     {
1088         if (!numslaves)
1089         {
1090             if(config.cat)
1091                 logf("<error> You must have at least two objects.");
1092             else
1093                 logf("<error> You must have at least one slave entity.");
1094             return 0;
1095         }
1096         for(t = 0; t < numslaves; t++)
1097         {
1098             config.movex = slave_movex[t];
1099             config.movey = slave_movey[t];
1100             config.scalex = slave_scalex[t];
1101             config.scaley = slave_scaley[t];
1102             config.isframe = slave_isframe[t];
1103
1104             logf("<notice> Combine [%s]%s and [%s]%s", master_name, master_filename,
1105                     slave_name[t], slave_filename[t]);
1106             if(!config.dummy)
1107             {
1108                 int ret;
1109                 fi = open(slave_filename[t], O_RDONLY);
1110                 if(!fi) {
1111                     logf("<fatal> Failed to open %s\n", slave_filename[t]);
1112                     exit(1);
1113                 }
1114                 ret = swf_ReadSWF(fi, &slave);
1115                 if(ret<0) {
1116                     logf("<fatal> Failed to read from %s\n", slave_filename[t]);
1117                     exit(1);
1118                 }
1119                 logf("<debug> Read %d bytes from slavefile\n", ret);
1120                 close(fi);
1121             }
1122             else
1123             {
1124                 memset(&slave, 0, sizeof(slave));
1125                 slave.firstTag = swf_InsertTag(0, ST_END);
1126                 slave.frameRate = 0;
1127                 slave.fileVersion = 4;
1128                 slave.frameCount = 0;
1129             }
1130
1131             combine(&master, slave_name[t], &slave, &newswf);
1132             master = newswf;
1133         }
1134     }
1135
1136     fi = open(outputname, O_RDWR|O_TRUNC|O_CREAT, 0777);
1137
1138     if(config.zlib)
1139         swf_WriteSWC(fi, &newswf);
1140     else {
1141         newswf.compressed = 0;
1142         swf_WriteSWF(fi, &newswf);
1143     }
1144     close(fi);
1145     return 0;
1146 }
1147