hello everyone!

I hope, that name of the threas is correct.

I use Flash builder 4, flash player 10.2.0... debug for other browsers(firefox), Flex SDK Hero 4.5.0.1....

I make a AS3 project with simpleStageVideo from addobe issue about it.

if delete lines with StageVideoAvailabilityEvent it works correctly and show my wideo. But when run all code, i have a debug error Error #1014: flash.events::StageVideoAvailabilityEvent can't find class.

what is wrong??????????

this is a code:

package
{
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.DisplayObject;
    import flash.display.Loader;
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageDisplayState;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.FullScreenEvent;
    import flash.events.KeyboardEvent;
    import flash.events.MouseEvent;
    import flash.events.NetStatusEvent;
    import flash.events.StageVideoAvailabilityEvent;
    import flash.events.StageVideoEvent;
    import flash.events.TimerEvent;
    import flash.events.VideoEvent;
    import flash.geom.Rectangle;
    import flash.media.SoundTransform;
    import flash.media.StageVideo;
    import flash.media.StageVideoAvailability;
    import flash.media.Video;
    import flash.net.NetConnection;
    import flash.net.NetStream;
    import flash.system.LoaderContext;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.text.TextFormat;
    import flash.ui.Keyboard;
   
    /**
     *
     * @author Thibault Imbert
     *
     */   
    [SWF(frameRate="1", backgroundColor="#000000")]
    public class CStageVideo extends Sprite
    {
        private static const FILE_NAME:String = "C:/Users/Dan/Desktop/Goldenbird/render/Back30.flv";
        private static const INTERVAL:Number = 500;
        private static const BORDER:Number = 20;
       
        private var legend:TextField = new TextField();
        private var sv:StageVideo;
        private var nc:NetConnection;
        private var ns:NetStream;
        private var customClient:Object;
        private var duration: Number;
        private var rc:Rectangle;
        private var video:Video;
        private var thumb:Shape;
        private var interactiveThumb:Sprite;
        private var totalTime:Number;
       
        private var videoWidth:int;
        private var videoHeight:int;
        private var outputBuffer:String = new String();
        private var rect:Rectangle = new Rectangle(0, 0, 0, BORDER);
        private var videoRect:Rectangle = new Rectangle(0, 0, 0, 0);
        private var gotStage:Boolean;
        private var stageVideoInUse:Boolean;
        private var classicVideoInUse:Boolean;
        private var accelerationType:String;
        private var infos:String = new String();
        private var available:Boolean;
        private var inited:Boolean;
        private var played:Boolean;
        private var container:Sprite;
       
        /**
         *
         *
         */        
       
        public function CStageVideo()
        {
            // Make sure the app is visible and stage available
            addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onAddedToStage(event:Event):void
        {
            // Scaling
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            legend.autoSize = TextFieldAutoSize.LEFT;
           
            // Debug infos
            legend.multiline = true;
            legend.background = true;
            legend.backgroundColor = 0xFFFFFFFF;
            addChild(legend);
           
            // Thumb seek Bar
            thumb = new Shape();
           
            interactiveThumb = new Sprite();
            interactiveThumb.addChild(thumb);
            addChild(interactiveThumb);
           
            // Connections
            nc = new NetConnection();
            nc.connect(null);
            ns = new NetStream(nc);
            ns.addEventListener(NetStatusEvent.NET_STATUS, onNetStatus);
            //ns.client = this;
            customClient = new Object;
            customClient.onMetaData = metaDataHandler;
            ns.client = customClient;
           
            // Screen
            video = new Video();
            video.smoothing = true;
           
            // Video Events
            // the StageVideoEvent.STAGE_VIDEO_STATE informs you if StageVideo is available or not
            stage.addEventListener(StageVideoAvailabilityEvent.STAGE_VIDEO_AVAILA BILITY, onStageVideoState);
            //toggleStageVideo(available = inited = false);
            // in case of fallback to Video, we listen to the VideoEvent.RENDER_STATE event to handle resize properly and know about the acceleration mode running
            video.addEventListener(VideoEvent.RENDER_STATE, videoStateChange);
           
            // Input Events
            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
            stage.addEventListener(Event.RESIZE,  onResize);
            stage.addEventListener(MouseEvent.CLICK, onClick);
        }
       
        private function metaDataHandler( meta:Object ):void
        {
            duration = meta.duration;
            trace("meta duration -> " + duration);        
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onNetStatus(event:NetStatusEvent):void
        {
            if ( event.info == "NetStream.Play.StreamNotFound" )
                legend.text = "Video file passed, not available!";
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onFrame(event:Event):void
        {
            var ratio:Number = (ns.time / totalTime) * (stage.stageWidth - (BORDER << 1));
            rect.width = ratio;
            thumb.graphics.clear();
            thumb.graphics.beginFill(0xFFFFFF);
            thumb.graphics.drawRect(rect.x, rect.y, rect.width, rect.height);   
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onClick(event:MouseEvent):void
        {
            if ( event.stageY >= interactiveThumb.y - BORDER && event.stageX <= stage.stageWidth - BORDER )
            {
                var seekTime:Number = (stage.mouseX - BORDER) * ( totalTime / (stage.stageWidth - (BORDER << 1) ) );
                ns.seek( seekTime );   
            }
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onKeyDown(event:KeyboardEvent):void
        {   
            if ( event.keyCode == Keyboard.O )
            {
                if ( available )
                    // We toggle the StageVideo on and off (fallback to Video and back to StageVideo)
                    toggleStageVideo(inited=!inited);
               
            } else if ( event.keyCode == Keyboard.F )
            {
                stage.displayState = StageDisplayState.FULL_SCREEN;
            } else if ( event.keyCode == Keyboard.SPACE )
            {
                ns.togglePause();
            }
            else if ( event.keyCode == Keyboard.DELETE )
            {
                played = false;
            }
        }
       
        /**
         *
         * @param width
         * @param height
         * @return
         *
         */       
        private function getVideoRect(width:uint, height:uint):Rectangle
        {   
            var videoWidth:uint = width;
            var videoHeight:uint = height;
            var scaling:Number = Math.min ( stage.stageWidth / videoWidth, stage.stageHeight / videoHeight );
           
            videoWidth *= scaling, videoHeight *= scaling;
           
            var posX:uint = stage.stageWidth - videoWidth >> 1;
            var posY:uint = stage.stageHeight - videoHeight >> 1;
           
            videoRect.x = posX;
            videoRect.y = posY;
            videoRect.width = videoWidth;
            videoRect.height = videoHeight;
           
            return videoRect;
        }
       
        /**
         *
         *
         */       
        private function resize ():void
        {   
            if ( stageVideoInUse )
            {
                // Get the Viewport viewable rectangle
                rc = getVideoRect(sv.videoWidth, sv.videoHeight);
                // set the StageVideo size using the viewPort property
                sv.viewPort = rc;
            } else
            {
                // Get the Viewport viewable rectangle
                rc = getVideoRect(video.videoWidth, video.videoHeight);
                // Set the Video object size
                video.width = rc.width;
                video.height = rc.height;
                video.x = rc.x, video.y = rc.y;
            }
           
            interactiveThumb.x = BORDER, interactiveThumb.y = stage.stageHeight - (BORDER << 1);
            legend.text = infos;
        }
       
        /**
         *
         * @param evt
         *
         */       
        public function onMetaData ( evt:Object ):void
        {
            totalTime = evt.duration;
            stage.addEventListener(Event.ENTER_FRAME, onFrame);
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onStageVideoState(event:StageVideoAvailabilityEvent):void
        {   
            // Detect if StageVideo is available and decide what to do in toggleStageVideo
            toggleStageVideo(available = inited = (event.availability == StageVideoAvailability.AVAILABLE));
        }
       
        /**
         *
         * @param on
         *
         */       
        private function toggleStageVideo(on:Boolean):void
        {   
            infos = "StageVideo Running (Direct path) : " + on + "\n";
           
            // If we choose StageVideo we attach the NetStream to StageVideo
            if (on)
            {
                stageVideoInUse = true;
                if ( sv == null )
                {
                    sv = stage.stageVideos[0];
                    sv.addEventListener(StageVideoEvent.RENDER_STATE, stageVideoStateChange);
                }
                sv.attachNetStream(ns);
                if (classicVideoInUse)
                {
                    // If we use StageVideo, we just remove from the display list the Video object to avoid covering the StageVideo object (always in the background)
                    stage.removeChild ( video );
                    classicVideoInUse = false;
                }
            } else
            {
                // Otherwise we attach it to a Video object
                if (stageVideoInUse)
                    stageVideoInUse = false;
                classicVideoInUse = true;
                video.attachNetStream(ns);
                stage.addChildAt(video, 0);
            }
           
            if ( !played )
            {
                played = true;
                ns.play(FILE_NAME);
            }
        }
       
        /**
         *
         * @param event
         *
         */       
        private function onResize(event:Event):void
        {
            resize();       
        }
       
        /**
         *
         * @param event
         *
         */       
        private function stageVideoStateChange(event:StageVideoEvent):void
        {   
            infos += "StageVideoEvent received\n";
            infos += "Render State : " + event.status + "\n";
            resize();
        }
       
        /**
         *
         * @param event
         *
         */       
        private function videoStateChange(event:VideoEvent):void
        {   
            infos += "VideoEvent received\n";
            infos += "Render State : " + event.status + "\n";
            resize();
        }
    }
}