Applied patch from Marcus Doemling-
[swftools.git] / 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
38 struct options_t options[] =
39 {
40  {"V","version"},
41  {"O","optimize"},
42  {"o","output"},
43  {"S","swifty"},
44  {"v","verbose"},
45  {0,0}
46 };
47
48 int args_callback_option(char*name,char*val)
49 {
50     if(!strcmp(name, "V")) {
51         printf("swfbbox - part of %s %s\n", PACKAGE, VERSION);
52         exit(0);
53     } 
54     else if(!strcmp(name, "O")) {
55         optimize = 1;
56         return 0;
57     } 
58     else if(!strcmp(name, "S")) {
59         swifty = 1;
60         return 0;
61     } 
62     else if(!strcmp(name, "v")) {
63         verbose = 1;
64         return 0;
65     } 
66     else if(!strcmp(name, "o")) {
67         outfilename = val;
68         return 1;
69     } 
70     else {
71         printf("Unknown option: -%s\n", name);
72         exit(1);
73     }
74
75     return 0;
76 }
77 int args_callback_longoption(char*name,char*val)
78 {
79     return args_long2shortoption(options, name, val);
80 }
81 void args_callback_usage(char*name)
82 {    
83     printf("Usage: %s [-OS] file.swf\n", name);
84     printf("\t-h , --help\t\t Print help and exit\n");
85     printf("\t-O , --optimize\t\t Recalculate bounding boxes\n");
86     printf("\t-S , --swifty\t\t Print out transformed bounding boxes\n");
87     printf("\t-o , --output\t\t Set output filename (for -O)\n");
88     printf("\t-v , --verbose\t\t Be more verbose\n");
89     printf("\t-V , --version\t\t Print program version and exit\n");
90 }
91 int args_callback_command(char*name,char*val)
92 {
93     if(filename) {
94         fprintf(stderr, "Only one file allowed. You supplied at least two. (%s and %s)\n",
95                  filename, name);
96     }
97     filename = name;
98     return 0;
99 }
100
101 #define swf_ResetReadBits(tag)   if (tag->readBit)  { tag->pos++; tag->readBit = 0; }
102
103 void parseFillStyleArray(TAG*tag, SHAPE2*shape)
104 {
105     U16 count;
106     int t;
107     int num=0;
108     if(tag->id == ST_DEFINESHAPE)
109         num = 1;
110     else if(tag->id == ST_DEFINESHAPE2)
111         num = 2;
112     else if(tag->id == ST_DEFINESHAPE3)
113         num = 3;
114
115     count = swf_GetU8(tag);
116     if(count == 0xff && num>1) // defineshape2,3 only
117         count = swf_GetU16(tag);
118
119     if(verbose) printf("num: %d\n", count);
120     shape->numfillstyles = count;
121     shape->fillstyles = malloc(sizeof(FILLSTYLE)*count);
122
123     for(t=0;t<count;t++)
124     {
125         int type;
126         U8*pos;
127         FILLSTYLE*dest = &shape->fillstyles[t];
128         swf_ResetReadBits(tag);
129         type = swf_GetU8(tag); //type
130         shape->fillstyles[t].type = type;
131         if(type == 0) {
132             /* plain color */
133             if(num == 3)
134                 swf_GetRGBA(tag, &dest->color);
135             else 
136                 swf_GetRGB(tag, &dest->color);
137         }
138         else if(type == 0x10 || type == 0x12)
139         {
140             /* linear/radial gradient fill */
141             swf_ResetReadBits(tag);
142             swf_GetMatrix(tag, &dest->m);
143             swf_ResetReadBits(tag);
144             dest->gradient = malloc(sizeof(GRADIENT)); // TODO: free this again
145             swf_GetGradient(tag, dest->gradient, num>=3?1:0);
146         }
147         else if(type == 0x40 || type == 0x41)
148         {
149             /* bitmap fill */
150             swf_ResetReadBits(tag);
151             dest->id_bitmap = swf_GetU16(tag); //id
152             swf_ResetReadBits(tag); //?
153             swf_GetMatrix(tag, &dest->m);
154         }
155         else {
156             fprintf(stderr, "rfxswf:swftools.c Unknown fillstyle:0x%02x\n",type);
157         }
158     }
159     swf_ResetReadBits(tag);
160     count = swf_GetU8(tag); // line style array
161     if(count == 0xff)
162         count = swf_GetU16(tag);
163
164     if(verbose) printf("lnum: %d\n", count);
165
166     shape->numlinestyles = count;
167     shape->linestyles = malloc(sizeof(LINESTYLE)*count);
168     /* TODO: should we start with 1 and insert a correct definition of the
169        "built in" linestyle 0? */
170     for(t=0;t<count;t++) 
171     {
172         shape->linestyles[t].width = swf_GetU16(tag);
173         if(num == 3)
174             swf_GetRGBA(tag, &shape->linestyles[t].color);
175         else
176             swf_GetRGB(tag, &shape->linestyles[t].color);
177     }
178     return;
179 }
180
181 void swf_ParseDefineShape(TAG*tag, SHAPE2*shape)
182 {
183     int num = 0, id;
184     U16 fill,line;
185     SRECT r;
186     SRECT r2;
187     SHAPELINE*l;
188     if(tag->id == ST_DEFINESHAPE)
189         num = 1;
190     else if(tag->id == ST_DEFINESHAPE2)
191         num = 2;
192     else if(tag->id == ST_DEFINESHAPE3)
193         num = 3;
194     else {
195         fprintf(stderr, "parseDefineShape must be called with a shape tag");
196     }
197
198     id = swf_GetU16(tag); //id
199     memset(shape, 0, sizeof(SHAPE2));
200     shape->bbox = malloc(sizeof(SRECT));
201     swf_GetRect(tag, &r);
202
203     memcpy(shape->bbox, &r, sizeof(SRECT));
204     parseFillStyleArray(tag, shape);
205
206     swf_ResetReadBits(tag); 
207     fill = (U16)swf_GetBits(tag,4);
208     line = (U16)swf_GetBits(tag,4);
209
210     shape->lines = swf_ParseShapeData(&tag->data[tag->pos], (tag->len - tag->pos)*8, fill, line);
211
212     l = shape->lines;
213 }
214
215 void swf_Shape2Optimize(SHAPE2*shape)
216 {
217     if(!shape->bbox)
218         shape->bbox = malloc(sizeof(SRECT));
219     *(shape->bbox) = swf_GetShapeBoundingBox(shape);
220 }
221
222 void swf_Shape2ToShape(SHAPE2*shape2, SHAPE*shape)
223 {
224     TAG*tag = swf_InsertTag(0,0);
225     SHAPELINE*l,*next;
226     int newx=0,newy=0,lastx=0,lasty=0,oldls=0,oldfs0=0,oldfs1=0;
227
228     memset(shape, 0, sizeof(SHAPE));
229
230     shape->linestyle.n = shape2->numlinestyles;
231     shape->linestyle.data = (LINESTYLE*)malloc(sizeof(LINESTYLE)*shape->linestyle.n);
232     memcpy(shape->linestyle.data, shape2->linestyles, sizeof(LINESTYLE)*shape->linestyle.n);
233     
234     shape->fillstyle.n =  shape2->numfillstyles;
235     shape->fillstyle.data = (FILLSTYLE*)malloc(sizeof(FILLSTYLE)*shape->fillstyle.n);
236     memcpy(shape->fillstyle.data, shape2->fillstyles, sizeof(FILLSTYLE)*shape->fillstyle.n);
237
238     swf_ShapeCountBits(shape,NULL,NULL);
239
240     l = shape2->lines;
241
242     while(l) {
243         int ls=0,fs0=0,fs1=0;
244
245         if(l->type != moveTo) {
246             if(oldls != l->linestyle) {oldls = ls = l->linestyle;if(!ls) ls=0x8000;}
247             if(oldfs0 != l->fillstyle0) {oldfs0 = fs0 = l->fillstyle0;if(!fs0) fs0=0x8000;}
248             if(oldfs1 != l->fillstyle1) {oldfs1 = fs1 = l->fillstyle1;if(!fs1) fs1=0x8000;}
249
250             if(ls || fs0 || fs1 || newx!=0x7fffffff || newy!=0x7fffffff) {
251                 swf_ShapeSetAll(tag,shape,newx,newy,ls,fs0,fs1);
252                 newx = 0x7fffffff;
253                 newy = 0x7fffffff;
254             }
255         }
256
257         if(l->type == lineTo) {
258             swf_ShapeSetLine(tag,shape,l->x-lastx,l->y-lasty);
259         } else if(l->type == splineTo) {
260             swf_ShapeSetCurve(tag,shape, l->sx-lastx,l->sy-lasty, l->x-l->sx,l->y-l->sy);
261         }
262         if(l->type == moveTo) {
263             newx = l->x;
264             newy = l->y;
265         }
266
267         lastx = l->x;
268         lasty = l->y;
269         l = l->next;
270     }
271     swf_ShapeSetEnd(tag);
272     shape->data = tag->data;
273     shape->bitlen = tag->len*8;
274 }
275
276 void swf_SetShape2(TAG*tag, SHAPE2*shape2)
277 {
278     SHAPE shape;
279     swf_Shape2ToShape(shape2, &shape);
280
281     swf_SetRect(tag,shape2->bbox);
282     swf_SetShapeStyles(tag, &shape);
283     swf_ShapeCountBits(&shape,NULL,NULL);
284     swf_SetShapeBits(tag,&shape);
285
286     swf_SetBlock(tag, shape.data, (shape.bitlen+7)/8);
287 }
288
289 /*
290    {char {x1 y1 x2 y2 x3 y3 x4 y4]]
291 */
292
293 SRECT bboxes[65536];
294 U16 depth2id[65536];
295 char*depth2name[65536];
296
297 int hasid(TAG*tag)
298 {
299     if(tag->id == ST_PLACEOBJECT)
300         return 1;
301     if(tag->id == ST_PLACEOBJECT2 && (tag->data[0] & 2))
302         return 1;
303     return 0;
304 }
305
306 int hasname(TAG*tag)
307 {
308     if(tag->id == ST_PLACEOBJECT)
309         return 0;
310     if(tag->id == ST_PLACEOBJECT2 && (tag->data[0] & 0x20))
311         return 1;
312     return 0;
313 }
314
315 char* getname(TAG*tag)
316 {
317     if(tag->id == ST_PLACEOBJECT)
318         return 0;
319     if(tag->id == ST_PLACEOBJECT2 && (tag->data[0] & 0x20)) {
320         SWFPLACEOBJECT o;
321         tag->pos = 0;tag->readBit = 0;
322         swf_GetPlaceObject(tag, &o);
323         return o.name;
324     }
325     return 0;
326 }
327
328 MATRIX getmatrix(TAG*tag)
329 {
330     SWFPLACEOBJECT o;
331     tag->pos = 0;tag->readBit = 0;
332     swf_GetPlaceObject(tag, &o);
333     return o.matrix;
334 }
335
336 static void swf_OptimizeBoundingBoxes(SWF*swf)
337 {
338     TAG* tag = swf->firstTag;
339     while (tag) {
340         if (tag->id == ST_DEFINESHAPE ||
341             tag->id == ST_DEFINESHAPE2 ||
342             tag->id == ST_DEFINESHAPE3) {
343             SHAPE2 s;
344             if(verbose) printf("%s\n", swf_TagGetName(tag));
345             swf_ParseDefineShape(tag, &s);
346             swf_Shape2Optimize(&s);
347             tag->len = 2;
348             tag->pos = 0;
349             swf_SetShape2(tag, &s);
350         }
351     }
352 }
353
354 static void showSwiftyOutput(SWF*swf) 
355 {
356     TAG*tag = swf->firstTag;
357     int frame=0;
358     printf("{\n\t{frame %d}\n", frame++);
359
360     while (tag) {
361         if (tag->id == ST_SHOWFRAME) {
362             printf("}\n{\n\t{frame %d}\n", frame++);
363         }
364         if (tag->id == ST_PLACEOBJECT || tag->id == ST_PLACEOBJECT2) {
365             if(hasid(tag)) {
366                 depth2id[swf_GetDepth(tag)] = swf_GetPlaceID(tag);
367             }
368             if(hasname(tag)) {
369                 depth2name[swf_GetDepth(tag)] = getname(tag);
370             }
371         }
372         if (tag->id == ST_PLACEOBJECT || tag->id == ST_PLACEOBJECT2) {
373             MATRIX m = getmatrix(tag);
374             U16 id = depth2id[swf_GetDepth(tag)];
375             char*name = depth2name[swf_GetDepth(tag)];
376             char buf[40];
377             SRECT bbox = bboxes[id];
378             SPOINT p1,p2,p3,p4;
379             p1.x = bbox.xmin; p1.y = bbox.ymin;
380             p2.x = bbox.xmax; p2.y = bbox.ymin;
381             p3.x = bbox.xmin; p3.y = bbox.ymax;
382             p4.x = bbox.xmax; p4.y = bbox.ymax;
383             p1 = swf_TurnPoint(p1, &m);
384             p2 = swf_TurnPoint(p2, &m);
385             p3 = swf_TurnPoint(p3, &m);
386             p4 = swf_TurnPoint(p4, &m);
387             if(!name) {
388                 sprintf(buf, "ID%d", id);name = buf;
389             }
390             //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);
391             printf("\t{%s {%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f}}\n", name, 
392                     p1.x/20.0, p1.y/20.0, p2.x/20.0, p2.y/20.0,
393                     p3.x/20.0, p3.y/20.0, p4.x/20.0, p4.y/20.0);
394         }
395         tag = tag->next;
396     }
397     printf("}\n");
398 }
399
400     
401 int main (int argc,char ** argv)
402
403     TAG*tag;
404     SWF swf;
405     int fi;
406     memset(bboxes, 0, sizeof(bboxes));
407     memset(depth2name, 0, sizeof(depth2name));
408
409     processargs(argc, argv);
410     initLog(0,0,0,0,0,verbose?LOGLEVEL_DEBUG:LOGLEVEL_WARNING);
411
412     if(!filename) {
413         fprintf(stderr, "You must supply a filename.\n");
414         return 1;
415     }
416
417     fi = open(filename,O_RDONLY|O_BINARY);
418
419     if (fi<0)
420     { 
421         perror("Couldn't open file: ");
422         exit(1);
423     }
424     if FAILED(swf_ReadSWF(fi,&swf))
425     { 
426         fprintf(stderr, "%s is not a valid SWF file or contains errors.\n",filename);
427         close(fi);
428         exit(1);
429     }
430     close(fi);
431
432     swf_OptimizeTagOrder(&swf);
433     swf_FoldAll(&swf);
434
435     /* Optimize bounding boxes in case -O flag was set */
436     if(optimize) {
437         swf_OptimizeBoundingBoxes(&swf);
438     }
439     
440     /* Create an ID to Bounding Box table */
441     tag = swf.firstTag;
442     while (tag) {
443         if(swf_isDefiningTag(tag) && tag->id != ST_DEFINESPRITE) {
444             bboxes[swf_GetDefineID(tag)] = swf_GetDefineBBox(tag);
445         }
446         tag = tag->next;
447     }
448     
449     /* Create an ID->Bounding Box table for all bounding boxes */
450     if(swifty) {
451         showSwiftyOutput(&swf);
452     }
453
454     if(optimize) {
455         fi = open(outfilename, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, 0666);
456         if(swf_WriteSWF(fi, &swf) < 0) {
457             fprintf(stderr, "Error writing file %s", outfilename);
458             close(fi);
459             exit(1);
460         }
461         close(fi);
462     }
463
464     swf_FreeTags(&swf);
465     return 0;
466 }