package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.utils.ByteArray;
	import mx.core.ByteArrayAsset;
	import se.mowday.utils.ByteSprite;
	import se.mowday.utils.SparrowData;

	public class Main extends Sprite
	{
		// The texture XML data
		[Embed(source='../asset/sp.xml', mimeType='application/octet-stream')]
		private var data:Class;

		// The PNG sprite image
		[Embed(source='../asset/sp.png')]
		private var png:Class

		public function Main():void
		{
			var requestHeaderSize:int = 1200;
			var responseHeaderSize:int = 300;
			var perFile:int = (requestHeaderSize + responseHeaderSize) * 0.0078125;
			perFile = 0;

			var data:ByteArray = ByteSprite.deflate(Bitmap(new png()).bitmapData, XML(new data()));
			var oldSum:int = (perFile * 2 +105);
			var newSum:int = (perFile  + convert(data.length));

			trace("Original file: 105kb");
			trace("Original header size: " + (perFile * 2) + "kb");
			trace("Sum original = " + oldSum + "kb");
			trace("------------------------");
			trace("New file: " + convert(data.length) + "kb");
			trace("New header size: " + (perFile) + "kb");
			trace("Sum new = " + newSum + "kb");
			trace("------------------------");
			trace("Gain = " + (oldSum - newSum) + "kb - " + (100 - Math.round(newSum / oldSum * 100)) + " %");

			var newData:SparrowData = ByteSprite.inflate(data);
			addChild(newData.png);
		}

		private function convert(bytes:Number):Number
		{
			return bytes * 0.0009765625;
		}
	}

}

/*
  Copyright (c) 2011, Carl Mowday
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are
  met:

  * Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.

  * Neither the name of Carl Mowday nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package se.mowday.utils
{
	import flash.display.BitmapData;
	import flash.utils.ByteArray;

	/**
	 * This class converts "sparrow data formatted" files
	 * into one single binary file. This will reduce file size
	 * by concatinating the information from the two files into one file
	 * in binary form. This itself reduces alot of the file size as a
	 * result of moving to binary from the verbose XML syntax. <br />
	 * <br />
	 * The 2 functions in this class, <code>deflate</code> and <code>inflate</code>
	 * are eachothers opposites.<br />
	 * <code>deflate</code> will take an image file in the form of BitmapData as well
	 * as the texture XML with it and convert and return a bytearray containing the
	 * information of the two files in binary form. <br />
	 * <code>inflate</code> does the opposite. It converts a bytearray into a <code>SparrowData</code>
	 * instance that holds both the png (as a bitmap) and the texture XML.<br />
	 * <br />
	 * The data is stored like this<br />
	 * <code>
	 * NUMBER_OF_ITEMS_IN_XML
	 *
	 * LOOP_NUMBER_OF_ITEMS_IN_XML
	 * {
	 * 	NAME_LENGTH | NAME | X | Y | WIDTH | HEIGHT | [ FRAME_X | FRAME_Y | FRAME_WIDTH | FRAME_HEIGHT | ]
	 * }
	 *
	 * PNG_WIDTH | PNG_HEIGHT | PNG_DATA
	 * </code>
	 * @author Carl Mowday
	 */
	public class ByteSprite
	{
		/**
		 * Converts an image file and it's texture XML into a
		 * binary representation of the 2 files.
		 * @param	png The bitmapdata of the image file, ususally a PNG file
		 * @param	data The texture XML that comes with the image data
		 * @return A binary representation of the 2 files (compressed!)
		 */
		static public function deflate(png:BitmapData, data:XML):ByteArray
		{
			var ba:ByteArray		= new ByteArray();
			var tempBA:ByteArray	= new ByteArray();

			var subTexture:XMLList	= data.SubTexture;

			ba.writeShort(subTexture.length());
			for each(var subtxt:XML in subTexture)
			{
				tempBA.clear();
				tempBA.writeUTFBytes(subtxt.@name);

				ba.writeShort(tempBA.length);
				ba.writeBytes(tempBA);

				ba.writeDouble(subtxt.@x);
				ba.writeDouble(subtxt.@y);
				ba.writeDouble(subtxt.@width);
				ba.writeDouble(subtxt.@height);

				if (subtxt.@frameX != undefined && subtxt.@frameY != undefined)
				{
					ba.writeBoolean(true);
					ba.writeDouble(subtxt.@frameX);
					ba.writeDouble(subtxt.@frameY);
					ba.writeDouble(subtxt.@frameWidth);
					ba.writeDouble(subtxt.@frameHeight);
				}
				else
				{
					ba.writeBoolean(false);
				}
			}

			ba.writeDouble(png.width);
			ba.writeDouble(png.height);

			for (var x:int = 0; x < png.width; x++)
			{
				for (var y:int = 0; y < png.height; y++)
				{
					ba.writeUnsignedInt(png.getPixel32(x, y));
				}
			}

			ba.compress();

			return ba;
		}

		/**
		 * Converts a binary bytearray into a png and a texture XML
		 * ala the "sparrow data format".
		 * @param	data The binary representation of the png containing
		 * the sprites and the texture XML
		 * @return The texture XML and the png contained in a SparrowData
		 * instance.
		 */
		static public function inflate(data:ByteArray):SparrowData
		{
			data.uncompress();

			data.position = 0;

			var xml:String = new String();
			xml = "<TextureAtlas>\n";

			var itemsLength:int = data.readShort();

			for (var i:int = 0; i < itemsLength; i++)
			{
				var nameLength:int = data.readShort();
				var name:String = data.readUTFBytes(nameLength);

				xml += "\t<SubTexture name='" + name + "' ";
				xml += "x='" + data.readDouble() + "' y='" + data.readDouble() +"' ";
				xml += "width='" + data.readDouble() + "' height='" + data.readDouble() + "' ";

				if (data.readBoolean())
				{
					xml += "frameX='" + data.readDouble() + "' ";
					xml += "frameY='" + data.readDouble() + "' ";
					xml += "frameWidth='" + data.readDouble() + "' ";
					xml += "frameHeight='" + data.readDouble() + "' ";
				}

				xml += "/>\n";
			}
			xml += "</TextureAtlas>";

			var pngWidth:Number		= data.readDouble();
			var pngHeight:Number	= data.readDouble();
			var pngData:ByteArray	= new ByteArray();
			data.readBytes(pngData);

			var sd:SparrowData = new SparrowData(
				pngData,
				pngWidth,
				pngHeight,
				new XML(xml));

			return sd;
		}

	}

}

