/ (via @zeh)
//count only "drawn" frames
NetStream.decodedFrames  

//complete frame count
NetStream.info.droppedFrames

stage.addEventListener(MouseEvent.CLICK,toggleFullScreen);

function toggleFullScreen(event:MouseEvent):void
{
	switch (stage.displayState)
	{
		case "normal" :
			stage.displayState = fullScreen";
			break; 

		case "fullScreen" : 

		default :
			stage.displayState = "normal";
			ExternalInterface.call("focus");
			break;
	}
}

while( myDisplayObject.numChildren ) myDisplayObject.removeChildAt(0);

this.parent.removeChild( this );

this.parent.getChildIndex( this );

// almost 8 times faster than the Math.version
// benchmark can be found here : http://www.calypso88.com/?p=539
Math.pow(i, 2);
i * i; 

Math.min(i, 50000);
(i > 50000) ? 50000 : i;

Math.max(i, 50000);
(i < 50000) ? 50000 : i;

Math.abs(i);
(i < 0) ? -i : i ;

Math.floor(i);
int( i );

Math.ceil(i);
(i % i) ? int(i) + 1 : i;

Math.round(i);
int(i + .5);

//Fast modulo operation using bitwise AND

//If the divisor is a power of 2, the modulo (%) operation can be done with:
//modulus = numerator & (divisor - 1);

x = 131 % 4;
x = 131 & (4 - 1);

//Check if an integer is even/uneven using bitwise AND
isEven = (i % 2) == 0;
isEven = (i & 1) == 0;

//Right bit shifting to divide by any power of two:
x = x / 2;
x = x >> 1;

x = x / 64;
x = x >> 6;

//Left bit shifting to multiply by any power of two

x = x * 2;
x = x << 1;

const ROWS:int = 30;
const COLUMNS:int = 88;
const ITEMS:int = ROWS * COLUMNS;

var s:Shape ;
var i:int = 0;

for(i; i < ITEMS; i++)
{
   s = new Shape();
   s.x = int(i / ROWS) * 5;
   s.y = (i % ROWS) * 5;
   s.graphics.beginFill(0x666666);
   s.graphics.drawRect(0, 0, 4, 4);

    addChild(s);
}

// output bitmapData
private var _map:BitmapData;

// vector objects = typed arrays
private var _pts:Vector.<Point> = new Vector.<Point>();
private var _origin:Vector.<Point> = new Vector.<Point>();

// width and height of the map
public static const HEIGHT:int = 272;
public static const WIDTH:int = 500;

// a reference to the lenght of our vector
private var points_nb:int;

public function PixelMap()
{
	addEventListener(Event.ADDED_TO_STAGE , _init );
}

private function _init(e:Event = null):void
{
	removeEventListener(Event.ADDED_TO_STAGE , _init );
	stage.quality = "medium";

	// create an instance of Map object embed inside the library
	var map:Map = new Map(WIDTH, HEIGHT);

	// Draw map inside temp BitmapData
	var temp:BitmapData = new BitmapData(WIDTH, HEIGHT, false, 0x0);
	temp.draw(map);

	// fill our _map bitmapData with black ,
	// dimenseions ares the size of the stage = Map size
	_map = new BitmapData(WIDTH, HEIGHT, true, 0x00000000);

	// define the step to pick the pixels
	var margin:int = 3;
	var iy:int;
	var ix:int;

	// loop inside temp BitmapData for every one out of three pixels
	// if this pixel is not white, draw one black point inside our _map instance
	for(iy = 0; iy &lt; HEIGHT; iy += margin)
	{
		for(ix = 0; ix &lt; WIDTH; ix += margin)
		{
			// if the color being returned is not white
			if(temp.getPixel32(ix,iy) != 0xFFFFFFFF)
			{
				//color the pixel at positions ix, iy
				// with white in the _map bitmapData instance
				_map.setPixel32(ix, iy, 0xFFFFFFFF);

				// get a random position for each white pixels
				_pts.push(new Point(Math.random() * 500,Math.random() * 272));

				// keep a reference to the original
				// position of the pixel inside a Vector instance
				_origin.push(new Point(ix,iy));
			}
		}
	}

	// a reference to the length of
	// our vector instance
	points_nb = _pts.length;

	// create a new bitmap
	// with the newly organized _map bitmapData
	addChild(new Bitmap(_map));

	// add animation
	addEventListener(Event.ENTER_FRAME , _update );
}

private function _update(e:Event):void
{
	// mouse X & Y positions
	var __x:int = mouseX;
	var __y:int = mouseY;
	var i:int = 0;

	// reference to the point we are moving
	// it is drawn inside the _map bitmapData
	var p  oint;

	// reference the same point
	// with the originals x & y coordinates
	var o  oint;

	// vars to store the temp x & y
	var px:int;
	var py:int;
	var ox:int;
	var oy:int;
	var prox:int;

	var dify:int;
	var difx:int;

	// loop inside the vector's instance which stores all our points
	while(i &lt; points_nb)
	{
		// reference the pixel we are playing with
		p = _pts[int(i)];
		o = _origin[int(i)];

		// store its x & y coordinates
		px = p.x;
		py = p.y;

		// get the originals x & y coordinates of the point
		ox = o.x;
		oy = o.y;

		// how far is the point from the mouse position?
		prox = Math.sqrt((__x - px) * (__x - px) + (__y - py) * (__y - py));

		// if distance between the mouse and the point
		// is less than 12 pixels
		if(prox &lt;= 12)
		{
			// change this point's color to black
			_map.setPixel32(px, py, 0x000000);

			// calculate the new random coordinates for that point
			// this is where we want to move the pixel
			px = px + Math.round(Math.random() * 60 - 30);
			py = py + Math.round(Math.random() * 60 - 30);

			// color the point at the new coordinates in white
			_map.setPixel32(px, py, 0xFFFFFFFF);

			// store the new coordinates inside the point instance
			// which is stored inside the vector's instance
			p.x = px;
			p.y = py;

		}
		else
		{
			// if the point's position we are looking at
			// is different from its original one
			if(p != o)
			{
				// calculates the distance between
				// the origine and the current position
				difx = px - ox;
				dify = py - oy;

				// change the point's color to black
				_map.setPixel32(px, py, 0x000000);

				// if the point is closer than 1 pixel, then use the original coordinates,
				// else ease back the point to its inital position
				difx &lt; 1 ? px = ox : px = px - difx * 0.1 ;
				dify &lt; 1 ? py = oy : py = py - dify * 0.1 ;

				// color the point at the new position
				_map.setPixel32(px, py, 0xFFFFFFFF);

				// and store the new point's position inside the vector's instance
				p.x = px;
				p.y = py;
			}
		}

		// increase i to loop inside the vector's instance
		i++;
	}
}