• Introduction
• Information we need
• Coding
  • Overview
  • Explanation of the code
  • Start of loading
  • Adaptive loading
  • Jumping back
• Example/Test

• Actionscript Code is highlighted in this color.
• Flash Actionscript starts with
  //~ Actionscript BEGIN
  and ends with
  //~ Actionscript END
• Predefined functions, words and properties are bold.
• Comments are highlighted in this color.
• Values referencing to Actionscript code are written in italics.

• We start loading the Flix video file, but we do not display it until the appropriate time. (We start the loadMovie() command, but at the same time we prevent the movie from starting to play with a stop()-action)
• We determine how long it should take for the Flix video file to completely load. (with the getBytesLoaded() and getTimer() commands we can determine the approximate time it will take for the Flix video file to completely load)
• We determine how long it will take to display the loaded portion of the video file.
  (we know how many bytes we have loaded and we know the framerate - with this information we can determine how long - approximately - the playing time of the loaded portion of the video file)
• If the time it should take to display the loaded portion of the video is longer than the time we need to load the rest of the video file, we start playing the video. (we have two values, one value shows how long we need to load the SWF-file up to the end and the other value shows how long it will take to display the loaded portion of the video file. If the time it should take to display the loaded portion of the video is longer than the time we need to load the rest of the video file, we can start playing the video and while it plays the rest of the video is loaded.

• how much time has elapsed since we started loading the video (in milliseconds)
• how much of the video has been loaded in this time (in bytes)

• the framerate (frames per second) of the video the total number of SWF frames in the video

• the framerate (frames per second) of the SWF
• the count of already loaded frames

• how much do we still have to load (in kilobytes)
• the visitors connection speed (in kilobytes per second)

In Flash that would be (simplified):
//~ Actionscript BEGIN
bytesToLoad = _root.mc.getBytesTotal() - _root.mc.getBytesLoaded();
kiloBytesToLoad = bytesToLoad / 1024;
leftLoadTime = kiloBytesToLoad / cSpeed; //~ we determined cSpeed before, see above.
//~ Actionscript END

• If you think the viewer's connection will get faster during the visit (e.g., perhaps a download ends) then you can change the buffer factor to a number smaller than 1.0.
• If you think the viewer's connection will get slower during the visit (e.g., because the viewer starts a new download) you should change the buffer factor to a number greater than 1.0. I always recommend making it larger than 1.0 to be on the safe side. A value of 1.1 gave good results with a 56k Modem in my tests.
  

//~ Actionscript BEGIN
/*~ define a puffer factor (in case the connection differs during the visit)
set 1.0 for NO puffer */
pufferFactor = 1.1;
//~ ############### END OF USER-DEFINED OPTIONS ###############
//~ Actionscript END

Next we need some information from the video which is loaded:

//~ Actionscript BEGIN
//~ total bytes of the swf
totalBytes = eval(this.target).getBytesTotal();
//~ total frames of the swf
totalFrames = eval(this.target)._totalframes;
//~ actual frame of the swf
currentFrame = eval(this.target)._currentframe;
//~ loaded bytes of the swf
loadedBytes = eval(this.target).getBytesLoaded();
//~ loaded frames of the swf
loadedFrames = eval(this.target)._framesloaded;
//~ Actionscript END

Next we have to determine this information:

//~ Actionscript BEGIN
//~ bytes still to load
leftBytes = totalBytes - loadedBytes;
//~ time since loading started (in milliseconds)
loadTime = getTimer() - this.startTime; //~ Variable startTime
//~ determine connection speed (in KB/second)
speed = loadedBytes / loadTime;
//~ determine total playing time of the movie
totalTime = totalFrames / fps;
//~ determine time currently could be played (in seconds)
playTime = loadedFrames / fps;
//~ determine time which is needed to complete loading of the swf (in seconds)
leftLoadTime = (leftBytes / 1024) / speed;
//~ Actionscript END

Once the preloader has all this information, it can determine whether or not to start the video, or if it should wait longer - until the time it will take to display the loaded portion of the video is longer than the time we need to load the rest of the video.

I just want to make a couple of comments about the loading bug in Flash 5+. If you load a SWF file with loadMovie() and then watch the values of the property getBytesLoaded() and getBytesTotal() you will see, that they will have the same value (normally 22) for several milliseconds. Now if you check this value using some code like getBytesLoaded() == getBytesTotal() this will return true (which is incorrect) for several milliseconds and that can cause problems in our code. This is why we use another variables.

//~ Actionscript BEGIN Prevent loading bug
s = totalFrames / currentFrame;

if (s > 1 || once == true) {
/*~ if time which can be displayed is longer
than the time needed to load start the swf */
if (playTime > (leftLoadTime * pufferFactor) && once == false) {
status = "playing...";
eval(this.target).play();
once = true;
//~ if playing ended, stop the swf
} else if (currentFrame == totalFrames && once == true) {
status = "finished playing...";
eval(this.target).stop();
this.stop();
}
//~ we still need some time for loading
} else {
eval(this.target).stop();
status = "buffering...";
}
//~ Actionscript END

The Code above in the frame calculate needs to be executed until the video is displayed entirely, therefore we need to jump backward to this frame.
The following code in the frame after calculate will do that:

//~ Actionscript BEGIN
//~ jump backward
gotoAndPlay(_currentframe - 1);
//~ Actionscript END