/*
  Copyright (c) 2011, Carl Mowday
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are
  met:

  * Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.

  * Neither the name of Carl Mowday nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package se.mowday.utils
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Loader;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.utils.ByteArray;

	/**
	 * This class holds the output of the ByteSprite class. This includes
	 * the png bitmap that holds the sprites as well as the texture XML
	 * that comes with it.<br />
	 * <br />
	 * There are 2 ways of accessing the png image. <br />
	 * 1. Simply get the <code>png</code> member. If the png member
	 * is empty (null) the class will generate a bitmap data object by looping
	 * all of the pixels in the byte array, generate a bitmapdata and then
	 * creating a bitmap object based on the bitmapdata.<br />
	 * 2. Invoked the <code>initiate</code> function. This acts as an
	 * asynchronicle start of loading the png. This method will create
	 * a Loader object, and then pass the bytes directly to that object.
	 * When the loader has finished loading the bitmap is retrieved from
	 * the content and then used. When this is done a <code>Event.COMPLETE</code>
	 * event will be dispatched, and the png member is ready to be used.
	 * @see se.mowday.utils.ByteSprite
	 * @author Carl Mowday
	 */
	public class SparrowData extends EventDispatcher
	{
		private var _png:Bitmap;
		private var _pngData:ByteArray;
		private var _data:XML;

		private var _height:Number;
		private var _width:Number;

		private var _loader:Loader;

		public function SparrowData(pngData:ByteArray, width:Number, height:Number, data:XML)
		{
			_data		= data;
			_width		= width;
			_height		= height;
			_pngData	= pngData;
		}

		/**
		 * Starts an asynchronicle loading of the png file. When completed
		 * the instance will dispatch an <code>Event.COMPLETE</code> event.
		 */
		public function initiate():void
		{
			_loader = new Loader();
			_loader.contentLoaderInfo.addEventListener(Event.INIT, onInit);
			_loader.loadBytes(_pngData);
		}

		/**
		 * Invoked when the loader has completed loading
		 * the bytes and the content can be retrieved
		 */
		private function onInit(e:Event):void
		{
			_loader.contentLoaderInfo.removeEventListener(Event.INIT, onInit);
			_png = Bitmap(_loader.content);
			dispatchEvent(new Event(Event.COMPLETE));
			_loader = null;
		}

		/**
		 * Checks if the png image is ready to be retrieved
		 * or not
		 */
		public function get ready():Boolean
		{
			return png != null;
		}

		/**
		 * The texture XML that comes with the sprite map
		 */
		public function get data():XML
		{
			return _data;
		}

		/**
		 * The png image (the sprite map)
		 */
		public function get png():Bitmap
		{
			if (_png == null)
			{
				var bmd:BitmapData = new BitmapData(_width, _height);
				for (var x:int = 0; x < _width; x++)
				{
					for (var y:int = 0; y < _height; y++)
					{
						bmd.setPixel32(x, y, _pngData.readUnsignedInt());
					}
				}
			}

			_png = new Bitmap(bmd);

			return _png;
		}

		/**
		 * The raw png data
		 */
		public function get pngData():ByteArray
		{
			return _pngData;
		}
	}

}

Download: starling_lib (113.12KB)
Added: 26/09/2011
Description:
The Flashdevelop project for the "Starling lib"

Download: StarlingHelper (278.92KB)
Added: 26/09/2011
Description:
The AIR application for the Starling helper project