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 "combine.h"
  18 #include "settings.h"
  19 #include "types.h"
  20 #include "flash.h"
  21 #include "reloc.h"
  22 #include "../config.h"
  23
  24 char * master_filename = 0;
  25 char * master_name = 0;
  26 char * slave_filename[128];
  27 char * slave_name[128];
  28 int slave_movex[128];
  29 int slave_movey[128];
  30 float slave_scalex[128];
  31 float slave_scaley[128];
  32 char slave_isframe[128];
  33 int numslaves = 0;
  34
  35 char * outputname = "output.swf";
  36
  37 int args_callback_option(char*name,char*val) {
  38     if(!strcmp(name,"c"))
  39     {
  40         config.clip = 1;
  41         return 0;
  42     }
  43     else if(!strcmp(name,"l"))
  44     {
  45         config.overlay = 1;
  46         return 0;
  47     }
  48     else if (!strcmp(name, "o"))
  49     {
  50         outputname = val;
  51         return 1;
  52     }
  53     else if (!strcmp(name, "v"))
  54     {
  55         config.loglevel ++;
  56         return 0;
  57     }
  58     else if (!strcmp(name, "a"))
  59     {
  60         config.cat = 1;
  61         return 0;
  62     }
  63     else if (!strcmp(name, "A"))
  64     {
  65         config.alloctest = 1;
  66         return 0;
  67     }
  68     else if (!strcmp(name, "x"))
  69     {
  70         config.movex = atoi(val);
  71         return 1;
  72     }
  73     else if (!strcmp(name, "y"))
  74     {
  75         config.movey = atoi(val);
  76         return 1;
  77     }
  78     else if (!strcmp(name, "m"))
  79     {
  80         config.merge = 1;
  81         return 0;
  82     }
  83     else if (!strcmp(name, "f"))
  84     {
  85         config.isframe = 1;
  86         return 0;
  87     }
  88     else if (!strcmp(name, "d"))
  89     {
  90         config.dummy = 1;
  91         return 0;
  92     }
  93     else if (!strcmp(name, "z"))
  94     {
  95         config.zlib = 1;
  96         return 0;
  97     }
  98     else if (!strcmp(name, "r"))
  99     {
 100         config.framerate = atoi(val)*256/100;
 101         return 1;
 102     }
 103     else if (!strcmp(name, "X"))
 104     {
 105         config.sizex = atoi(val)*20;
 106         config.hassizex = 1;
 107         return 1;
 108     }
 109     else if (!strcmp(name, "Y"))
 110     {
 111         config.sizey = atoi(val)*20;
 112         config.hassizey = 1;
 113         return 1;
 114     }
 115     else if (!strcmp(name, "s"))
 116     {
 117         config.scalex = config.scaley = atoi(val)/100.0;
 118         return 1;
 119     }
 120     else if (!strcmp(name, "t") || !strcmp(name, "T"))
 121     {
 122         if(master_filename) {
 123             fprintf(stderr, "error with arguments. Try --help.\n");
 124             exit(1);
 125         }
 126         config.stack = 1;
 127         if(!strcmp(name,"T"))
 128             config.stack1 = 1;
 129         master_filename = "__none__";
 130         return 0;
 131     }
 132     else if (!strcmp(name, "V"))
 133     {
 134         printf("swfcombine - part of %s %s\n", PACKAGE, VERSION);
 135         exit(0);
 136     }
 137     else
 138     {
 139         fprintf(stderr, "Unknown option: -%s\n", name);
 140         exit(1);
 141     }
 142 }
 143
 144 struct options_t options[] =
 145 {{"o","output"},
 146  {"s","scale"},
 147  {"d","dummy"},
 148  {"x","xpos"},
 149  {"y","ypos"},
 150  {"X","width"},
 151  {"Y","height"},
 152  {"r","rate"},
 153  {"f","frame"},
 154  {"l","overlay"},
 155  {"m","merge"},
 156  {"t","stack"},
 157  {"T","stack1"},
 158  {"v","verbose"},
 159  {"V","version"},
 160  {"c","clip"},
 161  {"a","cat"},
 162  {"z","zlib"},
 163  {0,0}
 164 };
 165
 166 int args_callback_longoption(char*name,char*val) {
 167     return args_long2shortoption(options, name, val);
 168 }
 169
 170 int args_callback_command(char*name, char*val) {
 171     char*myname = strdup(name);
 172     char*filename;
 173     filename = strchr(myname, '=');
 174     if(filename) {
 175         *filename = 0;
 176         filename++;
 177     } else {
 178         // argument has no explicit name field. guess one from the file name
 179         char*path = strrchr(myname, '/');
 180         char*ext = strrchr(myname, '.');
 181         if(!path) path = myname;
 182         else path ++;
 183         if(ext) *ext = 0;
 184         myname = path;
 185         filename = name;
 186     }
 187
 188     if(!master_filename) {
 189         master_filename = filename;
 190         master_name = myname;
 191     } else {
 192         logf("<verbose> slave entity %s (named \"%s\")\n", filename, myname);
 193
 194         slave_filename[numslaves] = filename;
 195         slave_name[numslaves] = myname;
 196         slave_movex[numslaves] = config.movex;
 197         slave_movey[numslaves] = config.movey;
 198         slave_scalex[numslaves] = config.scalex;
 199         slave_scaley[numslaves] = config.scaley;
 200         slave_isframe[numslaves] = config.isframe;
 201         config.isframe = 0;
 202         config.movex = config.movey = 0;
 203         config.scalex = config.scaley = 1.0;
 204         numslaves ++;
 205     }
 206     return 0;
 207 }
 208
 209 void args_callback_usage(char*name)
 210 {
 211     printf("Usage: %s [-rXYomlcv] [-f] masterfile] [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
 212     printf("OR:    %s [-rXYomv] --stack[1] [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
 213     printf("OR:    %s [-rXYov] --cat [-xysf] [(name1|#id1)=]slavefile1 .. [-xysf] [(nameN|#idN)=]slavefileN\n", name);
 214     printf("OR:    %s [-rXYomlcv] --dummy [-xys] [file]\n", name);
 215     printf("\n");
 216     printf("-o outputfile       --output    explicitly specify output file. (otherwise, output.swf will be used\n");
 217     printf("-t                  --stack     place each slave in a seperate frame (no master movie\n");
 218     printf("-T                  --stack1    place each slave in the first frame (no master movie\n");
 219     printf("-m                  --merge     Don't store the slaves in Sprites/MovieClips\n");
 220     printf("-a                  --cat       concatenate all slave files (no master movie\n");
 221     printf("-l                  --overlay   Don't remove any master objects, only overlay new objects\n");
 222     printf("-c                  --clip      Clip the slave objects by the corresponding master objects\n");
 223     printf("-v                  --verbose   Use more than one -v for greater effect \n");
 224     printf("-d                  --dummy     Don't require slave objects \n");
 225     printf("-f                  --frame     The following identifier is a frame or framelabel, not an id or objectname\n");
 226     printf("-x xpos             --movex     x Adjust position of slave by xpos twips (1/20 pixel\n");
 227     printf("-y ypos             --movey     y Adjust position of slave by ypos twips (1/20 pixel\n");
 228     printf("-s scale            --scale     Adjust size of slave by scale%\n");
 229     printf("-r framerate        --rate      Set movie framerate (100 frames/sec\n");
 230     printf("-X width            --width     Force movie width to scale (default: use master width (not with -t\n");
 231     printf("-Y height           --height    Force movie height to scale (default: use master height (not with -t\n");
 232     printf("-z zlib             --zlib      Enable Flash 6 (MX) Zlib Compression\n");
 233 }
 234
 235 static void zlib_error(int ret, char* msg, z_stream*zs)
 236 {
 237     fprintf(stderr, "%s: zlib error (%d): last zlib error: %s\n",
 238           msg,
 239           ret,
 240           zs->msg?zs->msg:"unknown");
 241     perror("errno:");
 242     exit(1);
 243 }
 244
 245 static char* fi_depack(FILE* fi, unsigned int * setlength) {
 246     char * mem;
 247     z_stream zs;
 248     int ret;
 249     char buffer1[8192], *buffer2;
 250     int memsize = 8192;
 251     int mempos = 0;
 252     memset(&zs,0,sizeof(z_stream));
 253     zs.zalloc = Z_NULL;
 254     zs.zfree  = Z_NULL;
 255     zs.opaque = Z_NULL;
 256     buffer2 = malloc(8192);
 257
 258     ret = inflateInit(&zs);
 259     if (ret != Z_OK) zlib_error(ret, "inflate_init", &zs);
 260
 261     fread(buffer2, 8, 1, fi);
 262     buffer2[0] = 'F';
 263
 264     zs.next_out         = &buffer2[8];
 265     zs.avail_out        = 8192-8;
 266     zs.avail_in         = 0;
 267
 268     while(1)
 269     {
 270         if(!zs.avail_in) {
 271             zs.avail_in = fread(buffer1, 1, 8192, fi);
 272             zs.next_in = buffer1;
 273         }
 274         if(zs.avail_in)
 275             ret = inflate(&zs, Z_NO_FLUSH);
 276         else
 277             ret = inflate(&zs, Z_FINISH);
 278
 279         if (ret == Z_STREAM_END)
 280             break;
 281         if (ret != Z_OK) zlib_error(ret, "inflate_init", &zs);
 282
 283         if (zs.avail_out == 0)
 284         {
 285             buffer2 = realloc(buffer2, memsize + 8192);
 286             zs.avail_out = 8192;
 287             zs.next_out = &buffer2[memsize];
 288             memsize += 8192;
 289         }
 290     }
 291     *setlength = (zs.next_out - (Bytef*)buffer2);
 292     ret = inflateEnd(&zs);
 293     if(ret != Z_OK) zlib_error(ret, "inflate_init", &zs);
 294     return buffer2;
 295 }
 296
 297 /* read a whole file in memory */
 298 static char* fi_slurp(FILE*fi, unsigned int * setlength)
 299 {
 300     char * mem;
 301     long long int length; //;)
 302     long long int pos = 0;
 303     unsigned char id[3];
 304     fseek(fi,0,SEEK_END);
 305     length = ftell(fi);
 306     fseek(fi,0,SEEK_SET);
 307     if(length<3)
 308         return 0;
 309     fread(id, 3, 1, fi);
 310     fseek(fi, 0, SEEK_SET);
 311     if(!strncmp(id, "CWS", 3)) {
 312         return fi_depack(fi, setlength);
 313     }
 314
 315     mem = malloc(length);
 316     if(!mem)
 317         return 0;
 318     while(!feof(fi))
 319     {
 320         pos += fread(&mem[pos], 1, 65536, fi);
 321     }
 322     if (setlength)
 323         *setlength = length;
 324     return mem;
 325 }
 326
 327 static void fi_pack(FILE*fi, void*_mem, int length)
 328 {
 329     z_stream zs;
 330     int ret;
 331     char*mem = (char*)_mem;
 332     char buffer[8192];
 333     memset(&zs,0,sizeof(z_stream));
 334     zs.zalloc = Z_NULL;
 335     zs.zfree  = Z_NULL;
 336     zs.opaque = Z_NULL;
 337
 338     ret = deflateInit(&zs, 9);
 339     if (ret != Z_OK) zlib_error(ret, "deflate_init", &zs);
 340
 341     mem[0] = 'C';
 342     fwrite(mem, 8, 1, fi);
 343
 344     zs.avail_in         = length-8;
 345     zs.next_in          = mem+8;
 346     zs.avail_out        = 8192;
 347     zs.next_out         = buffer;
 348
 349     while(1)
 350     {
 351         if(zs.avail_in)
 352             ret = deflate(&zs, Z_NO_FLUSH);
 353         else
 354             ret = deflate(&zs, Z_FINISH);
 355
 356         if (ret == Z_STREAM_END)
 357             break;
 358
 359         if (ret != Z_OK) zlib_error(ret, "deflate_sync", &zs);
 360
 361         if (zs.avail_out == 0)
 362         {
 363             fwrite(buffer, 8192, 1, fi);
 364             zs.next_out = buffer;
 365             zs.avail_out = 8192;
 366         }
 367     }
 368     fwrite(buffer, zs.next_out - (Bytef*)buffer, 1, fi);
 369
 370     ret = deflateEnd(&zs);
 371     if (ret != Z_OK) zlib_error(ret, "deflate_end", &zs);
 372 }
 373
 374 static void fi_dump(FILE*fi, void*_mem, int length)
 375 {
 376     char*mem = (char*)_mem;
 377     int pos = 0;
 378     while(pos < length)
 379     {
 380         int size = 65536;
 381         if (size > (length - pos))
 382                 size = (length - pos);
 383         pos += fwrite(&mem[pos], 1, size, fi);
 384     }
 385 }
 386
 387 /* todo: use rfxswf */
 388 static void makestackmaster(u8**masterdata, int*masterlength)
 389 {
 390     u8 head[] = {'F','W','S'};
 391     u8 *pos;
 392     u32 * fixpos;
 393     int t;
 394     struct RECT box;
 395     int strlength = 0;
 396     int fileversion = 1;
 397
 398     /* scan all slaves for bounding box */
 399     for(t=0;t<numslaves;t++)
 400     {
 401         FILE*fi=fopen(slave_filename[t],"rb");
 402         u8 data[256];
 403         int ret;
 404         struct flash_header head;
 405         struct reader_t r;
 406         strlength += strlen(slave_name[t]) + 9;
 407         if(!fi) {
 408             logf("<fatal> Couldn't open %s.", slave_filename[t]);
 409             exit(1);
 410         }
 411         ret = fread(data,1,256,fi);
 412         if(ret < 13) {
 413             logf("<fatal> File %s is to small (%d bytes)", slave_filename[t], ret);
 414             exit(1);
 415         }
 416         swf_init(&r, data,256);
 417         head = swf_read_header(&r);
 418         logf("<verbose> File %s has bounding box %d:%d:%d:%d\n",
 419                 slave_filename[t],
 420                 head.boundingBox.x1, head.boundingBox.y1,
 421                 head.boundingBox.x2, head.boundingBox.y2);
 422         if(head.version > fileversion)
 423             fileversion = head.version;
 424         if(!t)
 425             box = head.boundingBox;
 426         else {
 427             if(head.boundingBox.x1 < box.x1)
 428                 box.x1 = head.boundingBox.x1;
 429             if(head.boundingBox.y1 < box.y1)
 430                 box.y1 = head.boundingBox.y1;
 431             if(head.boundingBox.x2 > box.x2)
 432                 box.x2 = head.boundingBox.x2;
 433             if(head.boundingBox.y2 > box.y2)
 434                 box.y2 = head.boundingBox.y2;
 435         }
 436         logf("<verbose> New master bounding box is %d:%d:%d:%d\n",
 437                 box.x1, box.y1,
 438                 box.x2, box.y2);
 439         fclose(fi);
 440     }
 441
 442     /* we don't have a master, so we create one ourselves. */
 443     *masterlength = (numslaves + 1) * 32 + strlength;
 444     *masterdata = (u8*)malloc(*masterlength);
 445     pos = *masterdata;
 446     memcpy(pos, head, sizeof(head));
 447     pos += sizeof(head);
 448     *pos++ = fileversion;
 449     fixpos = (u32*)pos;
 450     PUT32(pos, 0x12345678); // to be overwritten
 451     pos += 4;
 452     writeRECT(&pos, &box);
 453     PUT16(pos, 0x2000) // framerate
 454     pos += 2;
 455     PUT16(pos, numslaves) // framerate
 456     pos += 2;
 457     for(t=0;t<numslaves;t++)
 458     {
 459         char buf[128];
 460         int namelen;
 461
 462         if(1) {
 463             sprintf(buf, "Frame%02d", t);
 464             slave_name[t] = strdup(buf);
 465         }
 466         namelen = strlen(slave_name[t]);
 467
 468         PUT16(&pos[0] , ((u16)(TAGID_DEFINESPRITE<<6) + 6));
 469         PUT16(&pos[2] , (t+1)); //ID
 470         PUT16(&pos[4] , 0); // Frames
 471         PUT16(&pos[6] , 0); // TAG1
 472         PUT16(&pos[8] , ((u16)(TAGID_PLACEOBJECT2<<6) + 6 + namelen));
 473         PUT16(&pos[10], (34)); //flags: id+name
 474         PUT16(&pos[11], (1+t)); // depth
 475         PUT16(&pos[13], (t+1)); // id
 476         sprintf(&pos[15],slave_name[t]);
 477         pos += 15 + namelen + 1;
 478         if(!config.stack1 || t == numslaves-1) {
 479             PUT16(&pos[0],((u16)(TAGID_SHOWFRAME<<6) + 0));
 480             pos += 2;
 481         }
 482         if(!config.stack)
 483         if(t!=numslaves-1)
 484         {
 485             PUT16(&pos[0], ((u16)(TAGID_REMOVEOBJECT2<<6) + 2));
 486             PUT16(&pos[2], (1+t)); // depth;
 487             pos += 4;
 488         }
 489     }
 490     PUT16(pos, ((TAGID_END<<6) + 0));
 491     *masterlength = pos - *masterdata;
 492     PUT32(fixpos, *masterlength);
 493 }
 494
 495 struct config_t config;
 496 int main(int argn, char *argv[])
 497 {
 498     FILE*fi;
 499     u8*masterdata;
 500     unsigned int masterlength;
 501     u8*slavedata;
 502     unsigned int slavelength;
 503     u8*newdata;
 504     unsigned int newlength;
 505     int t;
 506
 507     config.overlay = 0;
 508     config.antistream = 0;
 509     config.alloctest = 0;
 510     config.cat = 0;
 511     config.merge = 0;
 512     config.clip = 0;
 513     config.loglevel = 2;
 514     config.movex = 0;
 515     config.movey = 0;
 516     config.scalex = 1.0;
 517     config.scaley = 1.0;
 518     config.sizex = 0;
 519     config.sizey = 0;
 520     config.hassizex = 0;
 521     config.hassizey = 0;
 522     config.framerate = 0;
 523     config.stack = 0;
 524     config.stack1 = 0;
 525     config.dummy = 0;
 526     config.zlib = 0;
 527
 528     processargs(argn, argv);
 529     initLog(0,-1,0,0,-1,config.loglevel);
 530
 531     if(config.merge && config.cat) {
 532         logf("<error> Can't combine --cat and --merge");
 533         exit(1);
 534     }
 535
 536     if(config.stack) {
 537
 538         if(config.overlay) {
 539             logf("<error> Can't combine -l and -t");
 540             exit(1);
 541         }
 542         if(config.clip) {
 543             logf("<error> Can't combine -c and -t");
 544             exit(1);
 545         }
 546         logf("<verbose> (stacking) %d files found\n", numslaves);
 547
 548         makestackmaster(&masterdata,&masterlength);
 549
 550         logf("<verbose> Generated %d bytes of master data", masterlength);
 551     }
 552     else {
 553         logf("<verbose> master entity %s (named \"%s\")\n", master_filename, master_name);
 554         fi = fopen(master_filename, "rb");
 555         if(!fi) {
 556             logf("<fatal> Failed to open %s\n", master_filename);
 557             exit(1);
 558         }
 559         masterdata = fi_slurp(fi, &masterlength);
 560         if(!masterdata) {
 561             logf("<fatal> Failed to read from %s\n", master_filename);
 562             exit(1);
 563         }
 564         logf("<debug> Read %d bytes from masterfile\n", masterlength);
 565         fclose(fi);
 566     }
 567
 568     for(t=0;t<numslaves;t++) {
 569             logf("<verbose> slave entity(%d) %s (%s \"%s\")\n", t+1, slave_filename[t],
 570                     slave_isframe[t]?"frame":"object", slave_name[t]);
 571     }
 572
 573     if(config.dummy)
 574     {
 575         if(numslaves)
 576         {
 577             logf("<error> --dummy (-d) implies there are zero slave objects. You supplied %d.", numslaves);
 578             exit(1);
 579         }
 580         numslaves = 1;
 581         slave_filename[0] = "!!dummy!!";
 582         slave_name[0] = "!!dummy!!";
 583         slave_isframe[0] = 0;
 584     }
 585
 586     if (config.alloctest)
 587     {
 588         int*bitmap = malloc(sizeof(int)*65536);
 589         memset(bitmap, -1, 65536*sizeof(int));
 590         memset(bitmap, 1, 101*sizeof(int));
 591         swf_relocate(masterdata, masterlength, bitmap);
 592         newdata = masterdata;
 593         newlength = masterlength;
 594         free(bitmap);
 595     }
 596     else
 597     {
 598         if (!numslaves)
 599         {
 600             logf("<error> You must have at least one slave entity.");
 601             return 0;
 602         }
 603         for(t = 0; t < numslaves; t++)
 604         {
 605             config.movex = slave_movex[t];
 606             config.movey = slave_movey[t];
 607             config.scalex = slave_scalex[t];
 608             config.scaley = slave_scaley[t];
 609             config.isframe = slave_isframe[t];
 610
 611             logf("<notice> Combine [%s]%s and [%s]%s", master_name, master_filename,
 612                     slave_name[t], slave_filename[t]);
 613             if(!config.dummy)
 614             {
 615                 fi = fopen(slave_filename[t], "rb");
 616                 if(!fi) {
 617                     logf("<fatal> Failed to open %s\n", slave_filename[t]);
 618                     exit(1);
 619                 }
 620                 slavedata = fi_slurp(fi, &slavelength);
 621                 if(!slavedata) {
 622                     logf("<fatal> Failed to read from %s\n", slave_filename[t]);
 623                     exit(1);
 624                 }
 625                 logf("<debug> Read %d bytes from slavefile\n", slavelength);
 626                 fclose(fi);
 627             }
 628             else
 629             {
 630                 slavedata = (u8*)malloc(16);
 631                 slavedata[0] = 'F';
 632                 slavedata[1] = 'W';
 633                 slavedata[2] = 'S';
 634                 slavedata[3] = 4; //version
 635                 PUT32(&slavedata[4], 14); ; // length
 636                 slavedata[8] = 0; // boundingbox
 637                 PUT16(&slavedata[9] , (0)); // rate
 638                 PUT16(&slavedata[11] , (0)); // count
 639                 PUT16(&slavedata[13] , (0)); // end tag
 640                 slavelength = 17;
 641             }
 642
 643             newdata = combine(masterdata, masterlength, slave_name[t], slavedata, slavelength, &newlength);
 644             if(!newdata) {
 645                 logf("<fatal> Aborting.");
 646                 return 1;
 647             }
 648
 649             free(masterdata);
 650             masterdata = newdata;
 651             masterlength = newlength;
 652         }
 653     }
 654
 655     logf("<debug> New File is %d bytes \n", newlength);
 656     if(newdata && newlength) {
 657         FILE*fi = fopen(outputname, "wb");
 658         if(config.zlib)
 659             fi_pack(fi, newdata, newlength);
 660         else
 661             fi_dump(fi, newdata, newlength);
 662         fclose(fi);
 663     }
 664     return 0;
 665 }
 666