# Writing SWF Dimensions

**URL:** https://forum.kirupa.com/t/writing-swf-dimensions/316580
**Category:** flash
**Created:** [November 26, 2010, 6:44pm UTC](https://forum.kirupa.com/t/writing-swf-dimensions/316580 "2010-11-26T18:44:01Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![krilnon](https://yyz1.discourse-cdn.com/flex011/user_avatar/forum.kirupa.com/krilnon/32/34_2.png) [@krilnon](https://forum.kirupa.com/u/krilnon)
#### Post date: [November 26, 2010, 6:44pm UTC](https://forum.kirupa.com/t/writing-swf-dimensions/316580/1 "2010-11-26T18:44:01Z")

</div>

I’m trying to write the RECT structure described on page 20 of the [SWF specification to a ByteArray. I started with [URL=“http://opensource.adobe.com/svn/opensource/flex/sdk/trunk/modules/swfutils/src/java/flash/swf/SwfEncoder.java”]some Java code from Adobe](http://www.adobe.com/devnet/swf.html) that does the same thing (but in Java, not AS3).

This is my adaptation so far:

```php
public static function writeRect(bytes:ByteArray, rect:Rectangle):void {
	bitPos = 8;
	currentByte = 0;
	var left:int = rect.left * 20;
	var right:int = rect.right * 20;
	var top:int = rect.top * 20;
	var bottom:int = rect.bottom * 20;
	
	var max:int = Math.max(Math.abs(left), Math.abs(right), Math.abs(top), Math.abs(bottom));
	
	var nBits:uint = Math.max(Math.ceil(Math.log(max) / Math.LN2), 1) + 1; // 1 extra for sign?
	writeBits(bytes, nBits, 5);
	writeBits(bytes, left, nBits);
	writeBits(bytes, right, nBits);
	writeBits(bytes, top, nBits);
	writeBits(bytes, bottom, nBits);
}

private static var
	bitPos:int,
	currentByte:uint;

private static function writeBits(bytes:ByteArray, val:uint, nBits:uint):void {
	while (nBits > 0){
		if (nBits > bitPos){
			//if more bits left to write than shift out what will fit
			currentByte |= val << (32 - nBits) >>> (32 - bitPos);
			currentByte %= 256; // modulo, because AS3 doesn't have a `byte` type
			
			// shift all the way left, then right to right
			// justify the data to be or'ed in
			bytes.writeByte(currentByte);
			nBits -= bitPos;
			currentByte = 0;
			bitPos = 8;
		} else { // (nBits <= bytePos)
			currentByte |= val << (32 - nBits) >>> (32 - bitPos);
			currentByte %= 256;
			bitPos -= nBits;
			nBits = 0;
			
			if (bitPos == 0){
				//if current byte is filled
				bytes.writeByte(currentByte);
				currentByte = 0;
				bitPos = 8;
			}
		}
	}
}

```

In some code that I wrote to test this, it will read in an SWF that’s 400x250 and write those dimensions as 400x249.75, which is a little off. (-:

In binary, here’s a comparison of what the 5 RECT fields should be (first) and what they end up being after the above code writes them (last):

```auto
nBits: 11100
left: 00000000000000
right: 11111010000000
top: 00000000000000
bottom: **10011100010000**

00000000000001111000000001000000000100010000010001000010000000000

nBits: 11100
left: 00000000000000
right: 11111010000000
top: 00000000000000
bottom: **10011100000111**

10000000000000000101000100000100010000100000000000000000000000000

```

(the trailing bits are just what is next in the file… I thought it might be useful to include in case I’m not writing enough bits, or something)

It seems like the right calls are being made to `writeBits`, because the values make sense as multiplied forms of the Rectangle dimensions:

```auto
writeBits 14 5
writeBits 0 14
writeBits 8000 14
writeBits 0 14
writeBits 5000 14

```

So, _something_ seems to be wrong with how it’s writing the last field (or how it does its bit/byte position bookkeeping overall), but I’ve been trying to debug this code for quite a while without any luck.

Does anyone know what might be going on here?