14ec250bccbe682c88a9ae0f5a86c41fcea44200
[swftools.git] / lib / rfxswf.c
1 /* vi: set sts=2 sw=2 :*/
2 /* rfxswf.c 
3
4    Library for creating and reading SWF files or parts of it.
5    There's a module directory which provides some extended functionality.
6    Most modules are included at the bottom of this file.
7
8    Part of the swftools package.
9
10    Copyright (c) 2000-2003 Rainer Böhme <rfxswf@reflex-studio.de>
11    Copyright (c) 2003 Matthias Kramm <kramm@quiss.org> 
12
13    This program is free software; you can redistribute it and/or modify
14    it under the terms of the GNU General Public License as published by
15    the Free Software Foundation; either version 2 of the License, or
16    (at your option) any later version.
17
18    This program is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21    GNU General Public License for more details.
22
23    You should have received a copy of the GNU General Public License
24    along with this program; if not, write to the Free Software
25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
26
27 #include "rfxswf.h"
28
29 #ifdef HAVE_JPEGLIB
30 #define HAVE_BOOLEAN
31 #include <jpeglib.h>
32 #endif // HAVE_JPEGLIB
33
34 #ifdef HAVE_ZLIB
35 #include <zlib.h>
36 #endif // HAVE_ZLIB
37
38 #ifndef RFXSWF_DISABLESOUND
39 #ifdef HAVE_LAME
40 #include "lame/lame.h"
41 #endif
42 #endif
43
44 #ifdef HAVE_TIME_H
45 #include <time.h>
46 #endif
47
48 #include "./bitio.h"
49 #include "./MD5.h"
50
51 // internal constants
52
53 #define MALLOC_SIZE     128
54 #define INSERT_RFX_TAG
55
56 #define MEMSIZE(l) (((l/MALLOC_SIZE)+1)*MALLOC_SIZE)
57
58
59 // inline wrapper functions
60
61 TAG * swf_NextTag(TAG * t) { return t->next; }
62 TAG * swf_PrevTag(TAG * t) { return t->prev; }
63 U16   swf_GetTagID(TAG * t)    { return t->id; }
64 U32   swf_GetTagLen(TAG * t) { return t->len; }
65 U8*   swf_GetTagLenPtr(TAG * t) { return &(t->data[t->len]); }
66 U32   swf_GetTagPos(TAG * t)   { return t->pos; }
67
68 // Basic Data Access Functions
69
70 #define swf_ResetReadBits(tag)   if (tag->readBit)  { tag->pos++; tag->readBit = 0; }
71 #define swf_ResetWriteBits(tag)  if (tag->writeBit) { tag->writeBit = 0; }
72
73 // for future purpose: avoid high level lib functions to change tagpos/bitpos
74
75 #define swf_SaveTagPos(tag)
76 #define swf_RestoreTagPos(tag)
77
78 void swf_SetTagPos(TAG * t,U32 pos)
79 { swf_ResetReadBits(t);
80   if (pos<=t->len) t->pos = pos;
81   #ifdef DEBUG_RFXSWF
82   else fprintf(stderr,"SetTagPos() out of bounds: TagID = %i\n",t->id);
83   #endif
84 }
85
86 char* swf_GetString(TAG*t)
87 {
88     char* str = ((char*)(&(t)->data[(t)->pos]));
89     while(swf_GetU8(t));
90     return str;
91 }
92
93 U8 swf_GetU8(TAG * t)
94 { swf_ResetReadBits(t);
95   #ifdef DEBUG_RFXSWF
96     if (t->pos>=t->len) 
97     { fprintf(stderr,"GetU8() out of bounds: TagID = %i\n",t->id);
98       return 0;
99     }
100   #endif
101   return t->data[t->pos++];
102 }
103
104 U16 swf_GetU16(TAG * t)
105 { U16 res;
106   swf_ResetReadBits(t);
107   #ifdef DEBUG_RFXSWF
108     if (t->pos>(t->len-2)) 
109     { fprintf(stderr,"GetU16() out of bounds: TagID = %i\n",t->id);
110       return 0;
111     }
112   #endif
113   res = t->data[t->pos] | (t->data[t->pos+1]<<8);
114   t->pos+=2;
115   return res;
116 }
117
118 U32 swf_GetU32(TAG * t)
119 { U32 res;
120   swf_ResetReadBits(t);
121   #ifdef DEBUG_RFXSWF
122     if (t->pos>(t->len-4)) 
123     { fprintf(stderr,"GetU32() out of bounds: TagID = %i\n",t->id);
124       return 0;
125     }
126   #endif
127   res = t->data[t->pos]        | (t->data[t->pos+1]<<8) | 
128        (t->data[t->pos+2]<<16) | (t->data[t->pos+3]<<24);
129   t->pos+=4;
130   return res;
131 }
132
133 int swf_GetBlock(TAG * t,U8 * b,int l)
134 // returns number of bytes written (<=l)
135 // b = NULL -> skip data
136 { swf_ResetReadBits(t);
137   if ((t->len-t->pos)<l) l=t->len-t->pos;
138   if (b && l) memcpy(b,&t->data[t->pos],l);
139   t->pos+=l;
140   return l;
141 }
142
143 int swf_SetBlock(TAG * t,U8 * b,int l)
144 // Appends Block to the end of Tagdata, returns size
145 { U32 newlen = t->len + l;
146   swf_ResetWriteBits(t);
147   if (newlen>t->memsize)
148   { U32  newmem  = MEMSIZE(newlen);  
149     U8 * newdata = (U8*)((t->data)?realloc(t->data,newmem):malloc(newmem));
150     if (!newdata)
151     {
152       #ifdef DEBUG_RFXSWF
153         fprintf(stderr,"Fatal Error: malloc()/realloc() failed (1). (%d bytes)\n", newmem);
154         *(int*)0=0;
155       #endif
156       return 0;
157     }
158     t->memsize = newmem;
159     t->data    = newdata;
160   }
161   if (b) memcpy(&t->data[t->len],b,l);
162   else memset(&t->data[t->len],0x00,l);
163   t->len+=l;
164   return l;
165 }
166
167 int swf_SetU8(TAG * t,U8 v)
168 { swf_ResetWriteBits(t);
169   if ((t->len+1)>t->memsize) return (swf_SetBlock(t,&v,1)==1)?0:-1;
170   t->data[t->len++] = v;
171   return 0;
172 }
173
174 int swf_SetU16(TAG * t,U16 v)
175 { U8 a[2];
176   a[0] = v&0xff;
177   a[1] = v>>8;
178   
179   swf_ResetWriteBits(t);
180   if ((t->len+2)>t->memsize) return (swf_SetBlock(t,a,2)==2)?0:-1;
181   t->data[t->len++] = a[0];
182   t->data[t->len++] = a[1];
183   return 0;
184 }
185
186 int swf_SetU32(TAG * t,U32 v)
187 { U8 a[4];
188   a[0] = v&0xff;        // to ensure correct handling of non-intel byteorder
189   a[1] = (v>>8)&0xff;
190   a[2] = (v>>16)&0xff;
191   a[3] = (v>>24)&0xff;
192   
193   swf_ResetWriteBits(t);
194   if ((t->len+4)>t->memsize) return (swf_SetBlock(t,a,4)==4)?0:-1;
195   t->data[t->len++] = a[0];
196   t->data[t->len++] = a[1];
197   t->data[t->len++] = a[2];
198   t->data[t->len++] = a[3];
199   return 0;
200 }
201
202 U32 swf_GetBits(TAG * t,int nbits)
203 { U32 res = 0;
204   if (!nbits) return 0;
205   if (!t->readBit) t->readBit = 0x80;
206   while (nbits)
207   { res<<=1;
208     if (t->data[t->pos]&t->readBit) res|=1;
209     t->readBit>>=1;
210     nbits--;
211     if (!t->readBit)
212     { if (nbits) t->readBit = 0x80;
213       #ifdef DEBUG_RFXSWF
214       if (t->pos>=t->len) 
215       { fprintf(stderr,"GetBits() out of bounds: TagID = %i\n",t->id);
216         return res;
217       }
218       #endif
219       t->pos++;
220     }
221   }
222   return res;
223 }
224
225 S32 swf_GetSBits(TAG * t,int nbits)
226 { U32 res = swf_GetBits(t,nbits);
227   if (res&(1<<(nbits-1))) res|=(0xffffffff<<nbits);  
228   return (S32)res;
229 }
230
231 U32 reader_GetBits(struct reader_t*reader, int nbits)
232 { return reader_readbits(reader, nbits);
233 }
234 S32 reader_GetSBits(struct reader_t*reader, int nbits)
235 { U32 res = reader_readbits(reader, nbits);
236   if (res&(1<<(nbits-1))) res|=(0xffffffff<<nbits);  
237   return (S32)res;
238 }
239
240 int swf_SetBits(TAG * t,U32 v,int nbits)
241 { U32 bm = 1<<(nbits-1);
242
243   while (nbits)
244   { if (!t->writeBit)
245     { if (FAILED(swf_SetU8(t,0))) return -1;
246       t->writeBit = 0x80;
247     }
248     if (v&bm) t->data[t->len-1] |= t->writeBit;
249     bm>>=1;
250     t->writeBit>>=1;
251     nbits--;
252   }
253   return 0;
254 }
255
256 // Advanced Data Access Functions
257
258 int swf_SetRGB(TAG * t,RGBA * col)
259 { if (!t) return -1;
260   if (col)
261   { swf_SetU8(t,col->r);
262     swf_SetU8(t,col->g);
263     swf_SetU8(t,col->b);
264   } else swf_SetBlock(t,NULL,3);
265   return 0;
266 }
267 void swf_GetRGB(TAG * t, RGBA * col)
268 {
269     RGBA dummy;
270     if(!col)
271         col = &dummy;
272     col->r = swf_GetU8(t);
273     col->g = swf_GetU8(t);
274     col->b = swf_GetU8(t);
275     col->a = 255;
276 }
277
278 int swf_SetRGBA(TAG * t,RGBA * col)
279 { if (!t) return -1;
280   if (col)
281   { swf_SetU8(t,col->r);
282     swf_SetU8(t,col->g);
283     swf_SetU8(t,col->b);
284     swf_SetU8(t,col->a);
285   } else swf_SetBlock(t,NULL,4);
286   return 0;
287 }
288 void swf_GetRGBA(TAG * t, RGBA * col)
289 {
290     RGBA dummy;
291     if(!col);
292         col = &dummy;
293     col->r = swf_GetU8(t);
294     col->g = swf_GetU8(t);
295     col->b = swf_GetU8(t);
296     col->a = swf_GetU8(t);
297 }
298
299 void swf_GetGradient(TAG * tag, GRADIENT * gradient, char alpha)
300 {
301     GRADIENT dummy;
302     int t;
303     if(!tag) {
304       memset(gradient, 0, sizeof(GRADIENT));
305       return;
306     }
307     if(!gradient)
308         gradient = &dummy;
309     gradient->num = swf_GetU8(tag);
310     for(t=0;t<gradient->num;t++)
311     {
312         int s=t;
313         if(s>=8) //FIXME
314             s=7;
315         gradient->ratios[t] = swf_GetU8(tag);
316         if(!alpha)
317             swf_GetRGB(tag, &gradient->rgba[t]);
318         else
319             swf_GetRGBA(tag, &gradient->rgba[t]);
320     }
321 }
322
323 void swf_SetGradient(TAG * tag, GRADIENT * gradient, char alpha)
324 {
325     int t;
326     if(!tag) {
327       memset(gradient, 0, sizeof(GRADIENT));
328       return;
329     }
330     swf_SetU8(tag, gradient->num);
331     for(t=0; t<8 && t<gradient->num; t++)
332     {
333         swf_SetU8(tag, gradient->ratios[t]);
334         if(!alpha)
335             swf_SetRGB(tag, &gradient->rgba[t]);
336         else
337             swf_SetRGBA(tag, &gradient->rgba[t]);
338     }
339 }
340
341 int swf_CountUBits(U32 v,int nbits)
342 { int n = 32;
343   U32 m = 0x80000000;
344   if(v == 0x00000000) n = 0; 
345   else
346     while (!(v&m))
347     { n--;
348       m>>=1;
349     } 
350   return (n>nbits)?n:nbits;
351 }
352
353 int swf_CountBits(U32 v,int nbits)
354 { int n = 33;
355   U32 m = 0x80000000;
356   if (v&m)
357   { if(v == 0xffffffff) n = 1;
358     else 
359     while (v&m)
360     { n--;
361       m>>=1;
362     } 
363   }
364   else
365   { if(v == 0x00000000) n = 0; 
366     else
367     while (!(v&m))
368     { n--;
369       m>>=1;
370     } 
371   }
372   return (n>nbits)?n:nbits;
373 }
374
375 int swf_GetRect(TAG * t,SRECT * r)
376 { int nbits;
377   SRECT dummy;
378   if(!t) {r->xmin=r->xmax=r->ymin=r->ymax=0;return 0;}
379   if (!r) r = &dummy;
380   nbits = (int) swf_GetBits(t,5);
381   r->xmin = swf_GetSBits(t,nbits);
382   r->xmax = swf_GetSBits(t,nbits);
383   r->ymin = swf_GetSBits(t,nbits);
384   r->ymax = swf_GetSBits(t,nbits);
385   return 0;
386 }
387
388 int reader_GetRect(struct reader_t*reader,SRECT * r)
389 { int nbits;
390   SRECT dummy;
391   if (!r) r = &dummy;
392   nbits = (int) reader_GetBits(reader,5);
393   r->xmin = reader_GetSBits(reader,nbits);
394   r->xmax = reader_GetSBits(reader,nbits);
395   r->ymin = reader_GetSBits(reader,nbits);
396   r->ymax = reader_GetSBits(reader,nbits);
397   return 0;
398 }
399
400 int swf_SetRect(TAG * t,SRECT * r)
401 { int nbits;
402     
403   nbits = swf_CountBits(r->xmin,0);
404   nbits = swf_CountBits(r->xmax,nbits);
405   nbits = swf_CountBits(r->ymin,nbits);
406   nbits = swf_CountBits(r->ymax,nbits);
407   if(nbits>=32) {
408     fprintf(stderr, "rfxswf: Warning: num_bits overflow in swf_SetRect\n");
409     nbits=31;
410   }
411
412   swf_SetBits(t,nbits,5);
413   swf_SetBits(t,r->xmin,nbits);
414   swf_SetBits(t,r->xmax,nbits);
415   swf_SetBits(t,r->ymin,nbits);
416   swf_SetBits(t,r->ymax,nbits);
417
418   return 0;
419 }
420
421 void swf_ExpandRect(SRECT*src, SPOINT add)
422 {
423     if(add.x < src->xmin)
424         src->xmin = add.x;
425     if(add.x > src->xmax)
426         src->xmax = add.x;
427     if(add.y < src->ymin)
428         src->ymin = add.y;
429     if(add.y > src->ymax)
430         src->ymax = add.y;
431 }
432 void swf_ExpandRect2(SRECT*src, SRECT*add)
433 {
434     if((add->xmin | add->ymin | add->xmax | add->ymax)==0)
435         return;
436     if(add->xmin < src->xmin)
437         src->xmin = add->xmin;
438     if(add->ymin < src->ymin)
439         src->ymin = add->ymin;
440     if(add->xmax > src->xmax)
441         src->xmax = add->xmax;
442     if(add->ymax > src->ymax)
443         src->ymax = add->ymax;
444 }
445 SPOINT swf_TurnPoint(SPOINT p, MATRIX* m)
446 {
447     SPOINT r;
448     r.x = (int)(m->sx*(1/65536.0)*p.x + m->r1*(1/65536.0)*p.y + 0.5) + m->tx;
449     r.y = (int)(m->r0*(1/65536.0)*p.x + m->sy*(1/65536.0)*p.y + 0.5) + m->ty;
450     return r;
451 }
452 SRECT swf_TurnRect(SRECT r, MATRIX* m)
453 {
454     SRECT g;
455     SPOINT p1,p2,p3,p4,pp1,pp2,pp3,pp4;
456     p1.x = r.xmin;p1.y = r.ymin;
457     p2.x = r.xmax;p2.y = r.ymin;
458     p3.x = r.xmin;p3.y = r.ymax;
459     p4.x = r.xmax;p4.y = r.ymax;
460     pp1 = swf_TurnPoint(p1, m);
461     pp2 = swf_TurnPoint(p2, m);
462     pp3 = swf_TurnPoint(p3, m);
463     pp4 = swf_TurnPoint(p4, m);
464     g.xmin = g.xmax = pp1.x;
465     g.ymin = g.ymax = pp1.y;
466     swf_ExpandRect(&g, pp2);
467     swf_ExpandRect(&g, pp3);
468     swf_ExpandRect(&g, pp4);
469     return g;
470 }
471         
472
473 int swf_GetMatrix(TAG * t,MATRIX * m)
474 { MATRIX dummy;
475   int nbits;
476     
477   if (!m) m = &dummy;
478   
479   if (!t)
480   { m->sx = m->sy = 0x10000;
481     m->r0 = m->r1 = 0;
482     m->tx = m->ty = 0;
483     return -1;
484   }
485
486   swf_ResetReadBits(t);
487   
488   if (swf_GetBits(t,1))
489   { nbits = swf_GetBits(t,5);
490     m->sx = swf_GetSBits(t,nbits);
491     m->sy = swf_GetSBits(t,nbits);
492   }
493   else m->sx = m->sy = 0x10000;
494   
495   if (swf_GetBits(t,1))
496   { nbits = swf_GetBits(t,5);
497     m->r0 = swf_GetSBits(t,nbits);
498     m->r1 = swf_GetSBits(t,nbits);
499   }
500   else m->r0 = m->r1 = 0x0;
501
502   nbits = swf_GetBits(t,5);
503   m->tx = swf_GetSBits(t,nbits);
504   m->ty = swf_GetSBits(t,nbits);
505   
506   return 0;
507 }
508
509 int swf_SetMatrix(TAG * t,MATRIX * m)
510 { int nbits;
511   MATRIX ma;
512
513   if (!m)
514   { m = &ma;
515     ma.sx = ma.sy = 0x10000;
516     ma.r0 = ma.r1 = 0;
517     ma.tx = ma.ty = 0;
518   }
519
520   swf_ResetWriteBits(t);
521
522   if ((m->sx==0x10000)&&(m->sy==0x10000)) swf_SetBits(t,0,1);
523   else
524   { swf_SetBits(t,1,1);
525     nbits = swf_CountBits(m->sx,0);
526     nbits = swf_CountBits(m->sy,nbits);
527     if(nbits>=32) {
528         fprintf(stderr,"rfxswf: Error: matrix values too large\n");
529         nbits = 31;
530     }
531     swf_SetBits(t,nbits,5);
532     swf_SetBits(t,m->sx,nbits);
533     swf_SetBits(t,m->sy,nbits);
534   }
535
536   if ((!m->r0)&&(!m->r1)) swf_SetBits(t,0,1);
537   else
538   { swf_SetBits(t,1,1);
539     nbits = swf_CountBits(m->r0,0);
540     nbits = swf_CountBits(m->r1,nbits);
541     if(nbits>=32) {
542         fprintf(stderr,"rfxswf: Error: matrix values too large\n");
543         nbits = 31;
544     }
545     swf_SetBits(t,nbits,5);
546     swf_SetBits(t,m->r0,nbits);
547     swf_SetBits(t,m->r1,nbits);
548   }
549
550   nbits = swf_CountBits(m->tx,0);
551   nbits = swf_CountBits(m->ty,nbits);
552   if(nbits>=32) {
553       fprintf(stderr,"rfxswf: Error: matrix values too large\n");
554       nbits = 31;
555   }
556   swf_SetBits(t,nbits,5);
557   swf_SetBits(t,m->tx,nbits);
558   swf_SetBits(t,m->ty,nbits);
559
560   return 0;
561 }
562
563 int swf_GetCXForm(TAG * t,CXFORM * cx,U8 alpha) //FIXME: alpha should be type bool
564 { CXFORM cxf;
565   int hasadd;
566   int hasmul;
567   int nbits;
568     
569   if (!cx) cx = &cxf;
570   
571   cx->a0 = cx->r0 = cx->g0 = cx->b0 = 256;
572   cx->a1 = cx->r1 = cx->g1 = cx->b1 = 0;
573
574   if (!t) return 0;
575   
576   swf_ResetReadBits(t);
577   hasadd = swf_GetBits(t,1);
578   hasmul = swf_GetBits(t,1);
579   nbits  = swf_GetBits(t,4);
580
581   if (hasmul)
582   { cx->r0 = (S16)swf_GetSBits(t,nbits);
583     cx->g0 = (S16)swf_GetSBits(t,nbits);
584     cx->b0 = (S16)swf_GetSBits(t,nbits);
585     if (alpha)
586       cx->a0 = (S16)swf_GetSBits(t,nbits);
587   }
588
589   if (hasadd)
590   { cx->r1 = (S16)swf_GetSBits(t,nbits);
591     cx->g1 = (S16)swf_GetSBits(t,nbits);
592     cx->b1 = (S16)swf_GetSBits(t,nbits);
593     if (alpha)
594       cx->a1 = (S16)swf_GetSBits(t,nbits);
595   }
596   
597   return 0;
598 }
599
600 int swf_SetCXForm(TAG * t,CXFORM * cx,U8 alpha)
601 { CXFORM cxf;
602   int hasadd;
603   int hasmul;
604   int nbits;
605     
606   if (!cx)
607   { cx = &cxf;
608     cx->a0 = cx->r0 = cx->g0 = cx->b0 = 256;
609     cx->a1 = cx->r1 = cx->g1 = cx->b1 = 0;
610   }
611
612   if (!alpha)
613   { cx->a0 = 256;
614     cx->a1 = 0;
615   }
616
617   nbits = 0;
618
619   hasmul = (cx->a0!=256)||(cx->r0!=256)||(cx->g0!=256)||(cx->b0!=256);
620   hasadd = cx->a1|cx->r1|cx->g1|cx->b1;
621
622   if (hasmul)
623   { if (alpha) nbits = swf_CountBits((S32)cx->a0,nbits);
624     nbits = swf_CountBits((S32)cx->r0,nbits);
625     nbits = swf_CountBits((S32)cx->g0,nbits);
626     nbits = swf_CountBits((S32)cx->b0,nbits);
627   }
628
629   if (hasadd)
630   { if (alpha) nbits = swf_CountBits((S32)cx->a1,nbits);
631     nbits = swf_CountBits((S32)cx->r1,nbits);
632     nbits = swf_CountBits((S32)cx->g1,nbits);
633     nbits = swf_CountBits((S32)cx->b1,nbits);
634   }
635   
636   swf_ResetWriteBits(t);
637   swf_SetBits(t,hasadd?1:0,1);
638   swf_SetBits(t,hasmul?1:0,1);
639   swf_SetBits(t,nbits,4);
640
641   if (hasmul)
642   { swf_SetBits(t,cx->r0,nbits);
643     swf_SetBits(t,cx->g0,nbits);
644     swf_SetBits(t,cx->b0,nbits);
645     if (alpha) swf_SetBits(t,cx->a0,nbits);
646   }
647
648   if (hasadd)
649   { swf_SetBits(t,cx->r1,nbits);
650     swf_SetBits(t,cx->g1,nbits);
651     swf_SetBits(t,cx->b1,nbits);
652     if (alpha) swf_SetBits(t,cx->a1,nbits);
653   }
654   
655   return 0;
656 }
657
658 //int swf_GetPoint(TAG * t,SPOINT * p) { return 0; }
659 //int swf_SetPoint(TAG * t,SPOINT * p) { return 0; }
660
661 void  swf_SetPassword(TAG * t, const char * password)
662 {
663     /* WARNING: crypt_md5 is not reentrant */
664     char salt[3];
665     char* md5string;
666
667 #if defined(HAVE_LRAND48) && defined(HAVE_SRAND48) && defined(HAVE_TIME_H) && defined(HAVE_TIME)
668     srand48(time(0));
669     salt[0] = "abcdefghijklmnopqrstuvwxyz0123456789"[lrand48()%36];
670     salt[1] = "abcdefghijklmnopqrstuvwxyz0123456789"[lrand48()%36];
671 #else
672     salt[0] = 'l';
673     salt[1] = '8';
674     fprintf(stderr, "rfxswf: Warning- no usable random generator found\n");
675     fprintf(stderr, "Your password will be vulnerable to dictionary attacks\n");
676 #endif
677     
678     md5string = crypt_md5(password, salt);
679
680     swf_SetU16(t,0);
681     swf_SetString(t, md5string);
682 }
683
684 int swf_VerifyPassword(TAG * t, const char * password)
685 {
686     char*md5string1, *md5string2;
687     char*x;
688     char*md5, *salt;
689     int n;
690
691     if(t->len >= 5 && t->pos==0 && 
692        t->data[0] == 0 &&
693        t->data[1] == 0) {
694       swf_GetU16(t);
695     } else {
696       printf("%d %d %d %d\n", t->len, t->pos, t->data[0], t->data[1]);
697     }
698
699     md5string1 = swf_GetString(t);
700
701     if(strncmp(md5string1, "$1$",3 )) {
702         fprintf(stderr, "rfxswf: no salt in pw string\n");
703         return 0;
704     }
705     x = strchr(md5string1+3, '$');
706     if(!x) {
707         fprintf(stderr, "rfxswf: invalid salt format in pw string\n");
708         return 0;
709     }
710     n = x-(md5string1+3);
711     salt = (char*)malloc(n+1);
712     memcpy(salt, md5string1+3, n);
713     salt[n] = 0;
714
715     md5string2 = crypt_md5(password, salt);
716     free(salt);
717     if(strcmp(md5string1, md5string2) != 0)
718         return 0;
719     return 1;
720 }
721
722 // Tag List Manipulating Functions
723
724 TAG * swf_InsertTag(TAG * after,U16 id)
725 { TAG * t;
726
727   t = (TAG *)malloc(sizeof(TAG));
728   if (t)
729   { memset(t,0x00,sizeof(TAG));
730     t->id = id;
731     
732     if (after)
733     {
734       t->prev  = after;
735       t->next  = after->next;
736       after->next = t;
737       if (t->next) t->next->prev = t;
738     }
739   }
740   return t;
741 }
742
743 TAG * swf_InsertTagBefore(SWF* swf, TAG * before,U16 id)
744 { TAG * t;
745
746   t = (TAG *)malloc(sizeof(TAG));
747   if (t)
748   { memset(t,0x00,sizeof(TAG));
749     t->id = id;
750     
751     if (before)
752     {
753       t->next  = before;
754       t->prev  = before->prev;
755       before->prev = t;
756       if (t->prev) t->prev->next = t;
757     }
758   }
759   if(swf && swf->firstTag == before) {
760     swf->firstTag = t;
761   }
762   return t;
763 }
764
765 void swf_ClearTag(TAG * t)
766 {
767   if (t->data) free(t->data);
768   t->data = 0;
769   t->pos = 0;
770   t->len = 0;
771   t->readBit = 0;
772   t->writeBit = 0;
773   t->memsize = 0;
774 }
775
776 void swf_ResetTag(TAG*tag, U16 id)
777 {
778     tag->len = tag->pos = tag->readBit = tag->writeBit = 0;
779     tag->id = id;
780 }
781
782 int swf_DeleteTag(TAG * t)
783 { if (!t) return -1;
784
785   if (t->prev) t->prev->next = t->next;
786   if (t->next) t->next->prev = t->prev;
787
788   if (t->data) free(t->data);
789   free(t);
790   return 0;
791 }
792
793 TAG * swf_ReadTag(struct reader_t*reader, TAG * prev)
794 { TAG * t;
795   U16 raw;
796   U32 len;
797   int id;
798
799   if (reader->read(reader, &raw, 2) !=2 ) return NULL;
800   raw = SWAP16(raw);
801
802   len = raw&0x3f;
803   id  = raw>>6;
804
805   if (len==0x3f)
806   {
807       if (reader->read(reader, &len, 4) != 4) return NULL;
808       len = SWAP32(len);
809   }
810
811   if (id==ST_DEFINESPRITE) len = 2*sizeof(U16);
812   // Sprite handling fix: Flatten sprite tree
813
814   t = (TAG *)malloc(sizeof(TAG));
815   
816   if (!t)
817   {
818     #ifdef DEBUG_RFXSWF
819       fprintf(stderr,"Fatal Error: malloc()/realloc() failed (2). (%d bytes)\n", sizeof(TAG));
820     #endif
821     return NULL;
822   }
823
824   memset(t,0x00,sizeof(TAG));
825   
826   t->len = len;
827   t->id  = id;
828
829   if (t->len)
830   { t->data = (U8*)malloc(t->len);
831     if (!t->data)
832     {
833       #ifdef DEBUG_RFXSWF
834         fprintf(stderr,"Fatal Error: malloc()/realloc() failed (3). (%d bytes)\n", t->len);
835       #endif
836       return NULL;
837     }
838     t->memsize = t->len;
839     if (reader->read(reader, t->data, t->len) != t->len) return NULL;
840   }
841
842   if (prev)
843   {
844     t->prev  = prev;
845     prev->next = t;
846   }
847
848   return t;
849 }
850
851 int swf_DefineSprite_GetRealSize(TAG * t);
852
853 int swf_WriteTag2(struct writer_t*writer, TAG * t)
854 // returns tag length in bytes (incl. Header), -1 = Error
855 // writer = 0 -> no output
856 { U16 raw[3];
857   U32 len;
858   int short_tag;
859
860   if (!t) return -1;
861
862   len = (t->id==ST_DEFINESPRITE)?swf_DefineSprite_GetRealSize(t):t->len;
863
864   short_tag = len<0x3f;
865
866   if (writer)
867   { if (short_tag)
868     { raw[0] = SWAP16(len|((t->id&0x3ff)<<6));
869       if (writer->write(writer,raw,2)!=2)
870       {
871         #ifdef DEBUG_RFXSWF
872           fprintf(stderr,"WriteTag() failed: Short Header.\n");
873         #endif
874         return -1;
875       }
876     }
877     else
878     {
879       raw[0] = SWAP16((t->id<<6)|0x3f);
880       if (writer->write(writer,raw,2)!=2)
881       {
882 #ifdef DEBUG_RFXSWF
883           fprintf(stderr,"WriteTag() failed: Long Header (1).\n");
884 #endif
885           return -1;
886       }
887       
888       len = SWAP32(len);
889       if (writer->write(writer,&len,4)!=4)
890       {
891         #ifdef DEBUG_RFXSWF
892           fprintf(stderr,"WriteTag() failed: Long Header (2).\n");
893         #endif
894         return -1;
895       }
896     }
897     
898     if (t->data)
899     { if (writer->write(writer,t->data,t->len)!=t->len)
900       {
901         #ifdef DEBUG_RFXSWF
902           fprintf(stderr,"WriteTag() failed: Data.\n");
903         #endif
904         return -1;
905       }
906     }
907     #ifdef DEBUG_RFXSWF
908       else if (t->len) fprintf(stderr,"WriteTag(): Tag Data Error, id=%i\n",t->id);
909     #endif
910   }
911
912   return t->len+(short_tag?2:6);
913 }
914
915 int swf_WriteTag(int handle, TAG * t)
916 {
917   struct writer_t writer;
918   if(handle<0)
919     return swf_WriteTag2(0, t);
920   writer_init_filewriter(&writer, handle);
921   return swf_WriteTag2(&writer, t);
922 }
923
924 int swf_DefineSprite_GetRealSize(TAG * t)
925 // Sprite Handling: Helper function to pack DefineSprite-Tag
926 { U32 len = t->len;
927   if(len>4) { // folded sprite
928       return t->len;
929   }
930   do
931   { t = swf_NextTag(t);
932     if (t && t->id!=ST_DEFINESPRITE) len += swf_WriteTag(-1, t);
933     else t = NULL;
934   } while (t&&(t->id!=ST_END));
935   return len;
936 }
937
938 void swf_UnFoldSprite(TAG * t)
939 {
940   U16 id,tmp;
941   U32 len;
942   TAG*next = t;
943   U16 spriteid,spriteframes;
944   int level;
945   if(t->id!=ST_DEFINESPRITE)
946     return;
947   if(t->len<=4) // not folded
948     return;
949
950   swf_SetTagPos(t,0);
951
952   spriteid = swf_GetU16(t); //id
953   spriteframes = swf_GetU16(t); //frames
954
955   level = 1;
956
957   while(1)
958   {
959     TAG*it = 0;
960     tmp = swf_GetU16(t);
961     len = tmp&0x3f;
962     id  = tmp>>6;
963     if(id == ST_END)
964         level--;
965     if(id == ST_DEFINESPRITE && len<=4)
966         level++;
967
968     if (len==0x3f)
969         len = swf_GetU32(t);
970     it = swf_InsertTag(next, id);
971     next = it;
972     it->len = len;
973     it->id  = id;
974     if (it->len)
975     { it->data = (U8*)malloc(it->len);
976       it->memsize = it->len;
977       swf_GetBlock(t, it->data, it->len);
978     }
979
980     if(!level)
981         break;
982   }
983   
984   free(t->data); t->data = 0;
985   t->memsize = t->len = t->pos = 0;
986
987   swf_SetU16(t, spriteid);
988   swf_SetU16(t, spriteframes);
989 }
990
991 void swf_FoldSprite(TAG * t)
992 {
993   TAG*sprtag=t,*tmp;
994   U16 id,frames,tmpid;
995   int level;
996   if(t->id!=ST_DEFINESPRITE)
997       return;
998   if(!t->len) {
999       fprintf(stderr, "Error: Sprite has no ID!");
1000       return;
1001   }
1002   if(t->len>4) {
1003     /* sprite is already folded */
1004       return;
1005   }
1006
1007   t->pos = 0;
1008   id = swf_GetU16(t);
1009   free(t->data);
1010   t->len = t->pos = t->memsize = 0;
1011   t->data = 0;
1012
1013   frames = 0;
1014
1015   t = swf_NextTag(sprtag);
1016   level = 1;
1017
1018   do 
1019   { 
1020     if(t->id==ST_SHOWFRAME) frames++;
1021     if(t->id == ST_DEFINESPRITE && t->len<=4)
1022         level++;
1023     if(t->id == ST_END)
1024         level--;
1025     t = swf_NextTag(t);
1026   } while(t && level);
1027   if(level)
1028     fprintf(stderr, "rfxswf error: sprite doesn't end(1)\n");
1029
1030   swf_SetU16(sprtag, id);
1031   swf_SetU16(sprtag, frames);
1032
1033   t = swf_NextTag(sprtag);
1034   level = 1;
1035
1036   do
1037   { 
1038     if(t->len<0x3f) {
1039         swf_SetU16(sprtag,t->len|(t->id<<6));
1040     } else {
1041         swf_SetU16(sprtag,0x3f|(t->id<<6));
1042         swf_SetU32(sprtag,t->len);
1043     }
1044     if(t->len)
1045         swf_SetBlock(sprtag,t->data, t->len);
1046     tmp = t;
1047     if(t->id == ST_DEFINESPRITE && t->len<=4)
1048         level++;
1049     if(t->id == ST_END)
1050         level--;
1051     t = swf_NextTag(t);
1052     swf_DeleteTag(tmp);
1053   } 
1054   while (t && level);
1055   if(level)
1056     fprintf(stderr, "rfxswf error: sprite doesn't end(2)\n");
1057
1058 //  sprtag->next = t;
1059 //  t->prev = sprtag;
1060 }
1061
1062 int swf_IsFolded(TAG * t)
1063 {
1064     return (t->id == ST_DEFINESPRITE && t->len>4);
1065 }
1066
1067 void swf_FoldAll(SWF*swf)
1068 {
1069     TAG*tag = swf->firstTag;
1070     //swf_DumpSWF(stdout, swf);
1071     while(tag) {
1072         if(tag->id == ST_DEFINESPRITE) {
1073             swf_FoldSprite(tag);
1074             //swf_DumpSWF(stdout, swf);
1075         }
1076         tag = swf_NextTag(tag);
1077     }
1078 }
1079
1080 void swf_FoldAllTags(TAG*tag)
1081 {
1082     SWF swf;
1083     memset(&swf, 0, sizeof(swf));
1084     swf.firstTag = tag;
1085     swf_FoldAll(&swf);
1086 }
1087
1088 void swf_UnFoldAll(SWF*swf)
1089 {
1090     TAG*tag = swf->firstTag;
1091     while(tag) {
1092         if(tag->id == ST_DEFINESPRITE)
1093             swf_UnFoldSprite(tag);
1094         tag = tag->next;
1095     }
1096 }
1097
1098 void swf_OptimizeTagOrder(SWF*swf)
1099 {
1100   TAG*tag,*next;
1101   TAG*level0;
1102   int level;
1103   int changes;
1104   swf_UnFoldAll(swf);
1105   /* at the moment, we don't actually do optimizing,
1106      only fixing of non-spec-conformant things like
1107      sprite tags */
1108
1109   do {
1110     changes = 0;
1111     level = 0;
1112     level0 = 0;
1113     tag = swf->firstTag;
1114     while(tag) {
1115       next = tag->next;
1116       if(tag->id == ST_DEFINESPRITE) {
1117         if(tag->len>4) {
1118           /* ??? all sprites are supposed to be unfolded */
1119           fprintf(stderr, "librfxswf error - internal error in OptimizeTagOrder/UnfoldAll\n");
1120         }
1121         level++;
1122         if(level==1) {
1123           level0 = tag;
1124           tag = next;
1125           continue;
1126         }
1127       }
1128       if(level>=1) {
1129         /* move non-sprite tags out of sprite */
1130         if(!swf_isAllowedSpriteTag(tag) || level>=2) {
1131           /* remove tag from current position */
1132           tag->prev->next = tag->next;
1133           if(tag->next)
1134             tag->next->prev = tag->prev;
1135
1136           /* insert before tag level0 */
1137           tag->next = level0;
1138           tag->prev = level0->prev;
1139           level0->prev = tag;
1140           tag->prev->next = tag;
1141           changes = 1;
1142         }
1143       }
1144       if(tag->id == ST_END) {
1145         level--;
1146       }
1147
1148       tag = next;
1149     }
1150   } while(changes);
1151 }
1152
1153 // Movie Functions
1154
1155 int swf_ReadSWF2(struct reader_t*reader, SWF * swf)   // Reads SWF to memory (malloc'ed), returns length or <0 if fails
1156 {     
1157   if (!swf) return -1;
1158   memset(swf,0x00,sizeof(SWF));
1159
1160   { char b[32];                         // read Header
1161     int len;
1162     TAG * t;
1163     TAG t1;
1164     struct reader_t zreader;
1165     
1166     if ((len = reader->read(reader ,b,8))<8) return -1;
1167
1168     if (b[0]!='F' && b[0]!='C') return -1;
1169     if (b[1]!='W') return -1;
1170     if (b[2]!='S') return -1;
1171     swf->fileVersion = b[3];
1172     swf->compressed  = (b[0]=='C')?1:0;
1173     swf->fileSize    = GET32(&b[4]);
1174     
1175     if(swf->compressed) {
1176         reader_init_zlibinflate(&zreader, reader);
1177         reader = &zreader;
1178     }
1179
1180     reader_GetRect(reader, &swf->movieSize);
1181     reader->read(reader, &swf->frameRate, 2);
1182     swf->frameRate = SWAP16(swf->frameRate);
1183     reader->read(reader, &swf->frameCount, 2);
1184     swf->frameCount = SWAP16(swf->frameCount);
1185
1186     /* read tags and connect to list */
1187     t = &t1;
1188     while (t) t = swf_ReadTag(reader,t);
1189     swf->firstTag = t1.next;
1190     t1.next->prev = NULL;
1191   }
1192   
1193   return reader->pos;
1194 }
1195
1196 int swf_ReadSWF(int handle, SWF * swf)
1197 {
1198   struct reader_t reader;
1199   reader_init_filereader(&reader, handle);
1200   return swf_ReadSWF2(&reader, swf);
1201 }
1202
1203 int  swf_WriteSWF2(struct writer_t*writer, SWF * swf)     // Writes SWF to file, returns length or <0 if fails
1204 { U32 len;
1205   TAG * t;
1206   int frameCount=0;
1207   struct writer_t zwriter;
1208   int fileSize = 0;
1209   int inSprite = 0;
1210     
1211   if (!swf) return -1;
1212
1213   // Insert REFLEX Tag
1214
1215 #ifdef INSERT_RFX_TAG
1216
1217   if (swf->firstTag && swf_NextTag(swf->firstTag))
1218     if (swf_GetTagID(swf_NextTag(swf->firstTag))!=ST_REFLEX)
1219       swf_SetBlock(swf_InsertTag(swf->firstTag,ST_REFLEX),"rfx",3);
1220
1221 #endif // INSERT_RFX_TAG
1222
1223   // Count Frames + File Size
1224
1225   len = 0;
1226   t = swf->firstTag;
1227   frameCount = 0;
1228
1229   while(t) {
1230       len += swf_WriteTag(-1,t);
1231       if(t->id == ST_DEFINESPRITE) inSprite++;
1232       else if(t->id == ST_END && inSprite) inSprite--;
1233       else if(t->id == ST_SHOWFRAME && !inSprite) frameCount++;
1234       t = swf_NextTag(t);
1235   }
1236   
1237   { TAG t1;
1238     char b[64],b4[4];
1239     U32 l;
1240
1241     memset(&t1,0x00,sizeof(TAG));
1242     t1.data    = (U8*)b;
1243     t1.memsize = 64;
1244     
1245     { // measure header file size
1246       TAG t2;
1247       char b2[64];
1248       memset(&t2,0x00,sizeof(TAG));
1249       t2.data    = (U8*)b2;
1250       t2.memsize = 64;
1251       swf_SetRect(&t2, &swf->movieSize);
1252       swf_SetU16(&t2, swf->frameRate);
1253       swf_SetU16(&t2, swf->frameCount);
1254       l = swf_GetTagLen(&t2)+8;
1255     }
1256     if(swf->compressed == 8) {
1257       l -= 8;
1258     }
1259
1260     fileSize = l+len;
1261     if(len) {// don't touch headers without tags
1262         swf->fileSize = fileSize;
1263         swf->frameCount = frameCount;
1264     }
1265
1266     if(swf->compressed != 8) {
1267     /* compressed flag set to 8 means "skip first 8 
1268        header bytes". This is necessary if the caller wants to
1269        create compressed SWFs himself */
1270       if(swf->compressed) {
1271         char*id = "CWS";
1272         writer->write(writer, id, 3);
1273       }
1274       else {
1275         char*id = "FWS";
1276         writer->write(writer, id, 3);
1277       }
1278
1279       writer->write(writer, &swf->fileVersion, 1);
1280       PUT32(b4, swf->fileSize);
1281       writer->write(writer, b4, 4);
1282       
1283       if(swf->compressed) {
1284         writer_init_zlibdeflate(&zwriter, writer);
1285         writer = &zwriter;
1286       }
1287     }
1288
1289     swf_SetRect(&t1,&swf->movieSize);
1290     swf_SetU16(&t1,swf->frameRate);
1291     swf_SetU16(&t1,swf->frameCount);
1292
1293     if (writer)
1294     { 
1295       int ret = writer->write(writer,b,swf_GetTagLen(&t1));
1296       if (ret!=swf_GetTagLen(&t1))
1297       {
1298         #ifdef DEBUG_RFXSWF
1299           fprintf(stderr, "ret:%d\n",ret);
1300           perror("write:");
1301           fprintf(stderr,"WriteSWF() failed: Header.\n");
1302         #endif
1303         return -1;
1304       }
1305
1306       t = swf->firstTag;
1307       while (t)
1308       { if (swf_WriteTag2(writer, t)<0) return -1;
1309         t = swf_NextTag(t);
1310       }
1311       if(swf->compressed != 8)
1312         writer->finish(writer); // flush zlib buffers - only if _we_ initialized that writer.
1313     }
1314   }
1315   return (int)fileSize;
1316 }
1317
1318 int  swf_WriteSWF(int handle, SWF * swf)     // Writes SWF to file, returns length or <0 if fails
1319 {
1320   struct writer_t writer;
1321   swf->compressed = 0;
1322   if(handle<0) {
1323     writer_init_nullwriter(&writer);
1324     return swf_WriteSWF2(&writer, swf);
1325   }
1326   writer_init_filewriter(&writer, handle);
1327   return swf_WriteSWF2(&writer, swf);
1328 }
1329
1330 int  swf_WriteSWC(int handle, SWF * swf)     // Writes SWF to file, returns length or <0 if fails
1331 {
1332   struct writer_t writer;
1333   swf->compressed = 1;
1334   if(handle<0) {
1335     writer_init_nullwriter(&writer);
1336     return swf_WriteSWF2(&writer, swf);
1337   }
1338   writer_init_filewriter(&writer, handle);
1339   return swf_WriteSWF2(&writer, swf);
1340 }
1341
1342 int swf_WriteHeader2(struct writer_t*writer,SWF * swf)
1343 {
1344   SWF myswf;
1345   memcpy(&myswf,swf,sizeof(SWF));
1346   myswf.firstTag = 0;
1347   return swf_WriteSWF2(writer, &myswf);
1348 }
1349
1350 int swf_WriteHeader(int handle,SWF * swf)
1351 {
1352   SWF myswf;
1353   memcpy(&myswf,swf,sizeof(SWF));
1354   myswf.firstTag = 0;
1355   return swf_WriteSWF(handle, &myswf);
1356 }
1357
1358 int swf_WriteCGI(SWF * swf)
1359 { int len;
1360   char s[1024];
1361     
1362   len = swf_WriteSWF(-1,swf);
1363
1364   if (len<0) return -1;
1365
1366   sprintf(s,"Content-type: application/x-shockwave-flash\n"
1367             "Accept-Ranges: bytes\n"
1368             "Content-Length: %lu\n"
1369             "Expires: Thu, 13 Apr 2000 23:59:59 GMT\n"
1370             "\n",len);
1371             
1372   write(fileno(stdout),s,strlen(s));
1373   return swf_WriteSWF(fileno(stdout),swf);
1374 }
1375
1376 void swf_FreeTags(SWF * swf)                 // Frees all malloc'ed memory for tags
1377 { TAG * t = swf->firstTag;
1378
1379   while (t)
1380   { TAG * tnew = t->next;
1381     if (t->data) free(t->data);
1382     free(t);
1383     t = tnew;
1384   }
1385 }
1386
1387 // include advanced functions
1388
1389 #include "modules/swfdump.c"
1390 #include "modules/swfshape.c"
1391 #include "modules/swftext.c"
1392 #include "modules/swffont.c"
1393 #include "modules/swfobject.c"
1394 #include "modules/swfbutton.c"
1395 #include "modules/swftools.c"
1396 #include "modules/swfcgi.c"
1397 #include "modules/swfbits.c"
1398 #include "modules/swfaction.c"
1399 #include "modules/swfsound.c"
1400 #include "modules/swfdraw.c"