fix: don't flatten sprites more than once.
[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     memset(&box, 0, sizeof(box));
263
264     /* scan all slaves for bounding box */
265     for(t=0;t<numslaves;t++)
266     {
267         SWF head;
268         int ret;
269         int fi=open(slave_filename[t],O_RDONLY);
270         if(fi<0 || swf_ReadSWF(fi, &head)<0) {
271             logf("<fatal> Couldn't open/read %s.", slave_filename[t]);
272             exit(1);
273         }
274         close(fi);
275         logf("<verbose> File %s has bounding box %d:%d:%d:%d\n",
276                 slave_filename[t], 
277                 head.movieSize.xmin, head.movieSize.ymin,
278                 head.movieSize.xmax, head.movieSize.ymax);
279         if(head.fileVersion > fileversion)
280             fileversion = head.fileVersion;
281         if(!t)
282             box = head.movieSize;
283         else {
284             if(head.movieSize.xmin < box.xmin)
285                 box.xmin = head.movieSize.xmin;
286             if(head.movieSize.ymin < box.ymin)
287                 box.ymin = head.movieSize.ymin;
288             if(head.movieSize.xmax > box.xmax)
289                 box.xmax = head.movieSize.xmax;
290             if(head.movieSize.ymax > box.ymax)
291                 box.ymax = head.movieSize.ymax;
292         }
293         logf("<verbose> New master bounding box is %d:%d:%d:%d\n",
294                 box.xmin, box.ymin,
295                 box.xmax, box.ymax);
296         swf_FreeTags(&head);
297     }
298
299     memset(swf, 0, sizeof(SWF));
300
301     swf->firstTag = swf_InsertTag(tag, ST_SETBACKGROUNDCOLOR);
302     tag = swf->firstTag;
303     swf_SetU8(tag, 0);
304     swf_SetU8(tag, 0);
305     swf_SetU8(tag, 0);
306     
307     for(t=0;t<numslaves;t++)
308     {
309         char buf[128];
310         sprintf(buf, "Frame%02d", t);
311         slave_name[t] = strdup(buf);
312
313         tag = swf_InsertTag(tag, ST_DEFINESPRITE);
314         swf_SetU16(tag, t+1);
315         swf_SetU16(tag, 0);
316         tag = swf_InsertTag(tag, ST_END);
317         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
318         swf_ObjectPlace(tag, t+1, 1+t,0,0, slave_name[t]);
319
320         if(!config.stack1 || t == numslaves-1) {
321             tag = swf_InsertTag(tag, ST_SHOWFRAME);
322         }
323         if(!config.stack)
324         if(t!=numslaves-1)
325         {
326             tag = swf_InsertTag(tag, ST_REMOVEOBJECT2);
327             swf_SetU16(tag, 1+t);
328         }
329     }
330     tag = swf_InsertTag(tag, ST_END);
331 }
332
333 static char* slavename = 0;
334 static int slaveid = -1;
335 static int slaveframe = -1;
336 static char masterbitmap[65536];
337
338 #define FLAGS_WRITEDEFINES 1
339 #define FLAGS_WRITENONDEFINES 2
340 #define FLAGS_WRITESPRITE 4
341 #define FLAGS_WRITESLAVE 8
342
343 int get_free_id(char*bitmap)
344 {
345     int t;
346     for(t=1;t<65536;t++)
347         if(!bitmap[t]) {
348             bitmap[t] = 1;
349             return t;
350         }
351     return -1;
352 }
353
354 void jpeg_assert(SWF*master, SWF*slave)
355 {
356     /* TODO: if there's a jpegtable found, store it
357        and handle it together with the flash file
358        headers */
359
360     /* check that master and slave don't have both
361        jpegtables (which would be fatal) */
362     int pos;
363     TAG *mpos=0, *spos=0;
364     TAG *mtag,*stag;
365     pos = 0;
366     mtag = master->firstTag;
367     stag = slave->firstTag;
368     while(mtag)
369     {
370         if(mtag->id  == ST_JPEGTABLES)
371             mpos = mtag;
372         mtag = mtag->next;
373     }
374     while(stag)
375     {
376         if(stag->id == ST_JPEGTABLES)
377             spos = stag;
378         stag = stag->next;
379     }
380     if(mpos && spos)
381     {
382         if(spos->len == mpos->len &&
383         !memcmp(spos->data, mpos->data, mpos->len))
384         {
385             // ok, both have jpegtables, but they're identical.
386             // delete one and don't throw an error
387             swf_DeleteTag(spos);
388             spos = 0;
389         }
390     }
391     if(spos && mpos) {
392         logf("<error> Master and slave have incompatible JPEGTABLES.");
393     }
394 }
395
396 TAG* write_sprite_defines(TAG*tag, SWF*sprite)
397 {
398     TAG*rtag = sprite->firstTag;
399     while(rtag && rtag->id!=ST_END) {
400         if(!swf_isAllowedSpriteTag(rtag)) {
401             logf("<debug> processing sprite tag %02x", tag->id);
402             if(swf_isDefiningTag(rtag))
403             {
404                 logf("<debug> [sprite defs] write tag %02x (%d bytes in body)", 
405                         tag->id, tag->len);
406                 tag = swf_InsertTag(tag, rtag->id);
407                 swf_SetBlock(tag, rtag->data, rtag->len);
408             }
409             else if(swf_isPseudoDefiningTag(rtag))
410             {
411                 logf("<debug> [sprite defs] write tag %02x (%d bytes in body)", 
412                         tag->id, tag->len);
413                 tag = swf_InsertTag(tag, rtag->id);
414                 swf_SetBlock(tag, rtag->data, rtag->len);
415             }
416             else {
417                 switch(rtag->id)
418                 {
419                     case ST_JPEGTABLES:
420                            /* if we get here, jpeg_assert has already run,
421                               ensuring this is the only one of it's kind,
422                               so we may safely write it out */
423                            tag = swf_InsertTag(tag, rtag->id);
424                            swf_SetBlock(tag, rtag->data, rtag->len);
425                        break;
426                     case ST_EXPORTASSETS:
427                        logf("<debug> deliberately ignoring EXPORTASSETS tag");
428                        break;
429                     case ST_ENABLEDEBUGGER:
430                        logf("<debug> deliberately ignoring ENABLEDEBUGGER tag");
431                        break;
432                     case ST_SETBACKGROUNDCOLOR:
433                        logf("<debug> deliberately ignoring BACKGROUNDCOLOR tag");
434                        break;
435                     case 40:
436                     case 49:
437                     case 51:
438                        logf("<notice> found tag %d. This is a Generator template, isn't it?", tag->id);
439                        break;
440                     default:
441                        logf("<notice> funny tag: %d is neither defining nor sprite", tag->id);
442                 }
443             }
444         }
445         rtag = rtag->next;
446     }
447     return tag;
448 }
449
450 void changedepth(TAG*tag, int add)
451 {
452     /* fucking byteorders */
453     if(tag->id == ST_PLACEOBJECT)
454         PUT16(&tag->data[2],GET16(&tag->data[2])+add);
455     if(tag->id == ST_PLACEOBJECT2)
456         PUT16(&tag->data[1],GET16(&tag->data[1])+add);
457     if(tag->id == ST_REMOVEOBJECT)
458         PUT16(&tag->data[2],GET16(&tag->data[2])+add);
459     if(tag->id == ST_REMOVEOBJECT2)
460         PUT16(&tag->data[0],GET16(&tag->data[0])+add);
461 }
462
463 void matrix_adjust(MATRIX*m)
464 {
465     m->sx = (int)(m->sx*config.scalex);
466     m->sy = (int)(m->sy*config.scaley);
467     m->r0 = (int)(m->r0*config.scalex);
468     m->r1 = (int)(m->r1*config.scaley);
469     m->tx += config.movex;
470     m->ty += config.movey;
471 }
472
473 void write_changepos(TAG*output, TAG*tag)
474 {
475     if(config.movex || config.movey || config.scalex != 1 || config.scaley != 1)
476     {
477         switch(tag->id)
478         {
479             case ST_PLACEOBJECT2: {
480                 MATRIX m;
481                 U8 flags;
482                 swf_GetMatrix(0, &m);
483
484                 flags = swf_GetU8(tag);
485                 swf_SetU8(output, flags|4);
486                 swf_SetU16(output, swf_GetU16(tag)); //depth
487                 //flags&1: move
488                 if(flags&2) {
489                     swf_SetU16(output, swf_GetU16(tag)); //id
490                 }
491                 // flags & 4
492                 swf_GetMatrix(tag, &m);
493                 matrix_adjust(&m);
494                 swf_SetMatrix(output, &m);
495
496                 //swf_ResetReadBits(tag);
497                 swf_SetBlock(output, &tag->data[tag->pos], tag->len - tag->pos);
498                 break;
499             }
500             case ST_PLACEOBJECT: {
501                 MATRIX m;
502                 swf_SetU16(output, swf_GetU16(tag)); //id
503                 swf_SetU16(output, swf_GetU16(tag)); //depth
504                 
505                 swf_GetMatrix(tag, &m);
506                 matrix_adjust(&m);
507                 swf_SetMatrix(output, &m);
508                 
509                 //swf_ResetReadBits(tag);
510                 swf_SetBlock(output, &tag->data[tag->pos], tag->len - tag->pos);
511                 break;
512             }
513             default:
514             swf_SetBlock(output, tag->data, tag->len);
515         }
516     } 
517     else 
518     {
519             swf_SetBlock(output, tag->data, tag->len);
520     }
521 }
522
523 TAG* write_sprite(TAG*tag, SWF*sprite, int spriteid, int replaceddefine)
524 {
525     TAG* definespritetag;
526     TAG* rtag;
527     int tmp;
528
529     definespritetag = tag = swf_InsertTag(tag, ST_DEFINESPRITE);
530     swf_SetU16(tag, spriteid);
531     swf_SetU16(tag, sprite->frameCount);
532     logf ("<notice> sprite id is %d", spriteid);
533
534     tmp = sprite->frameCount;
535     logf("<debug> %d frames to go",tmp);
536
537     if(config.clip) {
538         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
539         swf_SetU8(tag, 2+64); //flags: character+clipdepth
540         swf_SetU16(tag, 0); //depth
541         swf_SetU16(tag, replaceddefine); //id
542         swf_SetU16(tag, 65535); //clipdepth
543     }
544
545     if(config.overlay && !config.isframe) {
546         tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
547         swf_SetU8(tag, 2); //flags: character
548         swf_SetU16(tag, 0); //depth
549         swf_SetU16(tag, replaceddefine); //id
550     }
551
552     rtag = sprite->firstTag;
553     while(rtag && rtag->id!=ST_END)
554     {
555         if (swf_isAllowedSpriteTag(rtag)) {
556
557             logf("<debug> [sprite main] write tag %02x (%d bytes in body)", 
558                     rtag->id, rtag->len);
559             tag = swf_InsertTag(tag, rtag->id);
560             write_changepos(tag, rtag);
561           
562             changedepth(tag, +1);
563
564             if(tag->id == ST_SHOWFRAME)
565             {
566                 tmp--;
567                 logf("<debug> %d frames to go",tmp);
568             }
569         }
570         rtag = rtag->next;
571     }
572     tag = swf_InsertTag(tag, ST_END);
573     return tag;
574 }
575
576 static char tag_ok_for_slave(int id)
577 {
578     if(id == ST_SETBACKGROUNDCOLOR)
579         return 0;
580     return 1;
581 }
582
583 TAG* write_master(TAG*tag, SWF*master, SWF*slave, int spriteid, int replaceddefine, int flags)
584 {
585     int outputslave = 0;
586     int frame = 0;
587     int sframe = 0;
588     int slavewritten = 0;
589
590     TAG* rtag = master->firstTag;
591     TAG* stag = slave->firstTag;
592
593     while(rtag && rtag->id!=ST_END)
594     {
595         if(rtag->id == ST_SHOWFRAME && outputslave)
596         {
597             while(stag && stag->id!=ST_END) {
598                 if(stag->id == ST_SHOWFRAME) {
599                     stag = stag->next;
600                     sframe++;
601                     break;
602                 }
603                 if(tag_ok_for_slave(stag->id)) {
604                     tag = swf_InsertTag(tag, stag->id);
605                     swf_SetBlock(tag, stag->data, stag->len);
606                 }
607                 stag = stag->next;
608             }
609         }
610         if(rtag->id == ST_SHOWFRAME)
611         {
612             frame ++;
613         }
614
615         if(swf_isDefiningTag(rtag) && (flags&FLAGS_WRITEDEFINES))
616         {
617             logf("<debug> [master] write tag %02x (%d bytes in body)", 
618                     rtag->id, rtag->len);
619             if(swf_GetDefineID(rtag) == spriteid && !config.isframe)
620             {
621                 if(config.overlay)
622                 {
623                     tag = swf_InsertTag(tag, rtag->id);
624                     swf_SetBlock(tag, rtag->data, rtag->len);
625                     swf_SetDefineID(tag, replaceddefine);
626                 } else {
627                     /* don't write this tag */
628                     logf("<verbose> replacing tag %d id %d with sprite", rtag->id
629                             ,spriteid);
630                 }
631
632                 if(flags&FLAGS_WRITESPRITE)
633                 {
634                     tag = write_sprite_defines(tag, slave);
635                     tag = write_sprite(tag, slave, spriteid, replaceddefine);
636                 }
637                 if(flags&FLAGS_WRITESLAVE)
638                 {
639                     outputslave = 1;
640                 }
641             } else { 
642                 tag = swf_InsertTag(tag, rtag->id);
643                 swf_SetBlock(tag, rtag->data, rtag->len);
644             }
645         }
646         if(frame == slaveframe)
647         {
648             if(flags&FLAGS_WRITESLAVE) {
649                 outputslave = 1;
650                 slavewritten = 1;
651             }
652             if((flags&FLAGS_WRITESPRITE) && !slavewritten)
653             {
654                 int id = get_free_id(masterbitmap);
655                 int depth = 0;
656                 if(config.clip) {
657                     logf("<fatal> Can't combine --clip and --frame");
658                 }
659                 
660                 tag = write_sprite_defines(tag, slave);
661                 tag = write_sprite(tag, slave, id, -1);
662
663                 tag = swf_InsertTag(tag, ST_PLACEOBJECT2);
664                     swf_SetU8(tag, 2); //flags: id
665                     swf_SetU16(tag, depth);
666                     swf_SetU16(tag, id);
667
668                 slavewritten = 1;
669             }
670         }
671         if(!swf_isDefiningTag(rtag) && (flags&FLAGS_WRITENONDEFINES))
672         {
673             int dontwrite = 0;
674             switch(rtag->id) {
675                 case ST_PLACEOBJECT:
676                 case ST_PLACEOBJECT2:
677                     if(frame == slaveframe && !config.overlay)
678                         dontwrite = 1;
679                 case ST_REMOVEOBJECT:
680 //              case ST_REMOVEOBJECT2:
681                     /* place/removetags for the object we replaced
682                        should be discarded, too, as the object to insert 
683                        isn't a sprite 
684                      */
685                     if(spriteid>=0 && swf_GetPlaceID(rtag) == spriteid && 
686                             !config.isframe && config.merge)
687                         dontwrite = 1;
688                 break;
689             }
690             if(!dontwrite) {
691                 logf("<debug> [master] write tag %02x (%d bytes in body)", 
692                         rtag->id, rtag->len);
693                 tag = swf_InsertTag(tag, rtag->id);
694                 swf_SetBlock(tag, rtag->data, rtag->len);
695             }
696         }
697         rtag = rtag->next;
698     }
699    
700     if(outputslave) 
701     while(stag && stag->id!=ST_END)
702     {
703             if(tag_ok_for_slave(stag->id)) {
704                 tag = swf_InsertTag(tag, stag->id);
705                 swf_SetBlock(tag, stag->data, stag->len);
706             }
707             stag = stag->next;
708     }
709     if(!slavewritten && config.isframe && (flags&(FLAGS_WRITESLAVE|FLAGS_WRITESPRITE)))
710     {
711         if(slaveframe>=0)
712             logf("<warning> Frame %d doesn't exist in file. No substitution will occur",
713                     slaveframe);
714         else
715             logf("<warning> Frame \"%s\" doesn't exist in file. No substitution will occur",
716                     slavename);
717     }
718     return tag;
719 }
720
721 void catcombine(SWF*master, char*slave_name, SWF*slave, SWF*newswf)
722 {
723     char* depths;
724     int t;
725     TAG*tag;
726     TAG*mtag,*stag;
727     if(config.isframe) {
728         logf("<fatal> Can't combine --cat and --frame");
729         exit(1);
730     }
731    
732     tag = master->firstTag;
733     while(tag)
734     {
735         if(swf_isDefiningTag(tag)) {
736             int defineid = swf_GetDefineID(tag);
737             logf("<debug> tagid %02x defines object %d", tag->id, defineid);
738             masterbitmap[defineid] = 1;
739         }
740     }
741     
742     swf_Relocate(slave, masterbitmap);
743     jpeg_assert(master, slave);
744     
745     memcpy(newswf, master, sizeof(SWF));
746     tag = newswf->firstTag = swf_InsertTag(0, ST_REFLEX);
747
748     depths = malloc(65536);
749     if(!depths) {
750         logf("<fatal> Couldn't allocate %d bytes of memory", 65536);
751         return;
752     }
753     memset(depths, 0, 65536);
754     mtag = master->firstTag;
755     while(mtag)
756     {
757         int num=1;
758         U16 depth;
759         logf("<debug> [master] write tag %02x (%d bytes in body)", 
760                 mtag->id, mtag->len);
761         switch(mtag->id) {
762             case ST_PLACEOBJECT2:
763                 num++;
764             case ST_PLACEOBJECT: {
765                depth = swf_GetDepth(mtag);
766                depths[depth] = 1;
767             }
768             break;
769             case ST_REMOVEOBJECT: {
770                depth = swf_GetDepth(mtag);
771                depths[depth] = 0;
772             }
773             break;
774             case ST_REMOVEOBJECT2: {
775                depth = swf_GetDepth(mtag);
776                depths[depth] = 0;
777             }
778             break;
779         }
780         tag = swf_InsertTag(tag, mtag->id);
781         swf_SetBlock(tag, mtag->data, mtag->len);
782     }
783
784     for(t=0;t<65536;t++) 
785     if(depths[t])
786     {
787         char data[16];
788         int len;
789         tag = swf_InsertTag(tag, ST_REMOVEOBJECT2);
790         swf_SetU16(tag, t);
791     }
792     free(depths);
793
794     stag = slave->firstTag;
795     while(stag)
796     {
797         logf("<debug> [slave] write tag %02x (%d bytes in body)", 
798                 stag->id, stag->len);
799         tag = swf_InsertTag(tag, stag->id);
800         swf_SetBlock(tag, stag->data, stag->len);
801         stag = stag->next;
802     }
803 }
804
805 void normalcombine(SWF*master, char*slave_name, SWF*slave, SWF*newswf)
806 {
807     int spriteid = -1;
808     int replaceddefine = -1;
809     int frame = 0;
810     char*framelabel;
811     TAG * tag = master->firstTag;
812     
813     // set the idtab
814     while(tag)
815     {
816         if(swf_isDefiningTag(tag)) {
817             int defineid = swf_GetDefineID(tag);
818             logf("<debug> tagid %02x defines object %d", tag->id, defineid);
819             masterbitmap[defineid] = 1;
820         } else if(tag->id == ST_PLACEOBJECT2) {
821             char * name = swf_GetName(tag);
822             int id = swf_GetPlaceID(tag);
823
824             if(name)
825               logf("<verbose> tagid %02x places object %d named \"%s\"", tag->id, id, name);
826             else
827               logf("<verbose> tagid %02x places object %d (no name)", tag->id, id);
828
829             if ((name && slavename && !strcmp(name,slavename)) || 
830                 (!slavename && id==slaveid)) {
831                 if(id>=0) {
832                   spriteid = id;
833                   logf("<notice> Slave file attached to object %d.", id);
834                 }
835             }
836         } else if(tag->id == ST_SHOWFRAME) {
837             if(slaveframe>=0 && frame==slaveframe) {
838                 logf("<notice> Slave file attached to frame %d.", frame);
839             }
840             frame++;
841         } else if(tag->id == ST_FRAMELABEL) {
842             char * name = tag->data;
843             if(name && slavename && config.isframe && !strcmp(name, slavename)) {
844                 slaveframe = frame;
845                 logf("<notice> Slave file attached to frame %d (%s).", frame, name);
846             }
847         }
848         tag = tag->next;
849     };
850
851     if (spriteid<0 && !config.isframe) {
852         if(slavename) {
853             if(strcmp(slavename,"!!dummy!!"))
854                 logf("<warning> Didn't find anything named %s in file. No substitutions will occur.", slavename);
855         }
856         else
857             logf("<warning> Didn't find id %d in file. No substitutions will occur.", slaveid);
858         spriteid = get_free_id(masterbitmap);
859     }
860
861     swf_Relocate (slave, masterbitmap);
862     jpeg_assert(slave, master);
863     
864     if (config.overlay)
865         replaceddefine = get_free_id(masterbitmap);
866     
867     // write file 
868
869     memcpy(newswf, master, sizeof(SWF));
870     newswf->firstTag = tag = swf_InsertTag(0, ST_REFLEX);
871
872     if (config.antistream) {
873         if (config.merge) {
874             logf("<fatal> Can't combine --antistream and --merge");
875         }
876         tag = write_sprite_defines(tag, slave);
877         tag = write_sprite(tag, slave, spriteid, replaceddefine);
878         tag = write_master(tag, master, slave, spriteid, replaceddefine, FLAGS_WRITEDEFINES);
879         tag = write_master(tag, master, slave, spriteid, replaceddefine, FLAGS_WRITENONDEFINES);
880     } else {
881         if (config.merge)
882             tag = write_master(tag, master, slave, spriteid, replaceddefine, 
883                 FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESLAVE);
884         else
885             tag = write_master(tag, master, slave, spriteid, replaceddefine, 
886                 FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESPRITE);
887     }
888 }
889
890 void combine(SWF*master, char*slave_name, SWF*slave, SWF*newswf)
891 {
892     slavename = slave_name;
893     slaveid = -1;
894     slaveframe = -1;
895
896     swf_FoldAll(master);
897     swf_FoldAll(slave);
898
899     if(slavename[0] == '#')
900     {
901         slaveid = atoi(&slavename[1]);
902         slavename = 0;
903     }
904
905     if(config.isframe)
906     {
907         int tmp;
908         if(slavename && slavename[0]!='#' && (sscanf(slavename, "%d", &tmp) ==
909                 strlen(slavename))) {
910         /* if the name the slave should replace 
911            consists only of digits and the -f
912            option is given, it probably is not
913            a frame name but a frame number.
914          */
915             slaveid = tmp;
916             slavename = 0;
917         }
918
919         if(slaveid>=0) {
920             slaveframe = slaveid;
921             slaveid = -1;
922         } else {
923         /* if id wasn't given as either #number or number,
924            the name is a frame label. BTW: The user wouldn't have
925            needed to supply the -f option in this case */
926         }
927     }
928
929     logf("<debug> move x (%d)", config.movex);
930     logf("<debug> move y (%d)", config.movey);
931     logf("<debug> scale x (%f)", config.scalex);
932     logf("<debug> scale y (%f)", config.scaley);
933     logf("<debug> is frame (%d)", config.isframe);
934     
935     memset(masterbitmap, 0, sizeof(masterbitmap));
936
937     if(config.cat) 
938         return catcombine(master, slave_name, slave, newswf);
939     else
940         return normalcombine(master, slave_name, slave, newswf);
941 }
942
943 int main(int argn, char *argv[])
944 {
945     int fi;
946     SWF master;
947     SWF slave;
948     SWF newswf;
949     int t;
950
951     config.overlay = 0; 
952     config.antistream = 0; 
953     config.alloctest = 0;
954     config.cat = 0;
955     config.merge = 0;
956     config.clip = 0;
957     config.loglevel = 2; 
958     config.movex = 0;
959     config.movey = 0;
960     config.scalex = 1.0;
961     config.scaley = 1.0;
962     config.sizex = 0;
963     config.sizey = 0;
964     config.hassizex = 0;
965     config.hassizey = 0;
966     config.framerate = 0;
967     config.stack = 0;
968     config.stack1 = 0;
969     config.dummy = 0;
970     config.zlib = 0;
971
972     processargs(argn, argv);
973     initLog(0,-1,0,0,-1,config.loglevel);
974
975     if(config.merge && config.cat) {
976         logf("<error> Can't combine --cat and --merge");
977         exit(1);
978     }
979
980     if(config.stack) {
981         if(config.overlay) {
982             logf("<error> Can't combine -l and -t");
983             exit(1);
984         }
985         if(config.clip) {
986             logf("<error> Can't combine -c and -t");
987             exit(1);
988         }
989         logf("<verbose> (stacking) %d files found\n", numslaves);
990
991         makestackmaster(&master);
992     }
993     else {
994         int ret;
995         logf("<verbose> master entity %s (named \"%s\")\n", master_filename, master_name);
996         fi = open(master_filename, O_RDONLY);
997         if(fi<0) {
998             logf("<fatal> Failed to open %s\n", master_filename);
999             exit(1);
1000         }
1001         ret = swf_ReadSWF(fi, &master);
1002         if(ret<0) {
1003             logf("<fatal> Failed to read from %s\n", master_filename);
1004             exit(1);
1005         }
1006         logf("<debug> Read %d bytes from masterfile\n", ret);
1007         close(fi);
1008     }
1009
1010     for(t=0;t<numslaves;t++) {
1011             logf("<verbose> slave entity(%d) %s (%s \"%s\")\n", t+1, slave_filename[t], 
1012                     slave_isframe[t]?"frame":"object", slave_name[t]);
1013     }
1014
1015     if(config.dummy)
1016     {
1017         if(numslaves)
1018         {
1019             logf("<error> --dummy (-d) implies there are zero slave objects. You supplied %d.", numslaves);
1020             exit(1);
1021         }
1022         numslaves = 1;
1023         slave_filename[0] = "!!dummy!!";
1024         slave_name[0] = "!!dummy!!";
1025         slave_isframe[0] = 0;
1026     }
1027
1028     if (config.alloctest)
1029     {
1030         char*bitmap = malloc(sizeof(char)*65536);
1031         memset(bitmap, 0, 65536*sizeof(char));
1032         memset(bitmap, 1, 101*sizeof(char));
1033         swf_Relocate(&master, bitmap);
1034         newswf = master;
1035         free(bitmap);
1036 //      makestackmaster(&newswf);
1037     }
1038     else
1039     {
1040         if (!numslaves)
1041         {
1042             if(config.cat)
1043                 logf("<error> You must have at least two objects.");
1044             else
1045                 logf("<error> You must have at least one slave entity.");
1046             return 0;
1047         }
1048         for(t = 0; t < numslaves; t++)
1049         {
1050             config.movex = slave_movex[t];
1051             config.movey = slave_movey[t];
1052             config.scalex = slave_scalex[t];
1053             config.scaley = slave_scaley[t];
1054             config.isframe = slave_isframe[t];
1055
1056             logf("<notice> Combine [%s]%s and [%s]%s", master_name, master_filename,
1057                     slave_name[t], slave_filename[t]);
1058             if(!config.dummy)
1059             {
1060                 int ret;
1061                 fi = open(slave_filename[t], O_RDONLY);
1062                 if(!fi) {
1063                     logf("<fatal> Failed to open %s\n", slave_filename[t]);
1064                     exit(1);
1065                 }
1066                 ret = swf_ReadSWF(fi, &slave);
1067                 if(ret<0) {
1068                     logf("<fatal> Failed to read from %s\n", slave_filename[t]);
1069                     exit(1);
1070                 }
1071                 logf("<debug> Read %d bytes from slavefile\n", ret);
1072                 close(fi);
1073             }
1074             else
1075             {
1076                 memset(&slave, 0, sizeof(slave));
1077                 slave.firstTag = swf_InsertTag(0, ST_END);
1078                 slave.frameRate = 0;
1079                 slave.fileVersion = 4;
1080                 slave.frameCount = 0;
1081             }
1082
1083             combine(&master, slave_name[t], &slave, &newswf);
1084             master = newswf;
1085         }
1086     }
1087
1088     fi = open(outputname, O_RDWR|O_TRUNC|O_CREAT);
1089
1090     if(config.zlib)
1091         swf_WriteSWC(fi, &newswf);
1092     else {
1093         newswf.compressed = 0;
1094         swf_WriteSWF(fi, &newswf);
1095     }
1096     close(fi);
1097     return 0;
1098 }
1099