+U32 swf_GetU30(TAG*tag)
+{
+ U32 shift = 0;
+ U32 s = 0;
+ int nr=0;
+ while(1) {
+ U8 b = swf_GetU8(tag);
+ nr++;
+ s|=(b&127)<<shift;
+ shift+=7;
+ if(!(b&128) || shift>=32)
+ break;
+ }
+ /*int nr2= swf_SetU30(0, s);
+ if(nr!=nr2) {
+ printf("Unsigned value %d stored in %d bytes, I'd store it in %d bytes\n", s, nr, nr2);
+ }*/
+ return s;
+}
+
+int swf_SetU30(TAG*tag, U32 u)
+{
+ int nr = 0;
+ do {
+ if(tag)
+ swf_SetU8(tag, (u&~0x7f?0x80:0) | (u&0x7F));
+ u>>=7;
+ nr++;
+ } while(u);
+ return nr;
+}
+
+void swf_SetABCU32(TAG*tag, U32 u)
+{
+ do {
+ swf_SetU8(tag, (u&~0x7f?0x80:0) | (u&0x7F));
+ u>>=7;
+ } while(u);
+}
+U32 swf_GetABCU32(TAG*tag)
+{
+ return swf_GetU30(tag);
+}
+void swf_SetABCS32(TAG*tag, S32 v)
+{
+ swf_SetABCU32(tag, v);
+}
+S32 swf_GetABCS32(TAG*tag)
+{
+ return swf_GetABCU32(tag);
+}
+
+#if 0
+
+/*The AVM2 spec is just plain wrong, claiming that S32 values are sign
+extended. They're not.
+This wastes up to 4 bytes for every negative value. */
+
+void swf_SetABCS32(TAG*tag, S32 s)
+{
+ printf("write S32: %d\n", s);
+ S32 neg = s<0?-1:0;
+ U8 sign = s<0?0x40:0;
+ while(1) {
+ U8 val = s&0x7f;
+ U8 vsign = s&0x40;
+ s>>=7;
+ neg>>=7;
+ if(s==neg && vsign==sign) {
+ /* if the value we now write has the same sign as s
+ and all the remaining bits are equal to the sign of s
+ too, stop writing */
+ swf_SetU8(tag, val);
+ printf("put %02x\n", val);
+ break;
+ } else {
+ swf_SetU8(tag, 0x80 | val);
+ printf("put %02x\n", 0x80|val);
+ }
+ };
+}
+int swf_GetS30(TAG*tag)
+{
+ U32 shift = 0;
+ U32 s = 0;
+ int nr=0;
+ while(1) {
+ U8 b = swf_GetU8(tag);
+ nr++;
+ nt i,m=t->len>10?10:t->len;
+ for(i=0;i<m;i++) {
+ fprintf(stderr, "%02x ", t->data[i]);
+ }
+ fprintf(stderr, "\n");
+ s|=(b&127)<<shift;
+ shift+=7;
+ if(!(b&128) || shift>=32) {
+ if(b&64) {
+ if(shift<32)
+ s|=0xffffffff<<shift;
+ }
+ break;
+ }
+ }
+ /* It's not uncommon for other applications (Flex for all negative numbers, and
+ Flash for -1) to generate a lot more bytes than would be necessary.
+ int nr2= swf_SetS30(0, s);
+ if(nr!=nr2) {
+ printf("Signed value %d stored in %d bytes, I'd store it in %d bytes\n", s, nr, nr2);
+ }*/
+ return s;
+}
+#endif
+
+int swf_SetU30String(TAG*tag, const char*str, int l)
+{
+ int len=0;
+ len+=swf_SetU30(tag, l);
+ len+=l;
+ swf_SetBlock(tag, (void*)str, l);
+ return len;
+}
+
+float swf_GetF16(TAG * t)
+{
+ U16 f1 = swf_GetU16(t);
+ if(!(f1&0x3ff)) return 0.0;
+
+ // IEEE 16 is 1-5-10
+ // IEEE 32 is 1-8-23
+ /* gcc 4.1.2 seems to require a union here. *(float*)u doesn't work */
+ union {
+ U32 u;
+ float f;
+ } f2;
+
+ U16 e = (f1>>10)&0x1f;
+ U16 m = f1&0x3ff;
+ /* find highest bit in mantissa */
+ int h=0;
+ while(!(m&0x400)) {
+ m<<=1;
+ h++;
+ }
+ m&=0x3ff;
+ e -= h;
+ e += 0x6f;
+
+ f2.u = (f1&0x8000)<<16; //sign
+ f2.u |= e<<23; //exponent
+ f2.u |= m<<13; //mantissa
+ return *(float*)&f2;
+}
+
+void swf_SetF16(TAG * t, float f)
+{
+ union {
+ U32 u;
+ float f;
+ } v;
+ v.f = f;
+
+ U16 result = (v.u>>16)&0x8000; //sign
+ int exp = ((v.u>>23)&0xff)-0x7f+0x10;
+ U16 m = (v.u>>13)&0x3ff;
+ //fprintf(stderr, "%f: %04x sign, %d exp, %04x mantissa\n", f, result, exp, m);
+ if(exp<-10) {
+ // underflow (clamp to 0.0)
+ exp = 0;
+ m = 0;
+ } else if(exp<0) {
+ // partial underflow- strip some bits
+ m = (m|0x400)>>-exp;
+ exp = 0;
+ } else if(exp>=32) {
+ exp = 31;
+ m = 0x3ff;
+ fprintf(stderr, "Exponent overflow in FLOAT16 encoding\n");
+ } else {
+ exp++;
+ m = (m>>1)|0x200;
+ }
+ result |= exp<<10;
+ result |= m;
+ swf_SetU16(t, result);
+}
+
+float F16toFloat(U16 x)
+{
+ TAG t;
+ t.data = (void*)&x;
+ t.readBit = 0;
+ t.pos = 0;
+ t.len = 2;
+ return swf_GetF16(&t);
+}
+
+float floatToF16(float f)
+{
+ U16 u = 0;
+ TAG t;
+ t.data = (void*)&u;
+ t.len = 0;
+ t.memsize = 2;
+ t.writeBit = 0;
+ swf_SetF16(&t, f);
+ return u;
+}
+
+double swf_GetD64(TAG*tag)
+{
+ /* FIXME: this is not big-endian compatible */
+ double value = *(double*)&tag->data[tag->pos];
+ swf_GetU32(tag);
+ swf_GetU32(tag);
+ return value;
+}
+int swf_SetD64(TAG*tag, double v)
+{
+ /* FIXME: this is not big-endian compatible */
+ swf_SetU32(tag, ((U32*)&v)[0]);
+ swf_SetU32(tag, ((U32*)&v)[1]);
+ return 8;
+}
+int swf_GetU24(TAG*tag)
+{
+ int b1 = swf_GetU8(tag);
+ int b2 = swf_GetU8(tag);
+ int b3 = swf_GetU8(tag);
+ return b3<<16|b2<<8|b1;
+}
+int swf_GetS24(TAG*tag)
+{
+ int b1 = swf_GetU8(tag);
+ int b2 = swf_GetU8(tag);
+ int b3 = swf_GetU8(tag);
+ if(b3&0x80) {
+ return -1-((b3<<16|b2<<8|b1)^0xffffff);
+ } else {
+ return b3<<16|b2<<8|b1;
+ }
+}
+int swf_SetU24(TAG*tag, U32 v)
+{
+ if(tag) {
+ if(v&0xff000000)
+ fprintf(stderr, "Error: Overflow in swf_SetU24()\n");
+ swf_SetU8(tag, v);
+ swf_SetU8(tag, v>>8);
+ swf_SetU8(tag, v>>16);
+ }
+ return 3;
+}
+int swf_SetS24(TAG*tag, U32 v)
+{
+ if(tag) {
+ if(!(v&0xff000000))
+ return swf_SetU24(tag, v);
+ if((v&0xff000000)!=0xff000000) {
+ fprintf(stderr, "Error: Overflow in swf_SetS24()\n");
+ }
+ swf_SetU8(tag, v);
+ swf_SetU8(tag, v>>8);
+ swf_SetU8(tag, v>>16);
+ }
+ return 3;
+}
+
+