The number of seconds of data currently in the buffer. You can use this property with the bufferTime property to estimate how close the buffer is to being full — for example, to display feedback to a user who is waiting for data to be loaded into the buffer.

See also

Specifies how long to buffer messages before starting to display the stream. For example, to make sure that the first 15 seconds of the stream play without interruption, set bufferTime to 15; Flash Player begins playing the stream only after 15 seconds of data are buffered.

The default value is 0.1 (one-tenth of a second). To determine the number of seconds currently in the buffer, use the bufferLength property.

See also

The number of bytes of data that have been loaded into the player. You can use this property with the bytesTotal property to estimate how close the buffer is to being full — for example, to display feedback to a user who is waiting for data to be loaded into the buffer.

See also

The total size in bytes of the file being loaded into the player.

See also

Specifies whether Flash Player should try to download a cross-domain policy file from the loaded FLV file's server before beginning to load the FLV file. This property applies when you are using a NetStream object for progressive video download (standalone FLV files), or when you are loading FLV files that are outside the calling SWF file's own domain. This property is ignored when you are using a NetStream object to get an RTMP asset.

Set this property to true when you are loading an FLV file from outside the calling SWF file's domain and you need to use the BitmapData.draw() method for pixel-level access to the video. If you call BitmapData.draw() without setting the checkPolicyFile property to true at loading time, you may get a SecurityError exception because the required policy file was not downloaded.

If you don't need pixel-level access to the video you are loading, avoid setting checkPolicyFile to true. Checking for a policy file consumes network bandwidth and may delay the start of your download.

When you call the NetStream.play() method with checkPolicyFile set to true, Flash Player must either successfully download a relevant cross-domain policy file or determine that no such policy file exists before it begins downloading the object specified in your call to NetStream.play(). To verify the existence of a policy file, Flash Player performs the following actions, in this order:

1. Flash Player considers policy files that have already been downloaded.
2. Flash Player tries to download any pending policy files specified in calls to the Security.loadPolicyFile() method.
3. Flash Player tries to download a policy file from the default location that corresponds to the URL you passed to NetStream.play(), which is /crossdomain.xml on the same server as that URL.

In all cases, Flash Player requires that an appropriate policy file exist on the video's server, that it provide access to the object at the URL you passed to play() based on the policy file's location, and that it allow the domain of the calling SWF to access the video, through one or more <allow-access-from> tags.

If you set checkPolicyFile to true, Flash Player waits until the policy file is verified before downloading the video. Wait to perform any pixel-level operations on the video data, such as calling BitmapData.draw(), until you receive onMetaData or NetStatus events from your NetStream object.

If you set checkPolicyFile to true but no relevant policy file is found, you won't receive an error until you perform an operation that requires a policy file, and then Flash Player throws a SecurityError exception.

Be careful with checkPolicyFile if you are downloading an FLV file from a URL that uses server-side HTTP redirects. Flash Player tries to retrieve policy files that correspond to the initial URL that you specify in NetStream.play(). If the final FLV file comes from a different URL because of HTTP redirects, the initially downloaded policy files might not be applicable to the FLV file's final URL, which is the URL that matters in security decisions.

For more information on policy files, see the "Flash Player Security" chapter of Programming ActionScript 3.0.

See also

Specifies the object on which callback methods are invoked. The default object is this, the NetStream object being created. If you set the client property to another object, callback methods will be invoked on that other object.

The number of frames per second being displayed. If you are exporting FLV files to be played back on a number of systems, you can check this value during testing to help you determine how much compression to apply when exporting the file.

The number of seconds of data in the subscribing stream's buffer in live (unbuffered) mode. This property specifies the current network transmission delay (lag time).

This property is intended primarily for use with a server, such as Flash Media Server; for more information, see the class description.

You can get the value of this property to roughly gauge the transmission quality of the stream and communicate it to the user.

The object encoding (AMF version) for this NetStream object. The NetStream object inherits its objectEncoding value from the associated NetConnection object. It's important to understand this property if your ActionScript 3.0 SWF file needs to communicate with servers released prior to Flash Player 9. For more information, see the objectEncoding property description in the NetConnection class.

