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