Generated from pdf2swf_usage.html
[swftools.git] / src / flash.c
1 /* flash.c
2    Various routines for reading and writing swf files and tags.
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 "flash.h"
11 #include "bitio.h"
12
13 void swf_init(struct reader_t*r, uchar*newdata, int newlength)
14 {
15     reader_init (r, &newdata[3], newlength - 3);
16 }
17
18 struct flash_header swf_read_header(struct reader_t*r)
19 {
20     struct flash_header head;
21     u16 rate;
22     u16 count;
23     char version;
24     int length;
25     u8* oldpos = reader_getinputpos(r);
26
27     reader_input1(r,&version);
28     head.version = version;
29     reader_input4(r,&length);
30     head.length = length;
31     
32     reader_resetbits(r);
33     head.boundingBox = readRECT(r);
34     reader_input2(r,&rate);
35     head.rate = rate;
36     reader_input2(r,&count);
37     head.count = count;
38
39     head.headerlength = reader_getinputpos(r) - oldpos;
40     head.headerdata = oldpos;
41
42     return head;
43 }
44
45 void swf_write_header(struct writer_t*w, struct flash_header*head)
46 {
47     writer_writeu8(w, head->version);
48     writer_writeu32(w, head->length);
49     
50     writer_writebits(w, 31, 5); 
51     writer_writebits(w, head->boundingBox.x1, 31);
52     writer_writebits(w, head->boundingBox.x2, 31);
53     writer_writebits(w, head->boundingBox.y1, 31);
54     writer_writebits(w, head->boundingBox.y2, 31);
55     writer_resetbits(w);
56     writer_writeu16(w, head->rate);
57     writer_writeu16(w, head->count);
58 }
59
60 struct RGB readRGB(struct reader_t*r)
61 {
62     struct RGB rgb;
63     reader_input1(r,&rgb.r);
64     reader_input1(r,&rgb.g);
65     reader_input1(r,&rgb.b);
66     return rgb;
67 }
68
69 struct RGBA readRGBA(struct reader_t*r)
70 {
71     struct RGBA rgba;
72     reader_input1(r,&rgba.r);
73     reader_input1(r,&rgba.g);
74     reader_input1(r,&rgba.b);
75     reader_input1(r,&rgba.a);
76     return rgba;
77 }
78
79 struct GRADIENT readGRADIENT(struct reader_t*r, int shape)
80 {
81     struct GRADIENT gradient;
82     int t;
83     gradient.num = reader_readu8(r);
84     for(t=0;t<gradient.num;t++)
85     {
86         gradient.ratios[t] = reader_readu8(r);
87         if(shape<3)
88             gradient.rgb[t] = readRGB(r);
89         else
90             gradient.rgba[t] = readRGBA(r);
91     }
92     return gradient;
93 }
94
95 struct RECT readRECT(struct reader_t*reader)
96 {
97     u32 a;
98     struct RECT r;
99     s32 b;
100     reader_readbits(reader,&a,5);
101     reader_readsbits(reader,&b,a);
102     r.x1=b;
103     reader_readsbits(reader,&b,a);
104     r.x2=b;
105     reader_readsbits(reader,&b,a);
106     r.y1=b;
107     reader_readsbits(reader,&b,a);
108     r.y2=b;
109     return r;
110 }
111
112
113 void writeRECT(u8**pos, struct RECT*r)
114 {
115     struct writer_t w;
116     int t=0;
117     writer_init(&w, *pos, 256);
118     writer_writebits(&w, 31, 5); //FIXME:count
119     writer_writebits(&w, r->x1, 31);
120     writer_writebits(&w, r->x2, 31);
121     writer_writebits(&w, r->y1, 31);
122     writer_writebits(&w, r->y2, 31);
123     writer_resetbits(&w);
124     *pos = writer_getpos(&w);
125 }
126
127 struct CXFORM readCXFORM(struct reader_t*r, char alpha)
128 {
129     struct CXFORM c;
130     int bits;
131     c.hasadd=reader_readbit(r);
132     c.hasmult=reader_readbit(r);
133     bits=reader_getbits(r,4);
134     c.alpha = alpha;
135
136     if (c.hasmult)
137     {
138         c.rmult=reader_getsbits(r,bits)/65536.0;
139         c.gmult=reader_getsbits(r,bits)/65536.0;
140         c.bmult=reader_getsbits(r,bits)/65536.0;
141         if(c.alpha)
142             c.amult=reader_getsbits(r,bits)/65536.0;
143     }
144     if (c.hasadd)
145     {
146         c.radd=reader_getsbits(r,bits)/65536.0;
147         c.gadd=reader_getsbits(r,bits)/65536.0;
148         c.badd=reader_getsbits(r,bits)/65536.0;
149         if(c.alpha)
150             c.aadd=reader_getsbits(r,bits)/65536.0;
151     }
152     return c;
153 }
154
155 void CXFORM_write(struct CXFORM *obj, struct writer_t*w)
156 {
157     int bits = 15;
158     writer_writebit(w,obj->hasadd);
159     writer_writebit(w,obj->hasmult);
160     writer_writebits(w, bits, 4);
161     if (obj->hasmult)
162     {
163         writer_writebits(w, obj->rmult, bits);
164         writer_writebits(w, obj->gmult, bits);
165         writer_writebits(w, obj->bmult, bits);
166         if(obj->alpha)
167             writer_writebits(w, obj->amult, 4);
168     }
169     if (obj->hasadd)
170     {
171         writer_writebits(w, obj->radd, bits);
172         writer_writebits(w, obj->gadd, bits);
173         writer_writebits(w, obj->badd, bits);
174         if(obj->alpha)
175             writer_writebits(w, obj->aadd, 4);
176     }
177 }
178
179 unsigned char* readSTRING(struct reader_t*r)
180 {
181     unsigned char*now = reader_getinputpos(r);
182     char a;
183     do
184     {
185         reader_input1(r,&a);
186     }
187     while(a);
188     return now;
189 }
190 void MATRIX_init(struct MATRIX*m)
191 {
192     m->hasrotate = 0;
193     m->hasscale = 0;
194     m->b[0] = 0; 
195     m->b[1] = 0; 
196     m->a[0][0] = 1;
197     m->a[1][1] = 1;
198     m->a[1][0] = 0;
199     m->a[0][1] = 0;
200 }
201 struct MATRIX readMATRIX(struct reader_t*r)
202 {
203     struct MATRIX m;
204     u8 hasrotate;
205     u8 translatebits;
206     u32 translatex;
207     u32 translatey;
208
209     m.a[0][0] = m.a[1][1] = 1;
210     m.a[0][1] = m.a[1][0] = 0;
211     m.hasscale=reader_readbit(r);
212     if(m.hasscale)
213     {
214         u8 scalebits=reader_getbits(r,5);
215         s32 scalex=reader_getsbits(r,scalebits);
216         s32 scaley=reader_getsbits(r,scalebits);
217         m.a[0][0]=scalex/65536.0;
218         m.a[1][1]=scaley/65536.0;
219     }
220     m.hasrotate=reader_readbit(r);
221     if(m.hasrotate)
222     {
223         u8 rotbits=reader_getbits(r,5);
224         s32 rotateskew0=reader_getsbits(r,rotbits);
225         s32 rotateskew1=reader_getsbits(r,rotbits);
226         m.a[0][1]=rotateskew0/65536.0;
227         m.a[1][0]=rotateskew1/65536.0;
228     }
229
230     translatebits=reader_getbits(r,5);
231     translatex=reader_getsbits(r,translatebits);
232     translatey=reader_getsbits(r,translatebits);
233     m.b[0]=translatex;
234     m.b[1]=translatey;
235
236     return m;
237 }
238
239 void MATRIX_write(struct MATRIX * m , struct writer_t*w)
240 {
241     writer_writebit (w, m->hasscale);
242     if(m->hasscale)
243     {
244         int bits = 31;
245         writer_writebits(w, bits, 5);
246         writer_writebits(w, (u32)(m->a[0][0]*65536.0), bits);
247         writer_writebits(w, (u32)(m->a[1][1]*65536.0), bits);
248     }
249     writer_writebit (w, m->hasrotate);
250     if(m->hasrotate)
251     {
252         int bits = 31;
253         writer_writebits(w, bits, 5);
254         writer_writebits(w, (u32)(m->a[0][1]*65536.0), bits);
255         writer_writebits(w, (u32)(m->a[1][0]*65536.0), bits);
256     }
257
258     //translate
259     {
260         int bits = 31;
261         writer_writebits(w, bits, 5);
262         writer_writebits(w, (u32)(m->b[0]), bits);
263         writer_writebits(w, (u32)(m->b[1]), bits);
264     }
265 }
266
267
268 int swf_read_tag(struct reader_t*r, struct swf_tag* swftag)
269 {
270     u8*pos2,*pos = reader_getinputpos(r);
271     u16 tag;
272     u32 taglength;
273     u32 tagid;
274     int t;
275
276     reader_input2(r, &tag);
277
278     taglength = tag & 0x3f;
279     if (taglength == 0x3f)
280     {
281         reader_input4(r, &taglength);
282     }
283
284     swftag->id=tag>>6;
285     swftag->length = taglength;
286     swftag->data = reader_getinputpos(r);
287     reader_skip(r,taglength);
288     pos2 = reader_getinputpos(r);
289     swftag->fulllength = pos2 - pos;
290     swftag->fulldata = pos;
291     return 1;
292 }
293
294 int swf_count_tags(struct reader_t*r)
295 {
296     u8*pos = reader_getinputpos(r);
297     int t=0;
298     struct swf_tag tag;
299
300     while(1)
301     {
302         swf_read_tag(r,&tag);
303         t++;
304         if (tag.id == 0)
305             break;
306     }
307     
308     reader_setinputpos(r,pos);
309     return t;
310 }
311
312 void placeobject_init (struct PlaceObject*obj, struct swf_tag*tag)
313 {
314     struct reader_t r;
315     reader_init (&r, tag->data, tag->length);
316     obj -> id = reader_readu16(&r);
317     obj -> depth = reader_readu16(&r);
318     obj -> matrix = readMATRIX(&r);
319     obj -> hascxform = (reader_getinputpos(&r) < &tag->data[tag->length]);
320     if(obj -> hascxform)
321         obj -> cxform = readCXFORM(&r, 0);
322 }
323
324 void placeobject_write (struct PlaceObject*obj, struct writer_t*w)
325 {
326     u16 taghead = 0x3f | TAGID_PLACEOBJECT<<6;
327     u8*pos;
328     u8*lenpos;
329     U32 len;
330     writer_resetbits(w);
331     writer_write(w, &taghead, 2);
332     lenpos = writer_getpos(w);
333
334     writer_write(w, &taghead, 2);
335     writer_write(w, &taghead, 2);
336
337     pos = writer_getpos(w);
338
339     writer_write(w, &obj->id, 2);
340     writer_write(w, &obj->depth, 2);
341     MATRIX_write(&obj->matrix, w);
342
343     if(obj->hascxform)
344     {
345         CXFORM_write(&obj->cxform, w);
346     }
347     writer_resetbits(w);
348    
349     len = (u8*)writer_getpos(w) - pos;
350     lenpos[0] = len;
351     lenpos[1] = len>>8;
352     lenpos[2] = len>>16;
353     lenpos[3] = len>>24;
354 }
355
356 void placeobject2_init (struct PlaceObject2*obj,struct swf_tag*tag)
357 {    
358     struct reader_t r;
359     u8 b;
360     reader_init (&r, tag->data, tag->length);
361     b=reader_readu8(&r);
362     obj->reserved=         (b>>7)&1;
363     obj->hasclipactions=   (b>>6)&1;
364     obj->hasname=          (b>>5)&1;
365     obj->hasratio=         (b>>4)&1;
366     obj->hascolortransform=(b>>3)&1;
367     obj->hasmatrix=        (b>>2)&1;
368     obj->hascharacter=     (b>>1)&1;
369     obj->hasmove=          (b>>0)&1;
370
371     obj->depth = reader_readu16(&r);
372     obj->id = -1;
373     if(obj->hascharacter) {
374         obj->id = reader_readu16(&r);
375     }
376     if(obj->hasmatrix) { 
377         obj->matrix = readMATRIX(&r);
378     } 
379     if(obj->hascolortransform) {
380         obj->cxform = readCXFORM(&r,0);
381     }
382     if(obj->hasratio) {
383         obj->ratio=reader_readu16(&r);
384     }
385     obj->name = 0;
386     if(obj->hasname) {
387         obj->name=readSTRING(&r);
388     }
389     if(obj->hasclipactions) {
390         obj->clipactions=reader_readu16(&r);
391     }
392 }
393
394 void placeobject2_write (struct PlaceObject2*obj, struct writer_t*w)
395 {
396     u8 flags = obj->reserved<<7 | obj->hasclipactions<<6 | obj->hasname<<5 | obj->hasratio<<4 |
397                obj->hascolortransform<<3 | obj->hasmatrix<<2 | obj->hascharacter<<1 | obj->hasmove;
398     u16 taghead = SWAP16(0x3f | TAGID_PLACEOBJECT2<<6);
399     u8*pos;
400     u8*lenpos;
401     U32 len;
402     writer_resetbits(w);
403     writer_write(w, &taghead, 2);
404     lenpos = writer_getpos(w);
405     writer_write(w, &taghead, 2);
406     writer_write(w, &taghead, 2);
407
408     pos = writer_getpos(w);
409
410     writer_writeu8(w, flags);
411     writer_writeu16(w, obj->depth);
412     if(obj->hascharacter)
413         writer_writeu16(w, obj->id);
414     if(obj->hasmatrix)
415         MATRIX_write(&obj->matrix, w);
416     if(obj->hascolortransform)
417         CXFORM_write(&obj->cxform, w);
418     if(obj->hasratio)
419         writer_writeu16(w, obj->ratio);
420     writer_resetbits(w);
421     if(obj->hasname)
422         writer_write(w, obj->name, strlen(obj->name) + 1);
423     if(obj->hasclipactions)
424         writer_writeu16(w, obj->clipactions);
425     writer_resetbits(w);
426     
427     len = (u8*)writer_getpos(w) - pos;
428     lenpos[0] = len;
429     lenpos[1] = len>>8;
430     lenpos[2] = len>>16;
431     lenpos[3] = len>>24;
432 }
433
434 void read_swf(struct swffile*swf, uchar*data, int length)
435 {
436     int pos;
437     struct flash_header head;
438     int tagnum;
439     struct reader_t r;
440     swf_init(&r, data, length);
441     head = swf_read_header(&r);
442     logf("<debug> [HEADER] the version is %d", head.version);
443     logf("<debug> [HEADER] the length is %d", head.length);
444     logf("<debug> [HEADER] the boundingBox is %d:%d:%d:%d", 
445             head.boundingBox.x1,head.boundingBox.y1,
446             head.boundingBox.x2,head.boundingBox.y2);
447     logf("<debug> [HEADER] the rate (frames/second) is %d", head.rate);
448     logf("<debug> [HEADER] the count (frame number) is %d", head.count);
449
450     tagnum = swf_count_tags(&r);
451     swf->tags = (struct swf_tag*)malloc(sizeof(struct swf_tag)*tagnum);
452     
453     logf("<debug> [HEADER] the file consists of %d tags", tagnum);
454
455     pos = 0;
456     while(1)
457     {
458         struct swf_tag tag;
459         swf_read_tag(&r, &tag);
460         logf("<debug> read tag %02x (%d bytes)", tag.id, tag.length);
461         swf->tags[pos] = tag;
462         pos++;
463         if(tag.id == TAGID_END)
464             break;
465     }
466     swf->tagnum = tagnum;
467     swf->header = head;
468 }
469
470 int definingtagids[] =
471 {TAGID_DEFINESHAPE,
472  TAGID_DEFINESHAPE2,
473  TAGID_DEFINESHAPE3,
474  TAGID_DEFINEMORPHSHAPE,
475  TAGID_DEFINEFONT,
476  TAGID_DEFINEFONT2,
477  TAGID_DEFINETEXT,
478  TAGID_DEFINETEXT2,
479  TAGID_DEFINEEDITTEXT,
480  TAGID_DEFINEBITS,
481  TAGID_DEFINEBITSJPEG2,
482  TAGID_DEFINEBITSJPEG3,
483  TAGID_DEFINEBITSLOSSLESS,
484  TAGID_DEFINEBITSLOSSLESS2,
485  TAGID_DEFINEMOVIE,
486  TAGID_DEFINESPRITE,
487  TAGID_DEFINEBUTTON,
488  TAGID_DEFINEBUTTON2,
489  TAGID_DEFINESOUND,
490  -1
491 };
492
493 // tags which may be used inside a sprite definition
494 int spritetagids[] =
495 {TAGID_SHOWFRAME,
496  TAGID_PLACEOBJECT,
497  TAGID_PLACEOBJECT2,
498  TAGID_REMOVEOBJECT,
499  TAGID_REMOVEOBJECT2, //?
500  TAGID_DOACTION,
501  TAGID_STARTSOUND,
502  TAGID_FRAMELABEL,
503  TAGID_SOUNDSTREAMHEAD,
504  TAGID_SOUNDSTREAMHEAD2,
505  TAGID_SOUNDSTREAMBLOCK,
506  TAGID_END,
507  -1
508 };
509
510 int getidfromtag(struct swf_tag* tag)
511 {
512     int num = 1;
513     switch(tag->id) {
514         case TAGID_PLACEOBJECT2:
515             num++;
516         case TAGID_PLACEOBJECT: {
517            struct reader_t r;
518            reader_init (&r, tag->data, tag->length);
519            if(num>=2) {
520                 char b = reader_readu8(&r);
521                 if(!(b&2))
522                     return -1;
523            }
524            reader_readu16(&r);
525            return reader_readu16(&r);
526         }
527         break;
528         case TAGID_REMOVEOBJECT:
529            return tag->data[0]+tag->data[1]*256;
530         break;
531         case TAGID_REMOVEOBJECT2:
532            return -1;
533         break;
534     }
535
536     return tag->data[0]+tag->data[1]*256;
537 }
538
539 void setidintag(struct swf_tag* tag, int id)
540 {
541     tag->data[0] = id;
542     tag->data[1] = id>>8;
543 }
544
545 char is_sprite_tag (int id)
546 {
547     int t=0;
548     while(spritetagids[t]>=0)
549     {
550         if(spritetagids[t] == id) 
551             return 1;
552         t++;
553     }
554     return 0; 
555 }
556
557 char is_defining_tag (int id)
558 {
559     int t=0;
560     while(definingtagids[t]>=0)
561     {
562         if(definingtagids[t] == id) 
563             return 1;
564         t++;
565     }
566     return 0; 
567 }
568
569 struct swf_tag* duptag(struct swf_tag*tag)
570 {
571     struct swf_tag* newtag = (struct swf_tag*)malloc(sizeof(struct swf_tag));
572     newtag->id = tag->id;
573     newtag->fulldata = (u8*)malloc(tag->fulllength);
574     newtag->fulllength = tag->fulllength;
575     newtag->data = newtag->fulldata + (tag->data - tag->fulldata);
576     newtag->length = tag->length;
577     memcpy(newtag->fulldata, tag->fulldata, tag->fulllength);
578     return newtag;
579 }
580