The value of this property depends on whether the stream is local or remote. Local streams, where null was passed to the NetConnection.connect() method, return the value of NetConnection.defaultObjectEncoding. Remote streams, where you are connecting to a server, return the object encoding of the connection to the server.

If you try to read this property when not connected, or if you try to change this property, Flash Player throws an exception.

See also

Controls sound in this NetStream object. For more information, see the SoundTransform class.

See also

The position of the playhead, in seconds.

See also

Creates a stream that can be used for playing FLV files through the specified NetConnection object.

See also

Specifies an audio stream sent over the NetStream object, from a Microphone object passed as the source. This method is available only to the publisher of the specified stream.

This method is intended primarily for use with a server, such as Flash Media Server; for more information, see the class description.

You can call this method before or after you call the publish() method and actually begin transmitting. Subscribers who want to hear the audio must call the NetStream.play() method. You can control the sound properties of this audio stream through the soundTransform property of the specified Microphone object.

See also

Starts capturing video from the specified source, or stops capturing if theCamera is set to null. This method is available only to the publisher of the specified stream.

This method is intended primarily for use with a server, such as Flash Media Server; for more information, see the class description.

After attaching the video source, you must call NetStream.publish() to begin transmitting. Subscribers who want to display the video must call the NetStream.play() and Video.attachCamera() methods to display the video on the Stage.

You can use snapshotMilliseconds to send a single snapshot (by providing a value of 0) or a series of snapshots — in effect, time-lapse footage — by providing a positive number that adds a trailer of the specified number of milliseconds to the video feed. The trailer extends the display time of time the video message is displayed. By repeatedly calling attachCamera() with a positive value for snapshotMilliseconds, the sequence of alternating snapshots and trailers create time-lapse footage. For example, you could capture one frame per day and append it to a video file. When a subscriber plays the file, each frame remains onscreen for the specified number of milliseconds and then the next frame is displayed.

The purpose of the snapshotMilliseconds parameter is different from the fps parameter you can set with Camera.setMode(). When you specify snapshotMilliseconds, you control how much time elapses between recorded frames. When you specify fps using Camera.setMode(), you are controlling how much time elapses during recording and playback.

For example, suppose you want to take a snapshot every 5 minutes for a total of 100 snapshots. You can do this in two ways:

• You can issue a NetStream.attachCamera(myCamera, 500) command 100 times, once every 5 minutes. This takes 500 minutes to record, but the resulting file will play back in 50 seconds (100 frames with 500 milliseconds between frames).
• You can issue a Camera.setMode() command with an fps value of 1/300 (one per 300 seconds, or one every 5 minutes), and then issue a NetStream.attachCamera(source) command, letting the camera capture continuously for 500 minutes. The resulting file will play back in 500 minutes — the same length of time that it took to record — with each frame being displayed for 5 minutes.

Both techniques capture the same 500 frames, and both approaches are useful; the approach to use depends primarily on your playback requirements. For example, in the second case, you could be recording audio the entire time. Also, both files would be approximately the same size.

Stops playing all data on the stream, sets the time property to 0, and makes the stream available for another use. This command also deletes the local copy of an FLV file that was downloaded through HTTP. Although Flash Player deletes the local copy of the FLV file that it creates, a copy of the video might persist in the browser's cache directory. If you must completely prevent caching or local storage of the FLV file, use Flash Media Server 2.

See also

Pauses playback of a video stream. Calling this method does nothing if the video is already paused.

See also

Begins playback of external audio or a video (FLV) file. To view video data, you must create a Video object and call the Video.attachNetStream() method; audio being streamed with the video, or an FLV file that contains only audio, is played automatically. To stream audio from a microphone, use the NetStream.attachAudio() method and control some aspects of the audio through the Microphone object.

To control the audio associated with an FLV file, you can use the DisplayObjectContainer.addChild() method to route the audio to an object on the display list; you can then create a Sound object to control some aspects of the audio. For more information, see the DisplayObjectContainer.addChild() method.

