removed the priority stuff, sorted by tools
[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 "./flash.h"
16 #include "./reloc.h"
17 #include "./settings.h"
18
19 // TODO:
20 // * readers should be object-oriented
21
22 static char* slavename;
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     if(tag->id == TAGID_PLACEOBJECT)
60         (*(u16*)&tag->data[2]) += add;
61     if(tag->id == TAGID_PLACEOBJECT2)
62         (*(u16*)&tag->data[1]) += add;
63     if(tag->id == TAGID_REMOVEOBJECT)
64         (*(u16*)&tag->data[2]) += add;
65     if(tag->id == TAGID_REMOVEOBJECT2)
66         (*(u16*)&tag->data[0]) += add;
67 }
68
69 /* applies the config move and scale parameters to
70  * a matrix. (If settings would provide a rotation,
71  * this would be a matrix concatenation/multiplication
72  * routine. In this case, it's just element-wise multiplication.
73  */
74 void matrix_adjust(struct MATRIX*m)
75 {
76     if(config.scalex != 1 || config.scaley != 1)
77     {
78         if(!m->hasscale) {
79             m->hasscale = 1;
80             m->a[0][0] = config.scalex;
81             m->a[1][1] = config.scaley;
82         } else {
83             m->a[0][0] *= config.scalex;
84             m->a[1][1] *= config.scaley;
85         }
86         if(m->hasrotate) {
87             m->a[0][1] *= config.scalex;
88             m->a[1][0] *= config.scaley;
89         }
90         m->b[0] *= config.scalex;
91         m->b[1] *= config.scaley;
92     }
93 /*    printf("hasscale: %d\n",m->hasscale);
94     printf("hasrotate: %d\n", m->hasrotate);
95     printf("move: %d %d\n", m->b[0],m->b[1]);
96     printf("rot: %f %f\n",m->a[0][0],m->a[0][1]);
97     printf("     %f %f\n",m->a[1][0],m->a[1][1]);*/
98     m->b[0] += config.movex;
99     m->b[1] += config.movey;
100 }
101
102 void write_changepos(struct swf_tag*tag, struct writer_t*w)
103 {
104     if(config.movex || config.movey || config.scalex != 1 || config.scaley != 1)
105     {
106         switch(tag->id)
107         {
108             case TAGID_PLACEOBJECT: {
109                 struct PlaceObject p;
110                 placeobject_init(&p, tag);
111                 matrix_adjust(&p.matrix);
112                 placeobject_write(&p, w);
113                 break;
114             }
115             case TAGID_PLACEOBJECT2: {
116                 struct PlaceObject2 p;
117                 placeobject2_init(&p, tag);
118                 if(!p.hasmatrix) {
119                     p.hasmatrix = 1;
120                     MATRIX_init(&p.matrix);
121                 }
122                 matrix_adjust(&p.matrix);
123                 placeobject2_write(&p, w);
124                 break;
125             }
126             default:
127             writer_write(w, tag->fulldata, tag->fulllength);
128         }
129     } 
130     else 
131     {
132             writer_write(w, tag->fulldata, tag->fulllength);
133     }
134 }
135
136 void write_sprite_defines(struct writer_t*w)
137 {
138     int pos = 0;
139     while(slave.tags[pos].id != 0) {
140         struct swf_tag * tag = &slave.tags[pos];
141         if(!is_sprite_tag(tag->id)) {
142             logf("<debug> processing sprite tag %02x", slave.tags[pos].id);
143             if(is_defining_tag(tag->id))
144             {
145                 logf("<debug> [sprite defs] write tag %02x (%d bytes in body)", 
146                         tag->id, tag->length);
147                 writer_write(w, tag->fulldata, tag->fulllength);
148             }
149             else
150             {
151                 switch(tag->id)
152                 {case TAGID_DEFINEFONTINFO:
153                     {
154                         /* define font info is not a defining tag, in that
155                          * it doesn't define a new id, but rather extends
156                          * an existing one. It also isn't a sprite tag. 
157                          * Anyway we can't throw it out, so we just pass it
158                          * through.
159                          */
160                         break;
161                     }
162                  case TAGID_EXPORTASSETS:
163                     logf("<debug> deliberately ignoring EXPORTASSETS tag");
164                     break;
165                  case TAGID_ENABLEDEBUGGER:
166                     logf("<debug> deliberately ignoring ENABLEDEBUGGER tag");
167                     break;
168                  case TAGID_BACKGROUNDCOLOR:
169                     logf("<debug> deliberately ignoring BACKGROUNDCOLOR tag");
170                     break;
171                  case 40:
172                  case 49:
173                  case 51:
174                     logf("<notice> found tag %d. This is a Generator template, isn't it?", slave.tags[pos].id);
175                     break;
176                  default:
177                     logf("<notice> funny tag: %d is neither defining nor sprite", slave.tags[pos].id);
178                 }
179             }
180         }
181         pos++;
182     }
183 }
184
185
186 void write_sprite(struct writer_t*w, int spriteid, int replaceddefine)
187 {
188     u16 tmp;
189     u32 tmp32;
190     u32*tagidpos;
191     u8*startpos;
192     int pos = 0;
193     // write slave(2) (header)
194     tmp = 0x3f + (TAGID_DEFINESPRITE << 6);
195     writer_write(w, &tmp, 2);
196     tagidpos = (u32*)writer_getpos(w);
197     writer_write(w, &tmp32, 4);
198     
199     startpos = (u8*)writer_getpos(w);
200
201     if (spriteid<0)
202     {
203         logf("<warning> Didn't find anything named %s in file. No substitutions will occur.", slavename);
204         spriteid = get_free_id();
205     }
206
207     logf ("<notice> sprite id is %d", spriteid);
208     tmp = spriteid;
209     writer_write(w, &tmp, 2);
210     tmp = slave.header.count;
211     writer_write(w, &tmp, 2);
212
213
214     // write slave(2) (body)
215     tmp = slave.header.count;
216     logf("<debug> %d frames to go",tmp);
217
218     if(config.clip) {
219         tmp = 7 + (TAGID_PLACEOBJECT2 << 6);
220         writer_write(w, &tmp, 2);
221         tmp = 2+64; //flags: character + clipaction
222         writer_write(w, &tmp, 1);
223         tmp = 0; //depth
224         writer_write(w, &tmp,2);
225         tmp = replaceddefine; //id
226         writer_write(w, &tmp,2);
227         tmp = 65535; //clipdepth
228         writer_write(w, &tmp,2);
229     }
230
231     if(config.overlay) {
232         tmp = 5 + (TAGID_PLACEOBJECT2 << 6);
233         writer_write(w, &tmp, 2);
234         tmp = 2; //flags: character
235         writer_write(w, &tmp, 1);
236         tmp = 0; //depth
237         writer_write(w, &tmp,2);
238         tmp = replaceddefine; //id
239         writer_write(w, &tmp,2);
240     }
241
242     do {
243         struct swf_tag * tag = &slave.tags[pos];
244         if (is_sprite_tag(tag->id)) {
245
246             changedepth(tag, +1);
247             logf("<debug> [sprite main] write tag %02x (%d bytes in body)", 
248                     slave.tags[pos].id, slave.tags[pos].length);
249             write_changepos(tag, w);
250
251             if(tag->id == TAGID_SHOWFRAME)
252             {
253                 tmp--;
254                 logf("<debug> %d frames to go",tmp);
255             }
256         }
257     }
258     while(slave.tags[pos++].id != TAGID_END);
259
260     *tagidpos = (u8*)writer_getpos(w) - startpos; // set length of sprite (in header)
261     logf("<verbose> sprite length is %d",*tagidpos);
262 }
263
264 #define FLAGS_WRITEDEFINES 1
265 #define FLAGS_WRITENONDEFINES 2
266 #define FLAGS_WRITESPRITE 4
267 void write_master(struct writer_t*w, int spriteid, int replaceddefine, int flags)
268 {
269     int pos = 0;
270     do {
271         if(is_defining_tag(master.tags[pos].id) && (flags&1))
272         {
273             logf("<debug> [master] write tag %02x (%d bytes in body)", 
274                     master.tags[pos].id, master.tags[pos].length);
275             if( getidfromtag(&master.tags[pos]) == spriteid) 
276             {
277                 if(config.overlay)
278                 {
279                     *(u16*)master.tags[pos].data = replaceddefine;
280                     writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
281                 } else {
282                     /* don't write this tag */
283                     logf("<verbose> replacing tag %d id %d with sprite", master.tags[pos].id
284                             ,spriteid);
285                 }
286
287                 if(flags&4)
288                 {
289                     write_sprite_defines(w);
290                     write_sprite(w, spriteid, replaceddefine);
291                 }
292             } else { 
293                 writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
294             }
295         }
296         if(!is_defining_tag(master.tags[pos].id) && (flags&2))
297         {
298             logf("<debug> [master] write tag %02x (%d bytes in body)", 
299                     master.tags[pos].id, master.tags[pos].length);
300             writer_write(w, master.tags[pos].fulldata, master.tags[pos].fulllength);
301         }
302     }
303     while(master.tags[pos++].id != 0);
304 }
305
306
307 uchar * combine(uchar*masterdata, int masterlength, char*_slavename, uchar*slavedata, int slavelength, int*newlength)
308 {
309     char master_flash = 0;
310     char slave_flash = 0;
311     slavename = _slavename;
312
313     logf("<debug> move x (%d)", config.movex);
314     logf("<debug> move y (%d)", config.movey);
315     logf("<debug> scale x (%d)", config.scalex);
316     logf("<debug> scale y (%d)", config.scaley);
317     
318     memset(masterids, -1, sizeof(masterids));
319
320     if(masterlength < 3)
321     {
322         logf("<fatal> the master file is too small (%d bytes)", masterlength);
323         return 0;
324     }
325     if(slavelength < 3)
326     {
327         logf("<fatal> the slave file is too small (%d bytes)", slavelength);
328         return 0;
329     }
330     if(masterdata[2] == 'S' &&
331        masterdata[1] == 'W' &&
332        masterdata[0] == 'F')
333     {
334         logf("<notice> the master file is flash (swf) format\n");
335         master_flash = 1;
336     }
337     if(slavedata[2] == 'S' &&
338        slavedata[1] == 'W' &&
339        slavedata[0] == 'F')
340     {
341         logf("<notice> the slave file is flash (swf) format\n");
342         slave_flash = 1;
343     }
344
345     if(master_flash && slave_flash)
346     {
347         int length;
348         int pos=0;
349         u32 tmp32;
350         u32*headlength;
351         uchar*newdata;
352         int spriteid = -1;
353         int replaceddefine = -1;
354         struct writer_t w;
355         
356         read_swf(&master, masterdata, masterlength);
357
358         length = masterlength + slavelength*2 + 128; // this is a guess, but a good guess.
359         newdata = malloc(length);
360         writer_init(&w, newdata, length);
361
362         if(!newdata) {
363             logf("<fatal> Couldn't allocate %d bytes of memory", length);
364             return 0;
365         }
366
367         // set the idtab
368         pos = 0;
369         do {
370             int tag = master.tags[pos].id;
371             if(is_defining_tag(tag)) {
372                 int defineid = getidfromtag(&master.tags[pos]);
373                 logf("<debug> tagid %02x defines object %d", tag, defineid);
374                 masterids[defineid] = 1;
375             } else if(tag == TAGID_PLACEOBJECT2) {
376                 char * name = tag_placeobject2_name(&master.tags[pos]);
377                 int id = tag_placeobject2_character(&master.tags[pos]);
378
379                 if(name)
380                   logf("<verbose> tagid %02x places object %d named \"%s\"", tag, id, name);
381                 else
382                   logf("<verbose> tagid %02x places object %d (no name)", tag, id);
383
384                 if (name && !strcmp(name,slavename)) {
385                     if(id>=0) {
386                       spriteid = id;
387                       logf("<notice> Slave file attached to object %d.", id);
388                     }
389                 }
390             }
391         }
392         while(master.tags[pos++].id != 0);
393
394         swf_relocate (slavedata, slavelength, masterids);
395
396         read_swf(&slave, slavedata, slavelength);
397         
398         if(config.overlay)
399             replaceddefine = get_free_id();
400         
401         // write file 
402
403         writer_write(&w, "FWS",3);
404         headlength = (u32*)(writer_getpos(&w) + 1);
405         writer_write(&w, master.header.headerdata, master.header.headerlength);
406
407         if(config.antistream) {
408             write_sprite_defines(&w);
409             write_sprite(&w, spriteid, replaceddefine);
410             write_master(&w, spriteid, replaceddefine, FLAGS_WRITEDEFINES);
411             write_master(&w, spriteid, replaceddefine, FLAGS_WRITENONDEFINES);
412         } else {
413             write_master(&w, spriteid, replaceddefine, 
414                     FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESPRITE);
415         }
416
417         tmp32 = (u8*)writer_getpos(&w) - (u8*)newdata; //length
418         *newlength = tmp32;
419         *headlength = tmp32; // set the header to the correct length
420
421         return newdata; //length
422     }
423     
424     *newlength = 0;
425     return 0;
426 }