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