If the FLV file can't be found, the netStatus event is dispatched. To stop a stream that is currently playing, use the close() method.

When you use this method, consider the Flash Player security model.

• Calling NetStream.play() is not allowed if the calling SWF file is in the local-with-file-system sandbox and the resource is in a remote sandbox.
• Network sandbox access from the local-trusted or local-with-networking sandbox requires permission from the website through a cross-domain policy file.

For more information, see the following:

• The security chapter in the Programming ActionScript 3.0 book and the latest comments on LiveDocs
• The Flash Player 9 Security white paper

See also

Sends streaming audio, video, and text messages from a client to a server, such as Flash Media Server 2, optionally recording the stream during transmission. This method is available only to the publisher of the specified stream.

This method is intended primarily for use with a server, such as Flash Media Server 2; for more information, see the class description.

Don't use this method to let a client play a stream that has already been published and recorded. Instead, create a NetStream instance for that client and call the play() method:

  var subscribeNS:NetStream = new NetStream(myNetConnection);
  subscribeNS.play("streamToPlay");
  

With Flash Media Server 2, when you record a stream, Flash creates an FLV file and stores it in a subdirectory of the applications directory on the server. Each stream is stored in a directory whose name matches the application instance name value passed to the command parameter of the NetConnection.connect() method. Flash Player creates these directories automatically; you don't have to create one for each instance name. For example, the following code shows how you would connect to a specific instance of an application that is stored in a directory named lectureSeries in your applications directory. A file named lecture.flv is stored in a subdirectory named /yourAppsFolder/lectureSeries/streams/Monday:

  var myNC:NetConnection = new NetConnection();
  myNC.connect("rtmp://server.domain.com/lectureSeries/Monday");
  var myNS:NetStream = new NetStream(myNC);
  myNS.publish("lecture", "record");
  

The following example shows how to connect to a different instance of the same application but issue an identical publish command. A file named lecture.flv is stored in a subdirectory named /yourAppsFolder/lectureSeries/streams/Tuesday.

  var myNC:NetConnection = new NetConnection();
  myNC.connect("rtmp://server.domain.com/lectureSeries/Tuesday");
  var myNS:NetStream = new NetStream(my_nc);
  myNS.publish("lecture", "record");
  

If you don't pass a value for the instance name, that matches the value passed to the name property is stored in a subdirectory named /yourAppsFolder/appName/streams/_definst_ (for "default instance"). For more information on using instance names, see the NetConnection.connect() method. For information on playing back FLV files, see the NetStream.play() method.

This method can dispatch a netStatus event with several different information objects. For example, if someone is already publishing on a stream with the specified name, the netStatus event is dispatched with a code property of NetStream.Publish.BadName. For more information, see the netStatus event.

See also

Specifies whether incoming audio plays on the stream. This method is available only to clients subscribed to the specified stream, not to the stream's publisher.

This method is intended primarily for use with a server, such as Flash Media Server; for more information, see the class description.

You can call this method before or after you call the NetStream.play() method and actually begin receiving the stream. For example, you can attach these methods to a button the user clicks to mute and unmute the incoming audio stream.

If the specified stream contains only audio data, passing a value of false to this method stops NetStream.time from further incrementing.

Specifies whether incoming video will play on the stream. This method is available only to clients subscribed to the specified stream, not to the stream's publisher.

This method is intended primarily for use with a server, such as Flash Media Server 2; for more information, see the class description.

You can call this method before or after you call the NetStream.play() method and actually begin receiving the stream. For example, you can attach these methods to a button the user presses to show or hide the incoming video stream.

If the specified stream contains only video data, passing a value of false to this method stops NetStream.time from further incrementing.

Resumes playback of a video stream that is paused. If the video is already playing, calling this method does nothing.

See also

Seeks the keyframe closest to the specified location (an offset, in seconds, from the beginning of the stream). The stream resumes playing when that location is reached.

See also

Sends a message on the specified stream to all subscribing clients. This method is available only to the publisher of the specified stream.

This method is intended primarily for use with a server, such as Flash Media Server 2; for more information, see the class description.

