added tool "swfextract".
[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 void writeheader(struct writer_t*w, u8*data, int length)
307 {
308     if(config.hassizex || config.hassizey || config.framerate)
309     {
310         struct flash_header head;
311         swf_init(data-3, length+3);
312         head = swf_read_header();
313         if(config.hassizex)
314         {
315             head.boundingBox.x2 = head.boundingBox.x1 + config.sizex;
316         }
317         if(config.hassizey)
318         {
319             head.boundingBox.y2 = head.boundingBox.y1 + config.sizey;
320         }
321         if(config.framerate)
322         {
323             head.rate = config.framerate;
324         }
325         swf_write_header(w, &head);
326     }
327     else
328     writer_write(w, data, length);
329 }
330
331 uchar * combine(uchar*masterdata, int masterlength, char*_slavename, uchar*slavedata, int slavelength, int*newlength)
332 {
333     char master_flash = 0;
334     char slave_flash = 0;
335     slavename = _slavename;
336
337     logf("<debug> move x (%d)", config.movex);
338     logf("<debug> move y (%d)", config.movey);
339     logf("<debug> scale x (%d)", config.scalex);
340     logf("<debug> scale y (%d)", config.scaley);
341     
342     memset(masterids, -1, sizeof(masterids));
343
344     if(masterlength < 3)
345     {
346         logf("<fatal> the master file is too small (%d bytes)", masterlength);
347         return 0;
348     }
349     if(slavelength < 3)
350     {
351         logf("<fatal> the slave file is too small (%d bytes)", slavelength);
352         return 0;
353     }
354     if(masterdata[2] == 'S' &&
355        masterdata[1] == 'W' &&
356        masterdata[0] == 'F')
357     {
358         logf("<notice> the master file is flash (swf) format\n");
359         master_flash = 1;
360     }
361     else
362         logf("<notice> the master file is not flash (swf) format!\n");
363
364     if(slavedata[2] == 'S' &&
365        slavedata[1] == 'W' &&
366        slavedata[0] == 'F')
367     {
368         logf("<notice> the slave file is flash (swf) format\n");
369         slave_flash = 1;
370     }
371     else
372         logf("<notice> the slave file is not flash (swf) format!\n");
373
374     if(master_flash && slave_flash)
375     {
376         int length;
377         int pos=0;
378         u32 tmp32;
379         u32*headlength;
380         uchar*newdata;
381         int spriteid = -1;
382         int replaceddefine = -1;
383         struct writer_t w;
384         
385         read_swf(&master, masterdata, masterlength);
386
387         length = masterlength + slavelength*2 + 128; // this is a guess, but a good guess.
388         newdata = malloc(length);
389         writer_init(&w, newdata, length);
390
391         if(!newdata) {
392             logf("<fatal> Couldn't allocate %d bytes of memory", length);
393             return 0;
394         }
395
396         // set the idtab
397         pos = 0;
398         do {
399             int tag = master.tags[pos].id;
400             if(is_defining_tag(tag)) {
401                 int defineid = getidfromtag(&master.tags[pos]);
402                 logf("<debug> tagid %02x defines object %d", tag, defineid);
403                 masterids[defineid] = 1;
404             } else if(tag == TAGID_PLACEOBJECT2) {
405                 char * name = tag_placeobject2_name(&master.tags[pos]);
406                 int id = tag_placeobject2_character(&master.tags[pos]);
407
408                 if(name)
409                   logf("<verbose> tagid %02x places object %d named \"%s\"", tag, id, name);
410                 else
411                   logf("<verbose> tagid %02x places object %d (no name)", tag, id);
412
413                 if (name && !strcmp(name,slavename)) {
414                     if(id>=0) {
415                       spriteid = id;
416                       logf("<notice> Slave file attached to object %d.", id);
417                     }
418                 }
419             }
420         }
421         while(master.tags[pos++].id != 0);
422
423         swf_relocate (slavedata, slavelength, masterids);
424
425         read_swf(&slave, slavedata, slavelength);
426         
427         if(config.overlay)
428             replaceddefine = get_free_id();
429         
430         // write file 
431
432         writer_write(&w, "FWS",3);
433         headlength = (u32*)(writer_getpos(&w) + 1);
434         writeheader(&w, master.header.headerdata, master.header.headerlength);
435
436         if(config.antistream) {
437             write_sprite_defines(&w);
438             write_sprite(&w, spriteid, replaceddefine);
439             write_master(&w, spriteid, replaceddefine, FLAGS_WRITEDEFINES);
440             write_master(&w, spriteid, replaceddefine, FLAGS_WRITENONDEFINES);
441         } else {
442             write_master(&w, spriteid, replaceddefine, 
443                     FLAGS_WRITEDEFINES|FLAGS_WRITENONDEFINES|FLAGS_WRITESPRITE);
444         }
445
446         tmp32 = (u8*)writer_getpos(&w) - (u8*)newdata; //length
447         *newlength = tmp32;
448         *headlength = tmp32; // set the header to the correct length
449
450         return newdata; //length
451     }
452     
453     *newlength = 0;
454     return 0;
455 }