src/swfbbox.c

   1 /* swfbbox.c
   2    Tool for playing around with SWF bounding boxes.
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  21
  22 #include "../config.h"
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <assert.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include "../lib/rfxswf.h"
  29 #include "../lib/args.h"
  30 #include "../lib/log.h"
  31
  32 static char * filename = 0;
  33 static char * outfilename = "output.swf";
  34 static int optimize = 0;
  35 static int swifty = 0;
  36 static int verbose = 0;
  37 static int showbbox = 0;
  38 static int showorigbbox = 1;
  39 static int expand = 0;
  40 static int clip = 0;
  41
  42 static struct options_t options[] = {
  43 {"h", "help"},
  44 {"b", "bbox"},
  45 {"B", "newbbox"},
  46 {"e", "expand"},
  47 {"O", "optimize"},
  48 {"S", "swifty"},
  49 {"c", "clip"},
  50 {"o", "output"},
  51 {"v", "verbose"},
  52 {"V", "version"},
  53 {0,0}
  54 };
  55
  56 int args_callback_option(char*name,char*val)
  57 {
  58     if(!strcmp(name, "V")) {
  59         printf("swfbbox - part of %s %s\n", PACKAGE, VERSION);
  60         exit(0);
  61     }
  62     else if(!strcmp(name, "b")) {
  63         showorigbbox = 2;
  64         if(showbbox == 1) showbbox = 0;
  65         return 0;
  66     }
  67     else if(!strcmp(name, "B")) {
  68         showbbox = 2;
  69         return 0;
  70     }
  71     else if(!strcmp(name, "O")) {
  72         optimize = 1;
  73         if(showorigbbox == 1) showorigbbox = 0;
  74         return 0;
  75     }
  76     else if(!strcmp(name, "S")) {
  77         swifty = 1;
  78         if(showorigbbox == 1) showorigbbox = 0;
  79         return 0;
  80     }
  81     else if(!strcmp(name, "c")) {
  82         if(showorigbbox == 1) showorigbbox = 0;
  83         optimize = 1;
  84         clip = 1;
  85         return 0;
  86     }
  87     else if(!strcmp(name, "v")) {
  88         verbose ++;
  89         return 0;
  90     }
  91     else if(!strcmp(name, "q")) {
  92         if(verbose)
  93             verbose --;
  94         return 0;
  95     }
  96     else if(!strcmp(name, "e")) {
  97         expand = 1;
  98         return 0;
  99     }
 100     else if(!strcmp(name, "o")) {
 101         outfilename = val;
 102         return 1;
 103     }
 104     else {
 105         printf("Unknown option: -%s\n", name);
 106         exit(1);
 107     }
 108
 109     return 0;
 110 }
 111 int args_callback_longoption(char*name,char*val)
 112 {
 113     return args_long2shortoption(options, name, val);
 114 }
 115 void args_callback_usage(char *name)
 116 {
 117     printf("\n");
 118     printf("Usage: %s [-OS] file.swf\n", name);
 119     printf("\n");
 120     printf("-h , --help                    Print help and exit\n");
 121     printf("-b , --bbox                    Show movie bounding box (default)\n");
 122     printf("-B , --newbbox                 Show recalculated (optimized/expanded) bounding box\n");
 123     printf("-e , --expand                  Write out a new file using the recalculated bounding box\n");
 124     printf("-O , --optimize                Recalculate bounding boxes\n");
 125     printf("-S , --swifty                  Print out transformed bounding boxes\n");
 126     printf("-c , --clip                    Clip bounding boxes to movie size\n");
 127     printf("-o , --output <filename>       Set output filename to <filename> (for -O)\n");
 128     printf("-v , --verbose                 Be more verbose\n");
 129     printf("-V , --version                 Print program version and exit\n");
 130     printf("\n");
 131 }
 132 int args_callback_command(char*name,char*val)
 133 {
 134     if(filename) {
 135         fprintf(stderr, "Only one file allowed. You supplied at least two. (%s and %s)\n",
 136                  filename, name);
 137     }
 138     filename = name;
 139     return 0;
 140 }
 141
 142 #define swf_ResetReadBits(tag)   if (tag->readBit)  { tag->pos++; tag->readBit = 0; }
 143
 144 void swf_Shape2Optimize(SHAPE2*shape)
 145 {
 146     if(!shape->bbox)
 147         shape->bbox = malloc(sizeof(SRECT));
 148     *(shape->bbox) = swf_GetShapeBoundingBox(shape);
 149 }
 150
 151 /*
 152    {char {x1 y1 x2 y2 x3 y3 x4 y4]]
 153 */
 154
 155 SRECT bboxes[65536];
 156 U16 depth2id[65536];
 157 char*depth2name[65536];
 158
 159 int hasid(TAG*tag)
 160 {
 161     if(tag->id == ST_PLACEOBJECT)
 162         return 1;
 163     if(tag->id == ST_PLACEOBJECT2 && (tag->data[0] & 2))
 164         return 1;
 165     if(tag->id == ST_PLACEOBJECT3 && (tag->data[0] & 2))
 166         return 1;
 167     return 0;
 168 }
 169
 170 int hasname(TAG*tag)
 171 {
 172     if(tag->id == ST_PLACEOBJECT)
 173         return 0;
 174     if(tag->id == ST_PLACEOBJECT2 && (tag->data[0] & 0x20))
 175         return 1;
 176     if(tag->id == ST_PLACEOBJECT3 && (tag->data[0] & 0x20))
 177         return 1;
 178     return 0;
 179 }
 180
 181 char* getname(TAG*tag)
 182 {
 183     if(tag->id == ST_PLACEOBJECT)
 184         return 0;
 185     if(tag->id == ST_PLACEOBJECT2 && (tag->data[0] & 0x20)) {
 186         SWFPLACEOBJECT o;
 187         tag->pos = 0;tag->readBit = 0;
 188         swf_GetPlaceObject(tag, &o);
 189         return o.name;
 190     }
 191     if(tag->id == ST_PLACEOBJECT3 && (tag->data[0] & 0x20)) {
 192         SWFPLACEOBJECT o;
 193         tag->pos = 0;tag->readBit = 0;
 194         swf_GetPlaceObject(tag, &o);
 195         return o.name;
 196     }
 197     return 0;
 198 }
 199
 200 MATRIX getmatrix(TAG*tag)
 201 {
 202     SWFPLACEOBJECT o;
 203     tag->pos = 0;tag->readBit = 0;
 204     swf_GetPlaceObject(tag, &o);
 205     return o.matrix;
 206 }
 207
 208
 209 static int fontnum = -1;
 210 static SWFFONT**fonts;
 211 static SWF*c_swf;
 212 static void fontcallback1(void*self, U16 id,U8 * name)
 213 { fontnum++;
 214 }
 215 static void fontcallback2(void*self, U16 id,U8 * name)
 216 {
 217     fonts[fontnum] = 0;
 218     swf_FontExtract(c_swf,id,&fonts[fontnum]);
 219     if(verbose) {
 220         if(fonts[fontnum]) printf("Extracting font %d (%s)\n", id, name);
 221         else               printf("Extracting font %d (%s) failed\n", id, name);
 222         fflush(stdout);
 223     }
 224     fontnum++;
 225 }
 226 typedef struct _textbounds
 227 {
 228     SRECT r;
 229     MATRIX m; // character transform matrix
 230 } textbounds_t;
 231
 232 typedef struct _placement
 233 {
 234     SWFPLACEOBJECT* po;
 235     int num;
 236 } placement_t;
 237
 238 static placement_t* placements;
 239
 240 static placement_t* readPlacements(SWF*swf)
 241 {
 242     placement_t* p = (placement_t*)rfx_calloc(sizeof(placement_t)*65536);
 243     TAG*tag = swf->firstTag;
 244     while(tag) {
 245         if(swf_isPlaceTag(tag)) {
 246             SWFPLACEOBJECT*po = rfx_alloc(sizeof(SWFPLACEOBJECT));
 247             int id;
 248             swf_GetPlaceObject(tag, po);
 249             id = po->id;
 250             if(po->move) {
 251                 fprintf(stderr, "MOVE tags not supported with -c");
 252             }
 253             p[id].po = po;
 254             p[id].num++;
 255         }
 256         tag = tag->next;
 257     }
 258
 259     return p;
 260 }
 261
 262 static void freePlacements(placement_t*p)
 263 {
 264     int t;
 265     for(t=0;t<65536;t++) {
 266         if(p[t].po) {
 267             swf_PlaceObjectFree(p[t].po); p[t].po = 0;
 268         }
 269     }
 270     rfx_free(p);
 271 }
 272
 273 SRECT swf_ClipRect(SRECT border, SRECT r)
 274 {
 275     if(r.xmax > border.xmax) r.xmax = border.xmax;
 276     if(r.ymax > border.ymax) r.ymax = border.ymax;
 277     if(r.xmax < border.xmin) r.xmax = border.xmin;
 278     if(r.ymax < border.ymin) r.ymax = border.ymin;
 279
 280     if(r.xmin > border.xmax) r.xmin = border.xmax;
 281     if(r.ymin > border.ymax) r.ymin = border.ymax;
 282     if(r.xmin < border.xmin) r.xmin = border.xmin;
 283     if(r.ymin < border.ymin) r.ymin = border.ymin;
 284     return r;
 285 }
 286
 287 static SRECT clipBBox(TAG*tag, SRECT mbbox, SRECT r)
 288 {
 289     int id = swf_GetDefineID(tag);
 290     MATRIX m;
 291     if(!placements[id].po) {
 292         if(verbose)
 293             printf("Id %d is never set\n", id);
 294         return r;
 295     }
 296     if(placements[id].num>1) {
 297         if(verbose)
 298             printf("Id %d is set more than once\n", id);
 299         return r;
 300     }
 301     m = placements[id].po->matrix;
 302     if(m.r0 || m.r1)  {
 303         fprintf(stderr, "Rotating PLACEOBJECTS are not supported with -c\n");
 304         return r;
 305     }
 306
 307     if(verbose) {
 308         printf("ID %d\n", id);
 309         swf_DumpMatrix(stdout, &m);
 310     }
 311     mbbox.xmin -= m.tx;
 312     mbbox.ymin -= m.ty;
 313     mbbox.xmax -= m.tx;
 314     mbbox.ymax -= m.ty;
 315     mbbox.xmin *= 65536.0/m.sx;
 316     mbbox.xmax *= 65536.0/m.sx;
 317     mbbox.ymin *= 65536.0/m.sy;
 318     mbbox.ymax *= 65536.0/m.sy;
 319
 320     if(verbose) {
 321         printf("border: %f/%f/%f/%f - rect: %f/%f/%f/%f\n",
 322                 mbbox.xmin /20.0,
 323                 mbbox.ymin /20.0,
 324                 mbbox.xmax /20.0,
 325                 mbbox.ymax /20.0,
 326                 r.xmin /20.0,
 327                 r.ymin /20.0,
 328                 r.xmax /20.0,
 329                 r.ymax /20.0);
 330     }
 331
 332
 333     r = swf_ClipRect(mbbox, r);
 334
 335     if(verbose) {
 336         printf("new rect: %f/%f/%f/%f\n",
 337                 r.xmin /20.0,
 338                 r.ymin /20.0,
 339                 r.xmax /20.0,
 340                 r.ymax /20.0);
 341     }
 342
 343     return r;
 344 }
 345
 346
 347 static void textcallback(void*self, int*chars, int*xpos, int nr, int fontid, int fontsize,
 348                     int xstart, int ystart, RGBA* color)
 349 {
 350     textbounds_t * bounds = (textbounds_t*)self;
 351     SWFFONT*font = 0;
 352     int t;
 353     for(t=0;t<fontnum;t++) {
 354         if(fonts[t]->id == fontid) {
 355             font = fonts[t];
 356             break;
 357         }
 358     }
 359     if(!font) {
 360         fprintf(stderr, "Font %d unknown\n", fontid);
 361         exit(1);
 362     }
 363     if(!font->layout) {
 364         /* This is an expensive operation- but what should we do, we
 365            need the glyph's bounding boxes */
 366         swf_FontCreateLayout(font);
 367     }
 368
 369     if(verbose)
 370         printf("%d chars, font %d, size %d, at (%d,%d)\n", nr, fontid, fontsize, xstart, ystart);
 371
 372     for(t=0;t<nr;t++) {
 373         /* not tested yet- the matrix/fontsize calculation is probably all wrong */
 374         int x = xstart + xpos[t];
 375         int y = ystart;
 376         int ch = 0;
 377         SRECT newglyphbbox, glyphbbox = font->layout->bounds[chars[t]];
 378         MATRIX m = bounds->m;
 379         SPOINT p;
 380
 381         if(chars[t] < font->numchars && font->glyph2ascii) {
 382             ch = font->glyph2ascii[chars[t]];
 383         }
 384
 385         p.x = x; p.y = y;
 386         p = swf_TurnPoint(p, &m);
 387
 388         m.sx = (m.sx * fontsize) / 1024;
 389         m.sy = (m.sy * fontsize) / 1024;
 390         m.r0 = (m.r0 * fontsize) / 1024;
 391         m.r1 = (m.r1 * fontsize) / 1024;
 392
 393         m.tx += p.x;
 394         m.ty += p.y;
 395         newglyphbbox = swf_TurnRect(glyphbbox, &m);
 396
 397         if(ch<32) ch='?';
 398
 399         swf_ExpandRect2(&(bounds->r), &newglyphbbox);
 400         if(verbose >= 2) {
 401             printf("%5d %c, %d %d %d %d (%d %d %d %d) -> %d %d %d %d\n",
 402                 xpos[t], ch,
 403                 glyphbbox.xmin, glyphbbox.ymin, glyphbbox.xmax, glyphbbox.ymax,
 404                 newglyphbbox.xmin, newglyphbbox.ymin, newglyphbbox.xmax, newglyphbbox.ymax,
 405                 bounds->r.xmin, bounds->r.ymin, bounds->r.xmax, bounds->r.ymax);
 406         }
 407
 408     }
 409 }
 410
 411 static void swf_OptimizeBoundingBoxes(SWF*swf)
 412 {
 413     TAG* tag = swf->firstTag;
 414
 415     while (tag) {
 416         if (tag->id == ST_DEFINESHAPE ||
 417             tag->id == ST_DEFINESHAPE2 ||
 418             tag->id == ST_DEFINESHAPE3 ||
 419             tag->id == ST_DEFINESHAPE4) {
 420             SHAPE2 s;
 421             if(verbose) printf("%s\n", swf_TagGetName(tag));
 422             swf_ParseDefineShape(tag, &s);
 423             swf_Shape2Optimize(&s);
 424             tag->len = 2;
 425             tag->pos = 0;
 426             if(!s.bbox) {
 427                 fprintf(stderr, "Internal error (5)\n");
 428                 exit(1);
 429             }
 430             if(clip) {
 431                 *s.bbox = clipBBox(tag, swf->movieSize, *s.bbox);
 432             }
 433             swf_SetShape2(tag, &s);
 434         }
 435         if (tag->id == ST_DEFINETEXT || tag->id == ST_DEFINETEXT2) {
 436             SRECT oldbox;
 437             int matrix_offset;
 438             int len;
 439             U8*data;
 440             textbounds_t bounds;
 441             if(verbose) printf("%s\n", swf_TagGetName(tag));
 442             if(fontnum < 0) {
 443                 if(verbose) printf("Extracting fonts...\n");
 444                 c_swf = swf;
 445                 fontnum = 0;
 446                 swf_FontEnumerate(swf,&fontcallback1,0);
 447                 fonts = (SWFFONT**)malloc(fontnum*sizeof(SWFFONT*));
 448                 memset(fonts, 0, fontnum*sizeof(SWFFONT*));
 449                 fontnum = 0;
 450                 swf_FontEnumerate(swf,&fontcallback2,0);
 451             }
 452
 453             memset(&bounds, 0, sizeof(bounds));
 454
 455             swf_SetTagPos(tag, 0);
 456             swf_GetU16(tag);
 457             swf_GetRect(tag,&oldbox);
 458             swf_ResetReadBits(tag);
 459             matrix_offset = tag->pos;
 460             swf_GetMatrix(tag,&bounds.m);
 461             swf_ParseDefineText(tag, textcallback, &bounds);
 462             if(verbose) {
 463                 printf("\n");
 464                 swf_DumpMatrix(stdout, &bounds.m);
 465                 printf("old: %d %d %d %d\n", oldbox.xmin, oldbox.ymin, oldbox.xmax, oldbox.ymax);
 466                 printf("new: %d %d %d %d\n", bounds.r.xmin, bounds.r.ymin, bounds.r.xmax, bounds.r.ymax);
 467             }
 468             if(clip) {
 469                 bounds.r = clipBBox(tag, swf->movieSize, bounds.r);
 470             }
 471
 472             /* now comes the tricky part:
 473                we have to fiddle the data back in
 474                thank heavens that the bbox is follow by a matrix
 475                struct, which always starts on a byte boundary.
 476              */
 477             len = tag->len - matrix_offset;
 478             data = malloc(len);
 479             memcpy(data, &tag->data[matrix_offset], len);
 480             tag->writeBit = 0;
 481             tag->len = 2;
 482             swf_SetRect(tag, &bounds.r);
 483             swf_SetBlock(tag, data, len);
 484             free(data);
 485             tag->pos = tag->readBit = 0;
 486         }
 487         tag = tag->next;
 488     }
 489 }
 490
 491 static void showSwiftyOutput(SWF*swf)
 492 {
 493     TAG*tag = swf->firstTag;
 494     int frame=0;
 495     printf("{\n\t{frame %d}\n", frame++);
 496
 497     while (tag) {
 498         if (tag->id == ST_SHOWFRAME) {
 499             printf("}\n{\n\t{frame %d}\n", frame++);
 500         }
 501         if (swf_isPlaceTag(tag)) {
 502             if(hasid(tag)) {
 503                 depth2id[swf_GetDepth(tag)] = swf_GetPlaceID(tag);
 504             }
 505             if(hasname(tag)) {
 506                 depth2name[swf_GetDepth(tag)] = getname(tag);
 507             }
 508         }
 509         if (swf_isPlaceTag(tag)) {
 510             MATRIX m = getmatrix(tag);
 511             U16 id = depth2id[swf_GetDepth(tag)];
 512             char*name = depth2name[swf_GetDepth(tag)];
 513             char buf[40];
 514             SRECT bbox = bboxes[id];
 515             SPOINT p1,p2,p3,p4;
 516             p1.x = bbox.xmin; p1.y = bbox.ymin;
 517             p2.x = bbox.xmax; p2.y = bbox.ymin;
 518             p3.x = bbox.xmin; p3.y = bbox.ymax;
 519             p4.x = bbox.xmax; p4.y = bbox.ymax;
 520             p1 = swf_TurnPoint(p1, &m);
 521             p2 = swf_TurnPoint(p2, &m);
 522             p3 = swf_TurnPoint(p3, &m);
 523             p4 = swf_TurnPoint(p4, &m);
 524             if(!name) {
 525                 sprintf(buf, "ID%d", id);name = buf;
 526             }
 527             //printf("\t#%.4f %.4f %.4f %.4f | %.4f %.4f\n", m.sx/65536.0, m.r1/65536.0, m.r0/65536.0, m.sy/65536.0, m.tx/20.0, m.ty/20.0);
 528             printf("\t{%s {%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f}}\n", name,
 529                     p1.x/20.0, p1.y/20.0, p2.x/20.0, p2.y/20.0,
 530                     p3.x/20.0, p3.y/20.0, p4.x/20.0, p4.y/20.0);
 531         }
 532         tag = tag->next;
 533     }
 534     printf("}\n");
 535 }
 536 static SRECT getMovieClipBBox(TAG*tag)
 537 {
 538     //TAG*tag = swf->firstTag;
 539     int frame=0;
 540     SRECT movieSize;
 541     U16 depth2id[65536];
 542     memset(depth2id, 0, sizeof(depth2id));
 543
 544     memset(&movieSize,0,sizeof(SRECT));
 545
 546     while (tag && tag->id != ST_END) {
 547         if (swf_isPlaceTag(tag)) {
 548             if(hasid(tag)) {
 549                 depth2id[swf_GetDepth(tag)] = swf_GetPlaceID(tag);
 550             }
 551         }
 552         if (swf_isPlaceTag(tag)) {
 553             MATRIX m = getmatrix(tag);
 554             U16 id = depth2id[swf_GetDepth(tag)];
 555             SRECT bbox = bboxes[id];
 556
 557             SRECT tbbox = swf_TurnRect(bbox, &m);
 558             swf_ExpandRect2(&movieSize, &tbbox);
 559         }
 560         tag = tag->next;
 561     }
 562     return movieSize;
 563 }
 564
 565 static SRECT getSWFBBox(SWF*swf)
 566 {
 567     SRECT movieSize = getMovieClipBBox(swf->firstTag);
 568
 569     return movieSize;
 570 }
 571
 572 int main (int argc,char ** argv)
 573 {
 574     TAG*tag;
 575     SWF swf;
 576     int fi;
 577     SRECT oldMovieSize;
 578     SRECT newMovieSize;
 579     memset(bboxes, 0, sizeof(bboxes));
 580     memset(depth2name, 0, sizeof(depth2name));
 581
 582     processargs(argc, argv);
 583     initLog(0,0,0,0,0,verbose?LOGLEVEL_DEBUG:LOGLEVEL_WARNING);
 584
 585     if(!filename) {
 586         fprintf(stderr, "You must supply a filename.\n");
 587         return 1;
 588     }
 589
 590     fi = open(filename,O_RDONLY|O_BINARY);
 591
 592     if (fi<0)
 593     {
 594         perror("Couldn't open file: ");
 595         exit(1);
 596     }
 597     if FAILED(swf_ReadSWF(fi,&swf))
 598     {
 599         fprintf(stderr, "%s is not a valid SWF file or contains errors.\n",filename);
 600         close(fi);
 601         exit(1);
 602     }
 603     close(fi);
 604
 605     swf_OptimizeTagOrder(&swf);
 606
 607     if(clip) {
 608         placements = readPlacements(&swf);
 609     }
 610
 611     swf_FoldAll(&swf);
 612
 613     /* Optimize bounding boxes in case -O flag was set */
 614     if(optimize) {
 615         swf_OptimizeBoundingBoxes(&swf);
 616     }
 617
 618     /* Create an ID to Bounding Box table */
 619     tag = swf.firstTag;
 620     while (tag) {
 621         if(swf_isDefiningTag(tag)) {
 622             int id = swf_GetDefineID(tag);
 623             if(tag->id != ST_DEFINESPRITE) {
 624                 bboxes[id] = swf_GetDefineBBox(tag);
 625             } else {
 626                 swf_UnFoldSprite(tag);
 627                 bboxes[id] = getMovieClipBBox(tag);
 628                 swf_FoldSprite(tag);
 629                 if(verbose) {
 630                     printf("sprite %d is %.2fx%.2f\n", id,
 631                             (bboxes[id].xmax - bboxes[id].xmin)/20.0,
 632                             (bboxes[id].ymax - bboxes[id].ymin)/20.0);
 633                 }
 634             }
 635         }
 636         tag = tag->next;
 637     }
 638
 639     /* Create an ID->Bounding Box table for all bounding boxes */
 640     if(swifty) {
 641         showSwiftyOutput(&swf);
 642     }
 643
 644     oldMovieSize = swf.movieSize;
 645     newMovieSize = getSWFBBox(&swf);
 646
 647     if(optimize || expand) {
 648
 649         if(expand)
 650             swf.movieSize = newMovieSize;
 651
 652         fi = open(outfilename, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
 653         if(swf_WriteSWF(fi, &swf) < 0) {
 654             fprintf(stderr, "Error writing file %s", outfilename);
 655             close(fi);
 656             exit(1);
 657         }
 658         close(fi);
 659     }
 660
 661     if(showbbox) {
 662         if(verbose>=0)
 663             printf("Real Movie Size: ");
 664         printf("%.2f x %.2f :%.2f :%.2f\n",
 665                 (newMovieSize.xmax-newMovieSize.xmin)/20.0,
 666                 (newMovieSize.ymax-newMovieSize.ymin)/20.0,
 667                 (newMovieSize.xmin)/20.0,
 668                 (newMovieSize.ymin)/20.0
 669                 );
 670     }
 671     if(showorigbbox) {
 672         if(verbose>=0)
 673             printf("Original Movie Size: ");
 674         printf("%.2f x %.2f :%.2f :%.2f\n",
 675                 (oldMovieSize.xmax-oldMovieSize.xmin)/20.0,
 676                 (oldMovieSize.ymax-oldMovieSize.ymin)/20.0,
 677                 (oldMovieSize.xmin)/20.0,
 678                 (oldMovieSize.ymin)/20.0
 679                 );
 680     }
 681
 682     swf_FreeTags(&swf);
 683
 684     if(placements) {
 685         freePlacements(placements);
 686     }
 687     return 0;
 688 }