When are surfaces regenerated? Changes to a movie clip that make the player regenerate the internal bitmap representation should be used sparingly; otherwise you defeat the purpose of the feature. The bitmap that is generated when you turn bitmap caching on for a movie clip will be regenerated every time you change any of the following MovieClip ActionScript properties:

• _xscale
• _yscale
• _rotation
• _alpha
• _width
• _height
• filters
• blendMode
• opaqueBackground
• transform

So, try to avoid changing any of these ActionScript properties on a regular basis.

The bitmap will also be regenerated when:

• The timeline play head changes inside the movie clip
• When the outer boundaries of the movie clip change
• When you draw something inside the movie clip with the drawing api
• When you attach an image or symbol from the library into the movie clip
• Any of the above occur within a nested movie clip (child movie clip)
• The movie's viewing window changes (i.e. The viewer Zooms in using the RightClick menu)

Memory Usage
Bitmap Caching naturally makes the Flash Player utilize more memory because for every cached movie clip the player has to store the vector data and the additional bitmap equivalent in memory. When you turn bitmap caching off for any particular movie clip, its bitmap representation is removed from memory.

You should be concerned about the amount of memory that your Flash Movie uses, because it can affect the performance of other applications that are running on the same computer as the Flash Player. The more memory the Flash Player uses, the less memory that is available for other programs to run effectively. Computers only have so much memory available to them; this comes in the form of RAM (Random Access Memory). Most computers nowadays have at least 256MB RAM. The operating system may provide more memory as and when required in the form of Virtual Memory. The Flash Player should never use that amount of memory, but now with the various new Bitmap related features added to the player, it is possible for Flash Movies to consume large amounts of memory in a short space of time so as the developer you should endeavor to minimize memory usage.

Before we talk about the specifics of bitmap caching memory usage, a little background information might be useful. Firstly, a bitmap is made up of pixels. It can be thought of as a grid of color values, which designate a particular color for each and every pixel. Each pixel is a cell in the grid. A bitmap that is 100 pixels wide, by 100 pixels high is described by a grid of 1000 color values, one for each pixel. Each color value in a bitmap is a binary number. A binary number is made up of bit's which can either be 0 or 1. This binary number will differ in length, depending upon the color depth of the bitmap. The color depth of a bitmap determines the range of possible color values that can be used in each pixel. For example, each pixel in a 24 bit image can be one of roughly 16.8 million colors. Those colors are formed by mixing together varying quantities of three primary colors, Red, Green and Blue. The three main colors are called Channels. Each channel can have 256 possible values (0255).

255 * 255 * 255 = 16.8 million
256 decimal is 11111111 in binary.

This binary number is 8 bits long. 8 bits is 1 byte. Therefore each channel in a color uses 1 byte. The bitmaps that are created by the Flash Player when it converts a movie clip into a surface have a 32 bit color depth. 32 bit images have four channels; Red, Green, Blue and an additional Alpha Channel. Therefore the color value for each pixel in a surface created by the Flash Player is 32 bits long, or 4 bytes.

4 * 8 = 32 bit

The bitmap that is created by the Flash Player to represent the visual state of a movie clip when you turn Bitmap Caching on will have the same dimensions (width and height) as the movie clip. A cached movie clip that is 100 pixels high and 100 pixels wide has 1000 pixels.

100 * 100 = 10,000 pixels

Each of those pixels will be 32 bits or 4 bytes. Therefore it will utilize a further 400,000 bytes of memory.

10,000 * 4 = 400,000 bytes

There are 1024 bytes in 1 kilobyte (KB). So, 400,000 bytes can also be said to be roughly 400 kilobytes.

Size Limits
Because of the possibility of this feature using excessive amounts of memory, Bitmap Caching will not work, if the dimensions of a cached movie clip are larger, or become larger, than 2880 pixels in either width or height. 2880 is a restriction Macromedia has put in place for all bitmaps in the player, to try and minimize excessive memory use. That is because a 2880 * 2880 movie clip that is cached will use up roughly 32MB of memory. Four of these cached movie clips with those same dimensions could potentially fill up a computer's memory and crash the machine.

Filters
It is worth noting here that if a filter effect is applied to a movie clip either in the Authoring Environment or using actionscript, then Bitmap Caching is automatically turned on and the cacheAsBitmap property will always return true, regardless of whether you turned Bitmap Caching off in the Authoring Environment or with ActionScript. To prove this, create a new movie clip, give it an instance name of scrollingMovieclip and add the following code to the first frame of the main timeline:

var blur=new flash.filters.BlurFilter(3,3,3) //guassian blur
scrollingMovieclip.filters=[blur]
trace(scrollingMovieclip.cacheAsBitmap) //outputs 'true'

When all of the filters effects are removed from a movie clip the cacheAsBitmap property will return to its previous state. So for example, if Bitmap Caching is turned off for a movie clip but it has filters applied to it, then removing all of those filters from the movie clip will turn Bitmap Caching off again:

scrollingMovieClip.filters=undefined
trace(scrollingMovieclip.cacheAsBitmap) //outputs 'false'

Loading External Content
Also when you load an external Flash Movie or image into a cached movie clip, using ActionScript, bitmap caching is turned off. This is because a movie clip is totally reset, all variables inside it are deleted, and all child movie clips are removed, all movie clip properties are set back to their default values.

To prove it, try the following code:

/*

This code fixes the onLoad bug, that is that anyMovieclip.onLoad event handler is deleted when loading external content into a movieclip

*/
_global.s_onLoad=function(f)
{
if(onLoadManager == undefined)
{
_global.onLoadManager={}
}
onLoadManager[this] =f
}
_global.g_onLoad=function()
{
return onLoadManager[this]
}
MovieClip.prototype.addProperty('onLoad', g_onLoad, s_onLoad)
this.createEmptyMovieClip("scrollingMovieclip",this.getNextHighestDepth())
scrollingMovieclip.onLoad=function()
{
trace(this.cacheAsBitmap)
//when the photo is loaded, show that bitmap caching was turned off
}
scrollingMoveclip.cacheAsBitmap=true
scrollingMovieclip.loadMovie("photo.jpg")

• Figure 1
• Figure 2
• Figure 3
• Figure 4
• Figure 5
• Figure 6