To process and respond to the message, create a handler in the format myStream.HandlerName.

Flash Player does not serialize methods or their data, object prototype variables, or non-enumerable variables. For display objects, Flash Player serializes the path but none of the data.

See also

  import flash.net.NetConnection;
  import flash.net.NetStream;
  import flash.events.NetStatusEvent;
  import flash.media.Video;
  import flash.utils.setTimeout;
  
  var nc:NetConnection = new NetConnection();
  nc.objectEncoding = 0;
  nc.addEventListener("netStatus", onNCStatus);
  nc.connect("rtmp://www.example.com/MyApp/MyInstance");
  var ns1:NetStream;
  var vid:Video = new Video(300,300);
  addChild(vid);
  var obj:Object = new Object();
  obj.myFunction = function(event:String):void {
   trace(event);
  }
  
  function onNCStatus(event:NetStatusEvent):void {
   if(event.info.code == "NetConnection.Connect.Success") {
    ns1 = new NetStream(nc);
    ns1.play("MyVideo");
    vid.attachNetStream(ns1);
    ns1.client = obj;
    ns1.publish("dummy", "live");
    
    var ns2:NetStream = new NetStream(nc);
    ns2.play("dummy");
    ns2.client = obj;
    
    setTimeout(sendHello, 3000);
   }
  }
  
  function sendHello():void {
    ns1.send("myFunction", "hello");
  }
  

Pauses or resumes playback of a stream. The first time you call this method, it pauses play; the next time, it resumes play. You could use this method to let users pause or resume playback by pressing a single button.

See also

Dispatched when an exception is thrown asynchronously — that is, from native asynchronous code. This event is dispatched when a server calls a method on the client that is not defined.

The AsyncErrorEvent.ASYNC_ERROR constant defines the value of the type property of an asyncError event object.

This event has the following properties:

See also

Dispatched when an input or output error occurs that causes a network operation to fail.

Defines the value of the type property of an ioError event object.

This event has the following properties:

Dispatched when a NetStream object is reporting its status or error condition. The netStatus event contains an info property, which is an information object that contains specific information about the event, such as if a connection attempt succeeded or failed.

Defines the value of the type property of a netStatus event object.

This event has the following properties:

See also

Invoked when an embedded cue point is reached while playing an FLV file. You can use this handler to trigger actions in your code when the video reaches a specific cue point, which lets you synchronize other actions in your application with video playback events.

This event is intended primarily for use with a server, such as Flash Media Server 2; for more information, see the class description. It is not part of the Flash Player API, but is included in this language reference for your convenience. You cannot use the addEventListener() method, or any other EventDispatcher methods, to listen for or process this event. Rather, you must define a single callback function and attach it directly to one of the following objects:

• The object referenced by the client property of a NetStream instance.
• An instance of a NetStream subclass. NetStream is a sealed class, which means that properties or methods cannot be added to a NetStream object at runtime. However, you can create a subclass of NetStream and define your event handler in the subclass or make the subclass dynamic and add the event handler function to an instance of the subclass.

The following types of cue points can be embedded in an FLV file:

• A navigation cue point specifies a keyframe within the FLV file and the cue point's time property corresponds to that exact keyframe. Navigation cue points are often used as bookmarks or entry points to let users navigate through the video file.
• An event cue point is specified by time, whether or not that time corresponds to a specific keyframe. An event cue point usually represents a time in the video when something happens that could be used to trigger other application events.

The onCuePoint event object has the following properties:

You can define cue points in an FLV file when you first encode the file, or when you import a video clip in the Flash authoring tool by using the Video Import wizard.

The onMetaData event also retrieves information about the cue points in a video file. However the onMetaData event gets information about all of the cue points before the video begins playing. The onCuePoint event receives information about a single cue point at the time specified for that cue point during playback.

Generally, to have your code respond to a specific cue point at the time it occurs, use the onCuePoint event to trigger some action in your code.

You can use the list of cue points provided to the onMetaData event to let the user start playing the video at predefined points along the video stream. Pass the value of the cue point's time property to the NetStream.seek() method to play the video from that cue point.

See also

