several big endian fixes
[swftools.git] / src / combine.c
1 /* combine.c 
2    Implements combine(), which merges two swfs in memory.
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 <memory.h>
14 #include "../lib/log.h"
15 #include "../lib/rfxswf.h"
16 #include "./flash.h"
17 #include "./reloc.h"
18 #include "./settings.h"
19
20 static char* slavename = 0;
21 static int slaveid = -1;
22 static int slaveframe = -1;
23
24 static char* tag_placeobject2_name (struct swf_tag* tag)
25 {
26     struct PlaceObject2 plo2;
27     placeobject2_init (&plo2, tag);
28     return plo2.name;
29 }
30
31 static u16 tag_placeobject2_character (struct swf_tag* tag)
32 {
33     struct PlaceObject2 plo2;
34     placeobject2_init (&plo2, tag);
35     return plo2.id;
36 }
37
38 static struct swffile master;
39 static struct swffile slave;
40
41 static int masterids[65536];
42
43 static int get_free_id()
44 {
45     int t;
46     for (t=1;t<65536;t++)
47     {
48         if(masterids[t] == -1)
49         {
50             masterids[t] = 1;
51             return t;
52         }
53     }
54     return -1;
55 }
56
57 void changedepth(struct swf_tag*tag, int add)
58 {
59     /* fucking big endian byte order */
60     if(tag->id == TAGID_PLACEOBJECT)
61         (*(u16*)&tag->data[2]) =
62         SWAP16(SWAP16(*(u16*)&tag->data[2]) + add);
63     if(tag->id == TAGID_PLACEOBJECT2)
64         (*(u16*)&tag->data[1]) =
65         SWAP16(SWAP16(*(u16*)&tag->data[1]) + add);
66     if(tag->id == TAGID_REMOVEOBJECT)
67         (*(u16*)&tag->data[2]) =
68         SWAP16(SWAP16(*(u16*)&tag->data[2]) + add);
69     if(tag->id == TAGID_REMOVEOBJECT2)
70         (*(u16*)&tag->data[0]) =
71         SWAP16(SWAP16(*(u16*)&tag->data[0]) + add);
72 }
73
74 void jpeg_assert()
75 {
76     /* TODO: if there's a jpegtable found, store it
77        and handle it together with the flash file
78        headers */
79     /* check that master and slave don't have both
80        jpegtables (which would be fatal) */
81     int pos;
82     int mpos=-1, spos=-1;
83     pos = 0;
84     while(master.tags[pos].id != 0)
85     {
86         if(master.tags[pos].id == TAGID_JPEGTABLES)
87             mpos = pos;
88         pos++;
89     }
90     pos = 0;
91     while(master.tags[pos].id != 0)
92     {
93         if(slave.tags[pos].id == TAGID_JPEGTABLES)
94             spos = pos;
95         pos++;
96     }
97     if(spos>=0 && mpos>=0)
98     {
99         if(slave.tags[pos].length ==
100            master.tags[pos].length &&
101         !memcmp(slave.tags[pos].data, master.tags[pos].data,
102             master.tags[pos].length))
103         {
104             // ok, both have jpegtables, but they're identical.
105             // delete one and don't make an error
106             for(;spos<slave.tagnum-1;spos++)
107                 slave.tags[spos] =
108                     slave.tags[spos+1];
109             spos = -1;
110         }
111     }
112     if(spos>=0 && mpos>=0) {
113         logf("<error> Master and slave have incompatible JPEGTABLES.");
114     }
115 }
116
117 /* applies the config move and scale parameters to
118  * a matrix. (If settings would provide a rotation,
119  * this would be a matrix concatenation/multiplication
120  * routine. In this case, it's just element-wise multiplication.
121  */
122 void matrix_adjust(struct MATRIX*m)
123 {
124     if(config.scalex != 1 || config.scaley != 1)
125     {
126         if(!m->hasscale) {
127             m->hasscale = 1;
128             m->a[0][0] = config.scalex;
129             m->a[1][1] = config.scaley;
130         } else {
131             m->a[0][0] *= config.scalex;
132             m->a[1][1] *= config.scaley;
133         }
134         if(m->hasrotate) {
135             m->a[0][1] *= config.scalex;
136             m->a[1][0] *= config.scaley;
137         }
138         m->b[0] *= config.scalex;
139         m->b[1] *= config.scaley;
140     }
141 /*    printf("hasscale: %d\n",m->hasscale);
142     printf("hasrotate: %d\n", m->hasrotate);
143     printf("move: %d %d\n", m->b[0],m->b[1]);
144     printf("rot: %f %f\n",m->a[0][0],m->a[0][1]);
145     printf("     %f %f\n",m->a[1][0],m->a[1][1]);*/
146     m->b[0] += config.movex;
147     m->b[1] += config.movey;
148 }
149
150 void write_changepos(struct swf_tag*tag, struct writer_t*w)
151 {
152     if(config.movex || config.movey || config.scalex != 1 || config.scaley != 1)
153     {
154         switch(tag->id)
155         {
156             case TAGID_PLACEOBJECT: {
157                 struct PlaceObject p;
158                 placeobject_init(&p, tag);
159                 matrix_adjust(&p.matrix);
160                 placeobject_write(&p, w);
161                 break;
162             }
163             case TAGID_PLACEOBJECT2: {
164                 struct PlaceObject2 p;
165                 placeobject2_init(&p, tag);
166                 if(!p.hasmatrix) {
167                     p.hasmatrix = 1;
168                     MATRIX_init(&p.matrix);
169                 }
170                 matrix_adjust(&p.matrix);
171                 placeobject2_write(&p, w);
172                 break;
173             }
174             default:
175             writer_write(w, tag->fulldata, tag->fulllength);
176         }
177     } 
178     else 
179     {
180             writer_write(w, tag->fulldata, tag->fulllength);
181     }
182 }
183
184 void write_sprite_defines(struct writer_t*w)
185 {
186     int pos = 0;
187     while(slave.tags[pos].id != 0) {
188         struct swf_tag * tag = &slave.tags[pos];
189         if(!is_sprite_tag(tag->id)) {
190             logf("<debug> processing sprite tag %02x", slave.tags[pos].id);
191             if(is_defining_tag(tag->id))
192             {
193                 logf("<debug> [sprite defs] write tag %02x (%d bytes in body)", 
194                         tag->id, tag->length);
195                 writer_write(w, tag->fulldata, tag->fulllength);
196             }
197             else
198             {
199                 switch(tag->id)
200                 {case TAGID_DEFINEFONTINFO:
201                     {
202                         /* define font info is not a defining tag, in that
203                          * it doesn't define a new id, but rather extends
204                          * an existing one. It also isn't a sprite tag. 
205                          * Anyway we can't throw it out, so we just pass it
206                          * through.
207                          */
208                         writer_write(w, tag->fulldata, tag->fulllength);
209                         break;
210                     }
211                  case TAGID_JPEGTABLES:
212                         /* if we get here, jpeg_assert has already run,
213                            ensuring this is the only one of it's kind,
214                            so we may safely write it out */
215                         writer_write(w, tag->fulldata, tag->fulllength);
216                     break;
217                  case TAGID_EXPORTASSETS:
218                     logf("<debug> deliberately ignoring EXPORTASSETS tag");
219                     break;
220                  case TAGID_ENABLEDEBUGGER:
221                     logf("<debug> deliberately ignoring ENABLEDEBUGGER tag");
222                     break;
223                  case TAGID_BACKGROUNDCOLOR:
224                     logf("<debug> deliberately ignoring BACKGROUNDCOLOR tag");
225                     break;
226                  case 40:
227                  case 49:
228                  case 51:
229                     logf("<notice> found tag %d. This is a Generator template, isn't it?", slave.tags[pos].id);
230                     break;
231                  default:
232                     logf("<notice> funny tag: %d is neither defining nor sprite", slave.tags[pos].id);
233                 }
234             }
235         }
236         pos++;
237     }
238 }
239
240 void write_sprite(struct writer_t*w, int spriteid, int replaceddefine)
241 {
242     u16 tmp;
243     u32 tmp32;
244     u32*tagidpos;
245     u8*startpos;
246     int pos = 0;
247     // write slave(2) (header)
248     tmp = SWAP16(0x3f + (TAGID_DEFINESPRITE << 6));
249     writer_write(w, &tmp, 2);
250     tagidpos = (u32*)writer_getpos(w);
251     writer_write(w, &tmp32, 4);
252     
253     startpos = (u8*)writer_getpos(w);
254
255     logf ("<notice> sprite id is %d", spriteid);
256     tmp = spriteid;
257     writer_write(w, &tmp, 2);
258     tmp = slave.header.count;
259     writer_write(w, &tmp, 2);
260
261
262     // write slave(2) (body)
263     tmp = slave.header.count;
264     logf("<debug> %d frames to go",tmp);
265
266     if(config.clip) {
267         tmp = SWAP16(7 + (TAGID_PLACEOBJECT2 << 6));
268         writer_write(w, &tmp, 2);
269         tmp = SWAP16(2+64); //flags: character + clipaction
270         writer_write(w, &tmp, 1);
271         tmp = SWAP16(0); //depth
272         writer_write(w, &tmp,2);
273         tmp = SWAP16(replaceddefine); //id
274         writer_write(w, &tmp,2);
275         tmp = SWAP16(65535); //clipdepth
276         writer_write(w, &tmp,2);
277     }
278
279     if(config.overlay && !config.isframe) {
280         tmp = SWAP16(5 + (TAGID_PLACEOBJECT2 << 6));
281         writer_write(w, &tmp, 2);
282         tmp = SWAP16(2); //flags: character
283         writer_write(w, &tmp, 1);
284         tmp = SWAP16(0); //depth
285         writer_write(w, &tmp,2);
286         tmp = SWAP16(replaceddefine); //id
287         writer_write(w, &tmp,2);
288     }
289
290     do {
291         struct swf_tag * tag = &slave.tags[pos];
292         if (is_sprite_tag(tag->id)) {
293
294             changedepth(tag, +1);
295             logf("<debug> [sprite main] write tag %02x (%d bytes in body)", 
296                     slave.tags[pos].id, slave.tags[pos].length);
297             write_changepos(tag, w);
298
299             if(tag->id == TAGID_SHOWFRAME)
300             {
301                 tmp--;
302                 logf("<debug> %d frames to go",tmp);
303             }
304         }
305     }
306     while(slave.tags[pos++].id != TAGID_END);
307
308     *tagidpos = SWAP32((u8*)writer_getpos(w) - startpos); // set length of sprite (in header)
309     logf("<verbose> sprite length is %d",SWAP32(*tagidpos));
310 }
311
312 static char tag_ok_for_slave(int id)
313 {
314     if(id == TAGID_BACKGROUNDCOLOR)
315         return 0;
316     return 1;
317 }
318
319 #define FLAGS_WRITEDEFINES 1
320 #define FLAGS_WRITENONDEFINES 2
321 #define FLAGS_WRITESPRITE 4
322 #define FLAGS_WRITESLAVE 8
323 void write_master(struct writer_t*w, int spriteid, int replaceddefine, int flags)
324 {
325     int pos = 0;
326     int spos = 0;
327     int outputslave = 0;
328     int frame = 0;
329     int sframe = 0;
330     int slavewritten = 0;
331     while(master.tags[pos].id != 0)
332     {
333         if(master.tags[pos].id == TAGID_SHOWFRAME && outputslave)
334         {
335             while(slave.tags[spos].id) {
336                 if(slave.tags[spos].id == TAGID_SHOWFRAME) {
337                     spos++;
338                     sframe++;
339                     break;
340                 }
341                 if(tag_ok_for_slave(slave.tags[spos].id))
342                     writer_write(w, slave.tags[spos].fulldata, slave.tags[spos].fulllength);
343                 spos++;
344             }
345             frame ++;
346         }
347
348         if(is_defining_tag(master.tags[pos].id) && (flags&FLAGS_WRITEDEFINES))
349         {
350             logf("<debug> [master] write tag %02x (%d bytes in body)", 
351                     master.tags[pos].id, master.tags[pos].length);
352             if(getidfromtag(&master.tags[pos]) == spriteid && !config.isframe)
353             {
354                 if(config.overlay)
355                 {
356                     *(u16*)master.tags[pos].data = SWAP16(replaceddefine);
357                     writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
358                 } else {
359                     /* don't write this tag */
360                     logf("<verbose> replacing tag %d id %d with sprite", master.tags[pos].id
361                             ,spriteid);
362                 }
363
364                 if(flags&FLAGS_WRITESPRITE)
365                 {
366                     write_sprite_defines(w);
367                     write_sprite(w, spriteid, replaceddefine);
368                 }
369                 if(flags&FLAGS_WRITESLAVE)
370                 {
371                     outputslave = 1;
372                 }
373             } else { 
374                 writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
375             }
376         }
377         if(frame == slaveframe)
378         {
379             if(flags&FLAGS_WRITESLAVE) {
380                 outputslave = 1;
381                 slavewritten = 1;
382             }
383             if((flags&FLAGS_WRITESPRITE) && !slavewritten)
384             {
385                 int id = get_free_id();
386                 int depth = 0;
387                 char data[7];
388                 if(config.clip) {
389                     logf("<fatal> Can't combine --clip and --frame");
390                 }
391                 *(u16*)&data[0] = SWAP16((u16)(TAGID_PLACEOBJECT2<<6) + 5);
392                 *(u8*)&data[2]= SWAP16(2); //flags: id
393                 *(u16*)&data[3]= SWAP16(depth); // depth
394                 *(u16*)&data[5]= SWAP16(id);
395                 write_sprite_defines(w);
396                 write_sprite(w, id, -1);
397                 writer_write(w,data,7);
398                 slavewritten = 1;
399             }
400         }
401         if(!is_defining_tag(master.tags[pos].id) && (flags&FLAGS_WRITENONDEFINES))
402         {
403             int dontwrite = 0;
404             switch(master.tags[pos].id) {
405                 case TAGID_PLACEOBJECT:
406                 case TAGID_PLACEOBJECT2:
407                     if(frame == slaveframe && !config.overlay)
408                         dontwrite = 1;
409                 case TAGID_REMOVEOBJECT:
410 //              case TAGID_REMOVEOBJECT2:
411                     /* place/removetags for the object we replaced
412                        should be discarded, too, as the object to insert 
413                        isn't a sprite 
414                      */
415                     if(spriteid>=0 && getidfromtag(&master.tags[pos]) == spriteid && 
416                             !config.isframe && config.merge)
417                         dontwrite = 1;
418                 break;
419             }
420             if(!dontwrite) {
421                 logf("<debug> [master] write tag %02x (%d bytes in body)", 
422                         master.tags[pos].id, master.tags[pos].length);
423                 writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
424             }
425         }
426         pos++;
427     }
428    
429     if(outputslave) 
430     while(slave.tags[spos].id)
431     {
432             if(tag_ok_for_slave(slave.tags[spos].id))
433                 writer_write(w, slave.tags[spos].fulldata, slave.tags[spos].fulllength);
434             spos++;
435     }
436     if(!slavewritten && config.isframe && (flags&(FLAGS_WRITESLAVE|FLAGS_WRITESPRITE)))
437     {
438         logf("<warning> Frame %d doesn't exist in file. No substitution will occur",
439                 slaveframe);
440     }
441     //write END tag: 
442     writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
443 }
444
445 void writeheader(struct writer_t*w, u8*data, int length)
446 {
447     if(config.hassizex || config.hassizey || config.framerate)
448     {
449         struct flash_header head;
450         struct reader_t reader;
451         swf_init(&reader, data-3, length+3);
452         head = swf_read_header(&reader);
453         if(config.hassizex)
454         {
455             head.boundingBox.x2 = head.boundingBox.x1 + config.sizex;
456         }
457         if(config.hassizey)
458         {
459             head.boundingBox.y2 = head.boundingBox.y1 + config.sizey;
460         }
461         if(config.framerate)
462         {
463             head.rate = config.framerate;
464         }
465         swf_write_header(w, &head);
466     }
467     else
468     writer_write(w, data, length);
469 }
470
471 uchar * catcombine(uchar*masterdata, int masterlength, char*_slavename, uchar*slavedata, int slavelength, int*newlength)
472 {
473         struct writer_t w;
474         u32*headlength;
475         u32 tmp32;
476         int length = masterlength*2 + slavelength;
477         int pos = 0;
478         int t;
479         char* depths;
480         uchar*newdata = malloc(length);
481         if(!newdata) {
482             logf("<fatal> Couldn't allocate %d bytes of memory", length);
483             return 0;
484         }
485         if(config.isframe) {
486             logf("<fatal> Can't combine --cat and --frame");
487             exit(1);
488         }
489         writer_init(&w, newdata, length);
490         
491         do {
492             int tag = master.tags[pos].id;
493             if(is_defining_tag(tag)) {
494                 int defineid = getidfromtag(&master.tags[pos]);
495                 logf("<debug> tagid %02x defines object %d", tag, defineid);
496                 masterids[defineid] = 1;
497             }
498         }
499         while(master.tags[pos++].id != 0);
500         
501         swf_relocate (slavedata, slavelength, masterids);
502         read_swf(&slave, slavedata, slavelength);
503         jpeg_assert();
504         
505         writer_write(&w, "FWS",3);
506         headlength = (u32*)(writer_getpos(&w) + 1);
507         writeheader(&w, master.header.headerdata, master.header.headerlength);
508
509         depths = malloc(65536);
510         if(!depths) {
511             logf("<fatal> Couldn't allocate %d bytes of memory", 65536);
512             return 0;
513         }
514         memset(depths, 0, 65536);
515         pos = 0;
516         do {
517             int num=1;
518             u16 depth;
519             logf("<debug> [master] write tag %02x (%d bytes in body)", 
520                     master.tags[pos].id, master.tags[pos].length);
521             switch(master.tags[pos].id) {
522                 case TAGID_PLACEOBJECT2:
523                     num++;
524                 case TAGID_PLACEOBJECT: {
525                    struct reader_t r;
526                    reader_init (&r, master.tags[pos].data, master.tags[pos].length);
527                    if(num>=2)
528                         reader_readu8(&r);
529                    depth = reader_readu16(&r);
530                    depths[depth] = 1;
531                 }
532                 break;
533                 case TAGID_REMOVEOBJECT: {
534                    struct reader_t r;
535                    reader_init (&r, master.tags[pos].data, master.tags[pos].length);
536                    reader_readu16(&r);
537                    depths[reader_readu16(&r)] = 0;
538                 }
539                 break;
540                 case TAGID_REMOVEOBJECT2: {
541                    struct reader_t r;
542                    reader_init (&r, master.tags[pos].data, master.tags[pos].length);
543                    depths[reader_readu16(&r)] = 0;
544                 }
545                 break;
546             }
547             if(master.tags[pos].id != 0)
548                 writer_write(&w, master.tags[pos].fulldata, master.tags[pos].fulllength);
549         }
550         while(master.tags[pos++].id != 0);
551
552         for(t=0;t<65536;t++) 
553         if(depths[t])
554         {
555             char data[16];
556             int len;
557             *(u16*)(&data[0]) = SWAP16((TAGID_REMOVEOBJECT2<<6) + 2);
558             *(u16*)(&data[2]) = SWAP16(t);
559             writer_write(&w, data, 4);
560         }
561         free(depths);
562
563         pos = 0;
564         do {
565             logf("<debug> [slave] write tag %02x (%d bytes in body)", 
566                     slave.tags[pos].id, slave.tags[pos].length);
567             writer_write(&w, slave.tags[pos].fulldata, slave.tags[pos].fulllength);
568         }
569         while(slave.tags[pos++].id != 0);
570
571         tmp32 = (u8*)writer_getpos(&w) - (u8*)newdata; //length
572         *newlength = tmp32;
573         *headlength = SWAP32(tmp32); // set the header to the correct length
574
575         return newdata; //length
576 }
577
578 uchar * normalcombine(uchar*masterdata, int masterlength, char*_slavename, uchar*slavedata, int slavelength, int*newlength)
579 {
580         int length;
581         int pos=0;
582         u32 tmp32;
583         u32*headlength;
584         uchar*newdata;
585         int spriteid = -1;
586         int replaceddefine = -1;
587         struct writer_t w;
588         int frame;
589         char*framelabel;
590         
591         length = masterlength + slavelength*2 + 128; // this is a guess, but a good guess.
592         newdata = malloc(length);
593         writer_init(&w, newdata, length);
594
595         if(!newdata) {
596             logf("<fatal> Couldn't allocate %d bytes of memory", length);
597             return 0;
598         }
599
600         // set the idtab
601         pos = 0;
602         do {
603             int tag = master.tags[pos].id;
604             if(is_defining_tag(tag)) {
605                 int defineid = getidfromtag(&master.tags[pos]);
606                 logf("<debug> tagid %02x defines object %d", tag, defineid);
607                 masterids[defineid] = 1;
608             } else if(tag == TAGID_PLACEOBJECT2) {
609                 char * name = tag_placeobject2_name(&master.tags[pos]);
610                 int id = tag_placeobject2_character(&master.tags[pos]);
611
612                 if(name)
613                   logf("<verbose> tagid %02x places object %d named \"%s\"", tag, id, name);
614                 else
615                   logf("<verbose> tagid %02x places object %d (no name)", tag, id);
616
617                 if ((name && slavename && !strcmp(name,slavename)) || 
618                     (!slavename && id==slaveid)) {
619                     if(id>=0) {
620                       spriteid = id;
621                       logf("<notice> Slave file attached to object %d.", id);
622                     }
623                 }
624             } else if(tag == TAGID_SHOWFRAME) {
625                 if(slaveframe>=0 && frame==slaveframe) {
626                     logf("<notice> Slave file attached to frame %d.", frame);
627                 }
628                 frame++;
629             } else if(tag == TAGID_FRAMELABEL) {
630                 char * name = master.tags[pos].data;
631                 if(name && slavename && config.isframe && !strcmp(name, slavename)) {
632                     slaveframe = frame;
633                     logf("<notice> Slave file attached to frame %d (%s).", frame, name);
634                 }
635             }
636         }
637         while(master.tags[pos++].id != 0);
638
639         if (spriteid<0 && !config.isframe) {
640             if(slavename) {
641                 if(strcmp(slavename,"!!dummy!!"))
642                     logf("<warning> Didn't find anything named %s in file. No substitutions will occur.", slavename);
643             }
644             else
645                 logf("<warning> Didn't find id %d in file. No substitutions will occur.", slaveid);
646             spriteid = get_free_id();
647         }
648
649         swf_relocate (slavedata, slavelength, masterids);
650         read_swf(&slave, slavedata, slavelength);
651         jpeg_assert();
652         
653         if (config.overlay)
654             replaceddefine = get_free_id();
655         
656         // write file 
657
658         writer_write(&w, "FWS",3);
659         headlength = (u32*)(writer_getpos(&w) + 1);
660         writeheader(&w, master.header.headerdata, master.header.headerlength);
661
662         if (config.antistream) {
663             if (config.merge) {
664                 logf("<fatal> Can't combine --antistream and --merge");
665             }
666             write_sprite_defines(&w);
667             write_sprite(&w, spriteid, replaceddefine);
668             write_master(&w, spriteid, replaceddefine, FLAGS_WRITEDEFINES);
669             write_master(&w, spriteid, replaceddefine, FLAGS_WRITENONDEFINES);
670         } else {
671             if (config.merge)
672                 write_master(&w, spriteid, replaceddefine, 
673                     FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESLAVE);
674             else
675                 write_master(&w, spriteid, replaceddefine, 
676                     FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESPRITE);
677         }
678
679         tmp32 = (u8*)writer_getpos(&w) - (u8*)newdata; //length
680         *newlength = tmp32;
681         *headlength = SWAP32(tmp32); // set the header to the correct length
682
683         return newdata; //length
684 }
685
686 uchar * combine(uchar*masterdata, int masterlength, char*_slavename, uchar*slavedata, int slavelength, int*newlength)
687 {
688     char master_flash = 0;
689     char slave_flash = 0;
690     slavename = _slavename;
691
692     slaveid = -1;
693     slaveframe = -1;
694
695     if(slavename[0] == '#')
696     {
697         slaveid = atoi(&slavename[1]);
698         slavename = 0;
699     }
700     if(config.isframe)
701     {
702         slaveframe = slaveid;
703         slaveid = -1;
704     }
705
706     logf("<debug> move x (%d)", config.movex);
707     logf("<debug> move y (%d)", config.movey);
708     logf("<debug> scale x (%d)", config.scalex);
709     logf("<debug> scale y (%d)", config.scaley);
710     logf("<debug> is frame (%d)", config.isframe);
711     
712     memset(masterids, -1, sizeof(masterids));
713
714     if(masterlength < 3)
715     {
716         logf("<fatal> the master file is too small (%d bytes)", masterlength);
717         return 0;
718     }
719     if(slavelength < 3)
720     {
721         logf("<fatal> the slave file is too small (%d bytes)", slavelength);
722         return 0;
723     }
724     if(masterdata[2] == 'S' &&
725        masterdata[1] == 'W' &&
726        masterdata[0] == 'F')
727     {
728         logf("<notice> the master file is flash (swf) format\n");
729         master_flash = 1;
730     }
731     else
732         logf("<notice> the master file is not flash (swf) format!\n");
733
734     if(slavedata[2] == 'S' &&
735        slavedata[1] == 'W' &&
736        slavedata[0] == 'F')
737     {
738         logf("<notice> the slave file is flash (swf) format\n");
739         slave_flash = 1;
740     }
741     else
742         logf("<notice> the slave file is not flash (swf) format!\n");
743
744     if(master_flash && slave_flash) {
745         read_swf(&master, masterdata, masterlength);
746         if(config.cat) 
747             return catcombine(masterdata, masterlength, _slavename, slavedata, slavelength, newlength);
748         else
749             return normalcombine(masterdata, masterlength, _slavename, slavedata, slavelength, newlength);
750     }
751     
752     *newlength = 0;
753     return 0;
754 }