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 }