Dispatched when Flash Player receives descriptive information embedded in the FLV file being played.

This special event is primarily intended for use with a server, such as Flash Media Server; for more information, see the class description. It is not technically part of the Flash Player API, but is included in this language reference for your convenience. You cannot use the addEventListener() method, or any other EventDispatcher methods, to listen for or process this event. Rather, you must define a single callback function and attach it directly to one of the following objects:

• The object that the client property of a NetStream instance references.
• An instance of a NetStream subclass. NetStream is a sealed class, which means that properties or methods cannot be added to a NetStream object at runtime. However, you can create a subclass of NetStream and define your event handler in the subclass or make the subclass dynamic and add the event handler function to an instance of the subclass.

The Flash Video Exporter utility (version 1.1 or later) embeds a video's duration, creation date, data rates, and other information into the video file itself. Different video encoders embed different sets of meta data.

This event is triggered after a call to the NetStream.play() method, but before the video playhead has advanced.

In many cases, the duration value embedded in FLV metadata approximates the actual duration but is not exact. In other words, it does not always match the value of the NetStream.time property when the playhead is at the end of the video stream.

See also

Dispatched when a NetStream object has completely played a stream. This handler returns information objects that provide information in addition to what's returned by the netStatus event. You can use this handler to trigger actions in your code when a NetStream object has switched from one stream to another stream in a playlist (as indicated by the information object NetStream.Play.Switch) or when a NetStream object has played to the end (as indicated by the information object NetStream.Play.Complete). To respond to this event, you must create a function to process the information object sent by the server.

This event is intended primarily for use with a server, such as Flash Media Server; for more information, see the class description. It is not part of the Flash Player API, but is included in this language reference for your convenience. You cannot use the addEventListener() method, or any other EventDispatcher methods, to listen for or process this event. Rather, you must define a single callback function and attach it directly to one of the following objects:

• The object that the client property of a NetStream instance references.
• An instance of a NetStream subclass. NetStream is a sealed class, which means that properties or methods cannot be added to a NetStream object at runtime. However, you can create a subclass of NetStream and define your event handler in the subclass or make the subclass dynamic and add the event handler function to an instance of the subclass.

This event can return an information object with the following properties:

See also

In this example, the code that creates the Video and NetStream objects and calls the Video.attachNetStream() and NetStream.play() methods is placed in a handler function. The handler is called only if the attempt to connect to the NetConnection object is successful; that is, when the netStatus event returns an info object with a code property that indicates success. It is recommended that you wait for a successful connection before you call NetStream.play().

package {
    import flash.display.Sprite;
    import flash.events.NetStatusEvent;
    import flash.events.SecurityErrorEvent;
    import flash.media.Video;
    import flash.net.NetConnection;
    import flash.net.NetStream;
    import flash.events.Event;

    public class NetConnectionExample extends Sprite {
        private var videoURL:String = "Video.flv";
        private var connection:NetConnection;
        private var stream:NetStream;

        public function NetConnectionExample() {
            connection = new NetConnection();
            connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            connection.connect(null);
        }

        private function netStatusHandler(event:NetStatusEvent):void {
            switch (event.info.code) {
                case "NetConnection.Connect.Success":
                    connectStream();
                    break;
                case "NetStream.Play.StreamNotFound":
                    trace("Stream not found: " + videoURL);
                    break;
            }
        }

        private function securityErrorHandler(event:SecurityErrorEvent):void {
            trace("securityErrorHandler: " + event);
        }

        private function connectStream():void {
            var stream:NetStream = new NetStream(connection);
            stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            stream.client = new CustomClient();
            var video:Video = new Video();
            video.attachNetStream(stream);
            stream.play(videoURL);
            addChild(video);
        }
    }
}

class CustomClient {
    public function onMetaData(info:Object):void {
        trace("metadata: duration=" + info.duration + " width=" + info.width + " height=" + info.height + " framerate=" + info.framerate);
    }
    public function onCuePoint(info:Object):void {
        trace("cuepoint: time=" + info.time + " name=" + info.name + " type=" + info.type);
    }
}