home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / videoClasses / VideoPlayer.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  51.0 KB  |  1,808 lines
  1. package mx.controls.videoClasses
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.NetStatusEvent;
  5.    import flash.events.ProgressEvent;
  6.    import flash.events.TimerEvent;
  7.    import flash.media.SoundTransform;
  8.    import flash.media.Video;
  9.    import flash.utils.Timer;
  10.    import mx.core.mx_internal;
  11.    import mx.events.MetadataEvent;
  12.    import mx.events.VideoEvent;
  13.    import mx.resources.IResourceManager;
  14.    import mx.resources.ResourceManager;
  15.    
  16.    use namespace mx_internal;
  17.    
  18.    public class VideoPlayer extends Video
  19.    {
  20.       mx_internal static const VERSION:String = "3.5.0.12683";
  21.       
  22.       public static const DISCONNECTED:String = "disconnected";
  23.       
  24.       public static const STOPPED:String = "stopped";
  25.       
  26.       public static const PLAYING:String = "playing";
  27.       
  28.       public static const PAUSED:String = "paused";
  29.       
  30.       public static const BUFFERING:String = "buffering";
  31.       
  32.       public static const LOADING:String = "loading";
  33.       
  34.       public static const CONNECTION_ERROR:String = "connectionError";
  35.       
  36.       public static const REWINDING:String = "rewinding";
  37.       
  38.       public static const SEEKING:String = "seeking";
  39.       
  40.       public static const RESIZING:String = "resizing";
  41.       
  42.       public static const EXEC_QUEUED_CMD:String = "execQueuedCmd";
  43.       
  44.       private static const BUFFER_EMPTY:String = "bufferEmpty";
  45.       
  46.       private static const BUFFER_FULL:String = "bufferFull";
  47.       
  48.       private static const BUFFER_FLUSH:String = "bufferFlush";
  49.       
  50.       public static const DEFAULT_UPDATE_TIME_INTERVAL:Number = 250;
  51.       
  52.       public static const DEFAULT_UPDATE_PROGRESS_INTERVAL:Number = 250;
  53.       
  54.       public static const DEFAULT_IDLE_TIMEOUT_INTERVAL:Number = 300000;
  55.       
  56.       public static const AUTO_RESIZE_INTERVAL:Number = 100;
  57.       
  58.       public static const AUTO_RESIZE_PLAYHEAD_TIMEOUT:Number = 0.5;
  59.       
  60.       public static const AUTO_RESIZE_METADATA_DELAY_MAX:Number = 5;
  61.       
  62.       public static const FINISH_AUTO_RESIZE_INTERVAL:Number = 250;
  63.       
  64.       public static const RTMP_DO_STOP_AT_END_INTERVAL:Number = 500;
  65.       
  66.       public static const RTMP_DO_SEEK_INTERVAL:Number = 100;
  67.       
  68.       public static const HTTP_DO_SEEK_INTERVAL:Number = 250;
  69.       
  70.       public static const HTTP_DO_SEEK_MAX_COUNT:Number = 4;
  71.       
  72.       public static const CLOSE_NS_INTERVAL:Number = 0.25;
  73.       
  74.       public static const HTTP_DELAYED_BUFFERING_INTERVAL:Number = 100;
  75.       
  76.       public static var DEFAULT_INCMANAGER:Class = NCManager;
  77.       
  78.       public var autoBandWidthDetection:Boolean = false;
  79.       
  80.       private var rtmpDoStopAtEndTimer:Timer;
  81.       
  82.       private var currentPos:Number;
  83.       
  84.       private var bufferState:String;
  85.       
  86.       private var _volume:Number;
  87.       
  88.       public var ncMgrClassName:Class;
  89.       
  90.       private var _visible:Boolean;
  91.       
  92.       private var cachedPlayheadTime:Number;
  93.       
  94.       private var _ncMgr:INCManager;
  95.       
  96.       private var _soundTransform:SoundTransform;
  97.       
  98.       private var prevVideoHeight:Number = -1;
  99.       
  100.       private var _isLive:Boolean;
  101.       
  102.       private var idleTimeoutTimer:Timer;
  103.       
  104.       private var sawPlayStop:Boolean;
  105.       
  106.       private var lastUpdateTime:Number;
  107.       
  108.       private var invalidSeekTime:Boolean;
  109.       
  110.       private var autoPlay:Boolean;
  111.       
  112.       private var _priorBytesLoaded:int = -1;
  113.       
  114.       private var httpDoSeekCount:Number;
  115.       
  116.       private var streamLength:Number;
  117.       
  118.       private var _metadata:Object;
  119.       
  120.       private var cachedState:String;
  121.       
  122.       private var _state:String;
  123.       
  124.       private var startingPlay:Boolean;
  125.       
  126.       private var readyDispatched:Boolean;
  127.       
  128.       private var internalVideoHeight:Number = -1;
  129.       
  130.       private var atEnd:Boolean;
  131.       
  132.       private var sawSeekNotify:Boolean;
  133.       
  134.       private var prevVideoWidth:Number = -1;
  135.       
  136.       private var updateTimeTimer:Timer;
  137.       
  138.       private var finishAutoResizeTimer:Timer;
  139.       
  140.       private var _url:String;
  141.       
  142.       private var httpDoSeekTimer:Timer;
  143.       
  144.       private var rtmpDoSeekTimer:Timer;
  145.       
  146.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  147.       
  148.       private var internalVideoWidth:Number = -1;
  149.       
  150.       private var autoResizeTimer:Timer;
  151.       
  152.       private var invalidSeekRecovery:Boolean;
  153.       
  154.       private var ns:VideoPlayerNetStream;
  155.       
  156.       private var delayedBufferingTimer:Timer;
  157.       
  158.       private var updateProgressTimer:Timer;
  159.       
  160.       private var _bufferTime:Number;
  161.       
  162.       private var _autoRewind:Boolean;
  163.       
  164.       private var cmdQueue:Array;
  165.       
  166.       public function VideoPlayer(param1:uint, param2:uint, param3:Class = null)
  167.       {
  168.          super(param1,param2);
  169.          _state = DISCONNECTED;
  170.          cachedState = _state;
  171.          bufferState = BUFFER_EMPTY;
  172.          sawPlayStop = false;
  173.          cachedPlayheadTime = 0;
  174.          _metadata = null;
  175.          startingPlay = false;
  176.          invalidSeekTime = false;
  177.          invalidSeekRecovery = false;
  178.          currentPos = 0;
  179.          atEnd = false;
  180.          cmdQueue = [];
  181.          readyDispatched = false;
  182.          lastUpdateTime = -1;
  183.          sawSeekNotify = false;
  184.          param3 = param3 == null ? DEFAULT_INCMANAGER : param3;
  185.          updateTimeTimer = new Timer(DEFAULT_UPDATE_TIME_INTERVAL);
  186.          updateTimeTimer.addEventListener(TimerEvent.TIMER,doUpdateTime);
  187.          updateProgressTimer = new Timer(DEFAULT_UPDATE_PROGRESS_INTERVAL);
  188.          updateProgressTimer.addEventListener(TimerEvent.TIMER,doUpdateProgress);
  189.          idleTimeoutTimer = new Timer(DEFAULT_IDLE_TIMEOUT_INTERVAL,1);
  190.          idleTimeoutTimer.addEventListener(TimerEvent.TIMER,doIdleTimeout);
  191.          autoResizeTimer = new Timer(AUTO_RESIZE_INTERVAL);
  192.          autoResizeTimer.addEventListener(TimerEvent.TIMER,doAutoResize);
  193.          rtmpDoStopAtEndTimer = new Timer(RTMP_DO_STOP_AT_END_INTERVAL);
  194.          rtmpDoStopAtEndTimer.addEventListener(TimerEvent.TIMER,rtmpDoStopAtEnd);
  195.          rtmpDoSeekTimer = new Timer(RTMP_DO_SEEK_INTERVAL);
  196.          rtmpDoSeekTimer.addEventListener(TimerEvent.TIMER,doSeek);
  197.          httpDoSeekTimer = new Timer(HTTP_DO_SEEK_INTERVAL);
  198.          httpDoSeekTimer.addEventListener(TimerEvent.TIMER,doSeek);
  199.          finishAutoResizeTimer = new Timer(FINISH_AUTO_RESIZE_INTERVAL,1);
  200.          finishAutoResizeTimer.addEventListener(TimerEvent.TIMER,finishAutoResize);
  201.          delayedBufferingTimer = new Timer(HTTP_DELAYED_BUFFERING_INTERVAL);
  202.          delayedBufferingTimer.addEventListener(TimerEvent.TIMER,doDelayedBuffering);
  203.          httpDoSeekCount = 0;
  204.          _isLive = false;
  205.          autoPlay = true;
  206.          _autoRewind = true;
  207.          _bufferTime = 0.1;
  208.          _volume = 100;
  209.          _soundTransform = new SoundTransform(_volume);
  210.          _visible = true;
  211.          _url = "";
  212.       }
  213.       
  214.       public function get playheadTime() : Number
  215.       {
  216.          var _loc1_:Number = ns == null ? currentPos : Number(ns.time);
  217.          if(Boolean(_metadata) && Boolean(_metadata.audiodelay))
  218.          {
  219.             _loc1_ -= _metadata.audiodelay;
  220.             if(_loc1_ < 0)
  221.             {
  222.                _loc1_ = 0;
  223.             }
  224.          }
  225.          return _loc1_;
  226.       }
  227.       
  228.       public function set playheadTime(param1:Number) : void
  229.       {
  230.          seek(param1);
  231.       }
  232.       
  233.       public function stop() : void
  234.       {
  235.          if(!isXnOK())
  236.          {
  237.             if(_state == CONNECTION_ERROR || _ncMgr == null || _ncMgr.netConnection == null)
  238.             {
  239.                throw new VideoError(VideoError.NO_CONNECTION);
  240.             }
  241.             return;
  242.          }
  243.          if(_state == EXEC_QUEUED_CMD)
  244.          {
  245.             _state = cachedState;
  246.          }
  247.          else
  248.          {
  249.             if(!stateResponsive)
  250.             {
  251.                queueCmd(VideoPlayerQueuedCommand.STOP);
  252.                return;
  253.             }
  254.             execQueuedCmds();
  255.          }
  256.          if(_state == STOPPED || ns == null)
  257.          {
  258.             return;
  259.          }
  260.          if(_ncMgr.isRTMP())
  261.          {
  262.             if(_autoRewind && !_isLive)
  263.             {
  264.                currentPos = 0;
  265.                _play(0,0);
  266.                _state = STOPPED;
  267.                setState(REWINDING);
  268.             }
  269.             else
  270.             {
  271.                closeNS();
  272.                setState(STOPPED);
  273.             }
  274.          }
  275.          else
  276.          {
  277.             _pause(true);
  278.             if(_autoRewind)
  279.             {
  280.                _seek(0);
  281.                _state = STOPPED;
  282.                setState(REWINDING);
  283.             }
  284.             else
  285.             {
  286.                setState(STOPPED);
  287.             }
  288.          }
  289.       }
  290.       
  291.       override public function get videoWidth() : int
  292.       {
  293.          if(internalVideoWidth > 0)
  294.          {
  295.             return internalVideoWidth;
  296.          }
  297.          if(metadata != null && !isNaN(metadata.width) && !isNaN(metadata.height))
  298.          {
  299.             if(metadata.width == metadata.height && readyDispatched)
  300.             {
  301.                return super.videoWidth;
  302.             }
  303.             return int(metadata.width);
  304.          }
  305.          if(readyDispatched)
  306.          {
  307.             return super.videoWidth;
  308.          }
  309.          return -1;
  310.       }
  311.       
  312.       public function get progressInterval() : uint
  313.       {
  314.          return updateProgressTimer.delay;
  315.       }
  316.       
  317.       private function _play(... rest) : void
  318.       {
  319.          var _loc2_:String = null;
  320.          rtmpDoStopAtEndTimer.reset();
  321.          startingPlay = true;
  322.          switch(rest.length)
  323.          {
  324.             case 0:
  325.                ns.play(_ncMgr.streamName);
  326.                break;
  327.             case 1:
  328.                ns.play(_ncMgr.streamName,rest[0]);
  329.                break;
  330.             case 2:
  331.                ns.play(_ncMgr.streamName,rest[0],rest[1]);
  332.                break;
  333.             default:
  334.                _loc2_ = resourceManager.getString("controls","badArgs");
  335.                throw new ArgumentError(_loc2_);
  336.          }
  337.       }
  338.       
  339.       public function setScale(param1:Number, param2:Number) : void
  340.       {
  341.          if(param1 == super.scaleX && param2 == super.scaleY)
  342.          {
  343.             return;
  344.          }
  345.          super.scaleX = param1;
  346.          super.scaleY = param2;
  347.       }
  348.       
  349.       public function get volume() : Number
  350.       {
  351.          return _volume;
  352.       }
  353.       
  354.       public function get soundTransform() : SoundTransform
  355.       {
  356.          return _soundTransform;
  357.       }
  358.       
  359.       public function doUpdateTime(param1:Event) : void
  360.       {
  361.          var _loc3_:VideoEvent = null;
  362.          var _loc2_:Number = playheadTime;
  363.          switch(_state)
  364.          {
  365.             case STOPPED:
  366.             case PAUSED:
  367.             case DISCONNECTED:
  368.             case CONNECTION_ERROR:
  369.                if(param1 != null)
  370.                {
  371.                   updateTimeTimer.reset();
  372.                }
  373.          }
  374.          if(lastUpdateTime != _loc2_)
  375.          {
  376.             _loc3_ = new VideoEvent(VideoEvent.PLAYHEAD_UPDATE);
  377.             _loc3_.state = _state;
  378.             _loc3_.playheadTime = _loc2_;
  379.             dispatchEvent(_loc3_);
  380.             lastUpdateTime = _loc2_;
  381.          }
  382.       }
  383.       
  384.       public function get ncMgr() : INCManager
  385.       {
  386.          if(_ncMgr == null)
  387.          {
  388.             createINCManager();
  389.          }
  390.          return _ncMgr;
  391.       }
  392.       
  393.       public function set progressInterval(param1:uint) : void
  394.       {
  395.          updateProgressTimer.delay = param1;
  396.       }
  397.       
  398.       public function get stateResponsive() : Boolean
  399.       {
  400.          switch(_state)
  401.          {
  402.             case DISCONNECTED:
  403.             case STOPPED:
  404.             case PLAYING:
  405.             case PAUSED:
  406.             case BUFFERING:
  407.                return true;
  408.             default:
  409.                return false;
  410.          }
  411.       }
  412.       
  413.       public function get bufferTime() : Number
  414.       {
  415.          return _bufferTime;
  416.       }
  417.       
  418.       private function doAutoResize(param1:Event) : void
  419.       {
  420.          if(param1 != null)
  421.          {
  422.             switch(_state)
  423.             {
  424.                case RESIZING:
  425.                case LOADING:
  426.                   break;
  427.                case DISCONNECTED:
  428.                case CONNECTION_ERROR:
  429.                   autoResizeTimer.reset();
  430.                   return;
  431.                default:
  432.                   if(!stateResponsive)
  433.                   {
  434.                      return;
  435.                   }
  436.                   break;
  437.             }
  438.             if(!(videoWidth != prevVideoWidth || videoHeight != prevVideoHeight || bufferState == BUFFER_FULL || bufferState == BUFFER_FLUSH || (!!ns ? ns.time > AUTO_RESIZE_PLAYHEAD_TIMEOUT : false)))
  439.             {
  440.                return;
  441.             }
  442.             internalVideoWidth = videoWidth;
  443.             internalVideoHeight = videoHeight;
  444.             autoResizeTimer.reset();
  445.          }
  446.          setState(cachedState);
  447.       }
  448.       
  449.       public function get metadata() : Object
  450.       {
  451.          return _metadata;
  452.       }
  453.       
  454.       public function set volume(param1:Number) : void
  455.       {
  456.          if(param1 >= 0 && param1 <= 1)
  457.          {
  458.             _volume = param1;
  459.          }
  460.          else if(param1 < 0)
  461.          {
  462.             _volume = 0;
  463.          }
  464.          else
  465.          {
  466.             _volume = 1;
  467.          }
  468.          _soundTransform.volume = _volume;
  469.          if(ns != null)
  470.          {
  471.             ns.soundTransform = _soundTransform;
  472.          }
  473.       }
  474.       
  475.       public function get isLive() : Boolean
  476.       {
  477.          return _isLive;
  478.       }
  479.       
  480.       public function set soundTransform(param1:SoundTransform) : void
  481.       {
  482.          _soundTransform = param1;
  483.          _volume = _soundTransform.volume;
  484.          ns.soundTransform = _soundTransform;
  485.       }
  486.       
  487.       public function play(param1:String = null, param2:Boolean = false, param3:Number = -1) : void
  488.       {
  489.          if(param1 != null)
  490.          {
  491.             if(_state == EXEC_QUEUED_CMD)
  492.             {
  493.                _state = cachedState;
  494.             }
  495.             else
  496.             {
  497.                if(!stateResponsive)
  498.                {
  499.                   queueCmd(VideoPlayerQueuedCommand.PLAY,param1,param2,param3);
  500.                   return;
  501.                }
  502.                execQueuedCmds();
  503.             }
  504.             autoPlay = true;
  505.             _load(param1,param2,param3);
  506.             return;
  507.          }
  508.          if(!isXnOK())
  509.          {
  510.             if(_state == CONNECTION_ERROR || _ncMgr == null || _ncMgr.netConnection == null)
  511.             {
  512.                throw new VideoError(VideoError.NO_CONNECTION);
  513.             }
  514.             flushQueuedCmds();
  515.             queueCmd(VideoPlayerQueuedCommand.PLAY);
  516.             setState(LOADING);
  517.             cachedState = LOADING;
  518.             _ncMgr.reconnect();
  519.             return;
  520.          }
  521.          if(_state == EXEC_QUEUED_CMD)
  522.          {
  523.             _state = cachedState;
  524.          }
  525.          else
  526.          {
  527.             if(!stateResponsive)
  528.             {
  529.                queueCmd(VideoPlayerQueuedCommand.PLAY,null,param2);
  530.                return;
  531.             }
  532.             execQueuedCmds();
  533.          }
  534.          if(ns == null)
  535.          {
  536.             createStream();
  537.             attachNetStream(ns);
  538.          }
  539.          switch(_state)
  540.          {
  541.             case BUFFERING:
  542.                if(_ncMgr.isRTMP())
  543.                {
  544.                   _play(0);
  545.                   if(atEnd)
  546.                   {
  547.                      atEnd = false;
  548.                      currentPos = 0;
  549.                      setState(REWINDING);
  550.                   }
  551.                   else if(currentPos > 0)
  552.                   {
  553.                      _seek(currentPos);
  554.                      currentPos = 0;
  555.                   }
  556.                }
  557.             case PLAYING:
  558.                return;
  559.             case STOPPED:
  560.                if(_ncMgr.isRTMP())
  561.                {
  562.                   if(param2)
  563.                   {
  564.                      _play(-1);
  565.                      setState(BUFFERING);
  566.                   }
  567.                   else
  568.                   {
  569.                      _play(0);
  570.                      if(atEnd)
  571.                      {
  572.                         atEnd = false;
  573.                         currentPos = 0;
  574.                         _state = BUFFERING;
  575.                         setState(REWINDING);
  576.                      }
  577.                      else if(currentPos > 0)
  578.                      {
  579.                         _seek(currentPos);
  580.                         currentPos = 0;
  581.                         setState(BUFFERING);
  582.                      }
  583.                      else
  584.                      {
  585.                         setState(BUFFERING);
  586.                      }
  587.                   }
  588.                }
  589.                else
  590.                {
  591.                   _pause(false);
  592.                   if(atEnd)
  593.                   {
  594.                      atEnd = false;
  595.                      _seek(0);
  596.                      _state = BUFFERING;
  597.                      setState(REWINDING);
  598.                   }
  599.                   else if(bufferState == BUFFER_EMPTY)
  600.                   {
  601.                      setState(BUFFERING);
  602.                   }
  603.                   else
  604.                   {
  605.                      setState(PLAYING);
  606.                   }
  607.                }
  608.                break;
  609.             case PAUSED:
  610.                _pause(false);
  611.                if(!_ncMgr.isRTMP())
  612.                {
  613.                   if(bufferState == BUFFER_EMPTY)
  614.                   {
  615.                      setState(BUFFERING);
  616.                   }
  617.                   else
  618.                   {
  619.                      setState(PLAYING);
  620.                   }
  621.                }
  622.                else
  623.                {
  624.                   setState(BUFFERING);
  625.                }
  626.          }
  627.       }
  628.       
  629.       public function onCuePoint(param1:Object) : void
  630.       {
  631.          var _loc2_:MetadataEvent = new MetadataEvent(MetadataEvent.CUE_POINT);
  632.          _loc2_.info = param1;
  633.          dispatchEvent(_loc2_);
  634.       }
  635.       
  636.       public function ncReconnected() : void
  637.       {
  638.          if(_ncMgr == null || _ncMgr.netConnection == null)
  639.          {
  640.             setState(CONNECTION_ERROR);
  641.          }
  642.          else
  643.          {
  644.             ns = null;
  645.             _state = STOPPED;
  646.             execQueuedCmds();
  647.          }
  648.       }
  649.       
  650.       private function recoverInvalidSeek() : void
  651.       {
  652.          setStateFromCachedState();
  653.          invalidSeekTime = false;
  654.          invalidSeekRecovery = true;
  655.          seek(playheadTime);
  656.       }
  657.       
  658.       public function rtmpOnStatus(param1:NetStatusEvent) : void
  659.       {
  660.          if(_state == CONNECTION_ERROR)
  661.          {
  662.             return;
  663.          }
  664.          switch(param1.info.code)
  665.          {
  666.             case "NetStream.Play.Stop":
  667.                if(startingPlay)
  668.                {
  669.                   return;
  670.                }
  671.                switch(_state)
  672.                {
  673.                   case RESIZING:
  674.                   case LOADING:
  675.                   case STOPPED:
  676.                   case PAUSED:
  677.                      break;
  678.                   default:
  679.                      sawPlayStop = true;
  680.                }
  681.                break;
  682.             case "NetStream.Buffer.Empty":
  683.                switch(bufferState)
  684.                {
  685.                   case BUFFER_FULL:
  686.                      if(sawPlayStop)
  687.                      {
  688.                         rtmpDoStopAtEnd(null);
  689.                      }
  690.                      else if(_state == PLAYING)
  691.                      {
  692.                         setState(BUFFERING);
  693.                      }
  694.                }
  695.                bufferState = BUFFER_EMPTY;
  696.                sawPlayStop = false;
  697.                break;
  698.             case "NetStream.Buffer.Flush":
  699.                if(sawSeekNotify && _state == SEEKING)
  700.                {
  701.                   bufferState = BUFFER_EMPTY;
  702.                   sawPlayStop = false;
  703.                   setStateFromCachedState();
  704.                   doUpdateTime(null);
  705.                }
  706.                if(sawPlayStop && (bufferState == BUFFER_EMPTY || _bufferTime <= 0.1 && ns.bufferLength <= 0.1))
  707.                {
  708.                   cachedPlayheadTime = playheadTime;
  709.                   rtmpDoStopAtEndTimer.start();
  710.                }
  711.                switch(bufferState)
  712.                {
  713.                   case BUFFER_EMPTY:
  714.                      if(_state == LOADING && cachedState == PLAYING || _state == BUFFERING)
  715.                      {
  716.                         setState(PLAYING);
  717.                      }
  718.                      else if(cachedState == BUFFERING)
  719.                      {
  720.                         cachedState = PLAYING;
  721.                      }
  722.                      bufferState = BUFFER_FLUSH;
  723.                      break;
  724.                   default:
  725.                      if(_state == BUFFERING)
  726.                      {
  727.                         setStateFromCachedState();
  728.                      }
  729.                }
  730.                break;
  731.             case "NetStream.Buffer.Full":
  732.                if(sawSeekNotify && _state == SEEKING)
  733.                {
  734.                   bufferState = BUFFER_EMPTY;
  735.                   sawPlayStop = false;
  736.                   setStateFromCachedState();
  737.                   doUpdateTime(null);
  738.                }
  739.                switch(bufferState)
  740.                {
  741.                   case BUFFER_EMPTY:
  742.                      bufferState = BUFFER_FULL;
  743.                      if(_state == LOADING && cachedState == PLAYING || _state == BUFFERING)
  744.                      {
  745.                         setState(PLAYING);
  746.                      }
  747.                      else if(cachedState == BUFFERING)
  748.                      {
  749.                         cachedState = PLAYING;
  750.                      }
  751.                      if(rtmpDoStopAtEndTimer.running)
  752.                      {
  753.                         sawPlayStop = true;
  754.                         rtmpDoStopAtEndTimer.reset();
  755.                      }
  756.                      break;
  757.                   case BUFFER_FLUSH:
  758.                      bufferState = BUFFER_FULL;
  759.                      if(rtmpDoStopAtEndTimer.running)
  760.                      {
  761.                         sawPlayStop = true;
  762.                         rtmpDoStopAtEndTimer.reset();
  763.                      }
  764.                }
  765.                if(_state == BUFFERING)
  766.                {
  767.                   setStateFromCachedState();
  768.                }
  769.                break;
  770.             case "NetStream.Pause.Notify":
  771.                break;
  772.             case "NetStream.Unpause.Notify":
  773.                if(_state == PAUSED)
  774.                {
  775.                   _state = PLAYING;
  776.                   setState(BUFFERING);
  777.                }
  778.                else
  779.                {
  780.                   cachedState = PLAYING;
  781.                }
  782.                break;
  783.             case "NetStream.Play.Start":
  784.                rtmpDoStopAtEndTimer.reset();
  785.                bufferState = BUFFER_EMPTY;
  786.                sawPlayStop = false;
  787.                if(startingPlay)
  788.                {
  789.                   startingPlay = false;
  790.                   cachedPlayheadTime = playheadTime;
  791.                }
  792.                else if(_state == PLAYING)
  793.                {
  794.                   setState(BUFFERING);
  795.                }
  796.                break;
  797.             case "NetStream.Play.Reset":
  798.                rtmpDoStopAtEndTimer.reset();
  799.                if(_state == REWINDING)
  800.                {
  801.                   rtmpDoSeekTimer.reset();
  802.                   if(playheadTime == 0 || playheadTime < cachedPlayheadTime)
  803.                   {
  804.                      setStateFromCachedState();
  805.                   }
  806.                   else
  807.                   {
  808.                      cachedPlayheadTime = playheadTime;
  809.                      rtmpDoSeekTimer.start();
  810.                   }
  811.                }
  812.                break;
  813.             case "NetStream.Seek.Notify":
  814.                if(playheadTime != cachedPlayheadTime)
  815.                {
  816.                   setStateFromCachedState();
  817.                   doUpdateTime(null);
  818.                }
  819.                else
  820.                {
  821.                   sawSeekNotify = true;
  822.                   if(!rtmpDoSeekTimer.running)
  823.                   {
  824.                      rtmpDoSeekTimer.start();
  825.                   }
  826.                }
  827.                break;
  828.             case "Netstream.Play.UnpublishNotify":
  829.             case "Netstream.Play.PublishNotify":
  830.                break;
  831.             case "NetStream.Play.StreamNotFound":
  832.                if(!_ncMgr.connectAgain())
  833.                {
  834.                   setState(CONNECTION_ERROR);
  835.                }
  836.                break;
  837.             case "NetStream.Play.Failed":
  838.             case "NetStream.Failed":
  839.                setState(CONNECTION_ERROR);
  840.          }
  841.       }
  842.       
  843.       public function get totalTime() : Number
  844.       {
  845.          return streamLength;
  846.       }
  847.       
  848.       public function get autoRewind() : Boolean
  849.       {
  850.          return _autoRewind;
  851.       }
  852.       
  853.       override public function set height(param1:Number) : void
  854.       {
  855.          setSize(width,param1);
  856.       }
  857.       
  858.       private function createINCManager() : void
  859.       {
  860.          var _loc1_:Class = ncMgrClassName == null ? DEFAULT_INCMANAGER : ncMgrClassName;
  861.          _ncMgr = new _loc1_();
  862.          _ncMgr.videoPlayer = this;
  863.       }
  864.       
  865.       private function setState(param1:String) : void
  866.       {
  867.          if(param1 == _state)
  868.          {
  869.             return;
  870.          }
  871.          cachedState = _state;
  872.          cachedPlayheadTime = playheadTime;
  873.          _state = param1;
  874.          var _loc2_:String = _state;
  875.          var _loc3_:VideoEvent = new VideoEvent(VideoEvent.STATE_CHANGE);
  876.          _loc3_.state = _loc2_;
  877.          _loc3_.playheadTime = playheadTime;
  878.          dispatchEvent(_loc3_);
  879.          if(!readyDispatched)
  880.          {
  881.             switch(_loc2_)
  882.             {
  883.                case STOPPED:
  884.                case PLAYING:
  885.                case PAUSED:
  886.                case BUFFERING:
  887.                   readyDispatched = true;
  888.                   _loc3_ = new VideoEvent(VideoEvent.READY);
  889.                   _loc3_.state = _loc2_;
  890.                   _loc3_.playheadTime = playheadTime;
  891.                   dispatchEvent(_loc3_);
  892.             }
  893.          }
  894.          switch(cachedState)
  895.          {
  896.             case REWINDING:
  897.                _loc3_ = new VideoEvent(VideoEvent.REWIND);
  898.                _loc3_.state = _loc2_;
  899.                _loc3_.playheadTime = playheadTime;
  900.                dispatchEvent(_loc3_);
  901.                if(_ncMgr.isRTMP() && _loc2_ == STOPPED)
  902.                {
  903.                   closeNS();
  904.                }
  905.          }
  906.          switch(_loc2_)
  907.          {
  908.             case STOPPED:
  909.             case PAUSED:
  910.                if(_ncMgr.isRTMP() && !idleTimeoutTimer.running)
  911.                {
  912.                   idleTimeoutTimer.start();
  913.                }
  914.                break;
  915.             case SEEKING:
  916.             case REWINDING:
  917.                bufferState = BUFFER_EMPTY;
  918.                sawPlayStop = false;
  919.             case PLAYING:
  920.             case BUFFERING:
  921.                if(!updateTimeTimer.running)
  922.                {
  923.                   updateTimeTimer.start();
  924.                }
  925.             case LOADING:
  926.             case RESIZING:
  927.                idleTimeoutTimer.reset();
  928.          }
  929.          execQueuedCmds();
  930.       }
  931.       
  932.       public function httpOnStatus(param1:NetStatusEvent) : void
  933.       {
  934.          switch(param1.info.code)
  935.          {
  936.             case "NetStream.Play.Stop":
  937.                delayedBufferingTimer.reset();
  938.                if(invalidSeekTime)
  939.                {
  940.                   recoverInvalidSeek();
  941.                }
  942.                else
  943.                {
  944.                   switch(_state)
  945.                   {
  946.                      case PLAYING:
  947.                      case BUFFERING:
  948.                      case SEEKING:
  949.                         httpDoStopAtEnd();
  950.                   }
  951.                }
  952.                break;
  953.             case "NetStream.Seek.InvalidTime":
  954.                if(invalidSeekRecovery)
  955.                {
  956.                   invalidSeekTime = false;
  957.                   invalidSeekRecovery = false;
  958.                   setState(cachedState);
  959.                   seek(0);
  960.                }
  961.                else
  962.                {
  963.                   recoverInvalidSeek();
  964.                }
  965.                break;
  966.             case "NetStream.Buffer.Empty":
  967.                bufferState = BUFFER_EMPTY;
  968.                if(_state == PLAYING)
  969.                {
  970.                   delayedBufferingTimer.start();
  971.                }
  972.                break;
  973.             case "NetStream.Buffer.Full":
  974.             case "NetStream.Buffer.Flush":
  975.                delayedBufferingTimer.reset();
  976.                bufferState = BUFFER_FULL;
  977.                if(_state == LOADING && cachedState == PLAYING || _state == BUFFERING)
  978.                {
  979.                   setState(PLAYING);
  980.                }
  981.                else if(cachedState == BUFFERING)
  982.                {
  983.                   cachedState = PLAYING;
  984.                }
  985.                break;
  986.             case "NetStream.Seek.Notify":
  987.                invalidSeekRecovery = false;
  988.                switch(_state)
  989.                {
  990.                   case SEEKING:
  991.                   case REWINDING:
  992.                      if(!httpDoSeekTimer.running)
  993.                      {
  994.                         httpDoSeekCount = 0;
  995.                         httpDoSeekTimer.start();
  996.                      }
  997.                }
  998.                break;
  999.             case "NetStream.Play.StreamNotFound":
  1000.                setState(CONNECTION_ERROR);
  1001.          }
  1002.       }
  1003.       
  1004.       public function set bufferTime(param1:Number) : void
  1005.       {
  1006.          _bufferTime = param1;
  1007.          if(ns != null)
  1008.          {
  1009.             ns.bufferTime = _bufferTime;
  1010.          }
  1011.       }
  1012.       
  1013.       public function onMetaData(param1:Object) : void
  1014.       {
  1015.          if(_metadata != null)
  1016.          {
  1017.             return;
  1018.          }
  1019.          _metadata = param1;
  1020.          if(isNaN(streamLength) || streamLength <= 0)
  1021.          {
  1022.             streamLength = param1.duration;
  1023.          }
  1024.          if(isNaN(internalVideoWidth) || internalVideoWidth <= 0)
  1025.          {
  1026.             internalVideoWidth = param1.width;
  1027.          }
  1028.          if(isNaN(internalVideoHeight) || internalVideoHeight <= 0)
  1029.          {
  1030.             internalVideoHeight = param1.height;
  1031.          }
  1032.          var _loc2_:MetadataEvent = new MetadataEvent(MetadataEvent.METADATA_RECEIVED);
  1033.          _loc2_.info = param1;
  1034.          dispatchEvent(_loc2_);
  1035.       }
  1036.       
  1037.       private function setStateFromCachedState() : void
  1038.       {
  1039.          switch(cachedState)
  1040.          {
  1041.             case PLAYING:
  1042.             case PAUSED:
  1043.                setState(cachedState);
  1044.                break;
  1045.             case BUFFERING:
  1046.                if(bufferState == BUFFER_EMPTY)
  1047.                {
  1048.                   setState(BUFFERING);
  1049.                }
  1050.                else
  1051.                {
  1052.                   setState(cachedState);
  1053.                }
  1054.                break;
  1055.             default:
  1056.                setState(STOPPED);
  1057.          }
  1058.       }
  1059.       
  1060.       public function get bytesLoaded() : int
  1061.       {
  1062.          if(ns == null || _ncMgr.isRTMP())
  1063.          {
  1064.             return -1;
  1065.          }
  1066.          return ns.bytesLoaded;
  1067.       }
  1068.       
  1069.       private function doIdleTimeout(param1:Event) : void
  1070.       {
  1071.          idleTimeoutTimer.reset();
  1072.          close();
  1073.       }
  1074.       
  1075.       private function doDelayedBuffering(param1:Event) : void
  1076.       {
  1077.          switch(_state)
  1078.          {
  1079.             case LOADING:
  1080.             case RESIZING:
  1081.                break;
  1082.             case PLAYING:
  1083.                delayedBufferingTimer.reset();
  1084.                setState(BUFFERING);
  1085.                break;
  1086.             default:
  1087.                delayedBufferingTimer.reset();
  1088.          }
  1089.       }
  1090.       
  1091.       public function get url() : String
  1092.       {
  1093.          return _url;
  1094.       }
  1095.       
  1096.       private function queueCmd(param1:uint, param2:String = null, param3:Boolean = false, param4:Number = 0) : void
  1097.       {
  1098.          cmdQueue.push(new VideoPlayerQueuedCommand(param1,param2,param3,param4));
  1099.       }
  1100.       
  1101.       override public function get visible() : Boolean
  1102.       {
  1103.          _visible = super.visible;
  1104.          return _visible;
  1105.       }
  1106.       
  1107.       private function rtmpDoSeek() : void
  1108.       {
  1109.          if(_state != REWINDING && _state != SEEKING)
  1110.          {
  1111.             rtmpDoSeekTimer.reset();
  1112.             sawSeekNotify = false;
  1113.          }
  1114.          else if(playheadTime != cachedPlayheadTime)
  1115.          {
  1116.             rtmpDoSeekTimer.reset();
  1117.             sawSeekNotify = false;
  1118.             setStateFromCachedState();
  1119.             doUpdateTime(null);
  1120.          }
  1121.       }
  1122.       
  1123.       private function setUpStream() : void
  1124.       {
  1125.          if(!isNaN(_ncMgr.streamLength) && _ncMgr.streamLength >= 0)
  1126.          {
  1127.             streamLength = _ncMgr.streamLength;
  1128.          }
  1129.          if(!isNaN(_ncMgr.streamWidth) && _ncMgr.streamWidth >= 0)
  1130.          {
  1131.             internalVideoWidth = _ncMgr.streamWidth;
  1132.          }
  1133.          else
  1134.          {
  1135.             internalVideoWidth = -1;
  1136.          }
  1137.          if(!isNaN(_ncMgr.streamHeight) && _ncMgr.streamHeight >= 0)
  1138.          {
  1139.             internalVideoHeight = _ncMgr.streamHeight;
  1140.          }
  1141.          else
  1142.          {
  1143.             internalVideoHeight = -1;
  1144.          }
  1145.          if(autoPlay)
  1146.          {
  1147.             if(!_ncMgr.isRTMP())
  1148.             {
  1149.                cachedState = BUFFERING;
  1150.                _play();
  1151.             }
  1152.             else if(_isLive)
  1153.             {
  1154.                cachedState = BUFFERING;
  1155.                _play(-1);
  1156.             }
  1157.             else
  1158.             {
  1159.                cachedState = BUFFERING;
  1160.                _play(0);
  1161.             }
  1162.          }
  1163.          else
  1164.          {
  1165.             cachedState = STOPPED;
  1166.             if(_ncMgr.isRTMP())
  1167.             {
  1168.                _play(-2,0);
  1169.             }
  1170.             else
  1171.             {
  1172.                _play();
  1173.                _pause(true);
  1174.                _seek(0);
  1175.             }
  1176.          }
  1177.          autoResizeTimer.reset();
  1178.          autoResizeTimer.start();
  1179.       }
  1180.       
  1181.       public function seek(param1:Number) : void
  1182.       {
  1183.          if(invalidSeekTime)
  1184.          {
  1185.             return;
  1186.          }
  1187.          if(isNaN(param1) || param1 < 0)
  1188.          {
  1189.             throw new VideoError(VideoError.INVALID_SEEK);
  1190.          }
  1191.          if(!isXnOK())
  1192.          {
  1193.             if(_state == CONNECTION_ERROR || _ncMgr == null || _ncMgr.netConnection == null)
  1194.             {
  1195.                throw new VideoError(VideoError.NO_CONNECTION);
  1196.             }
  1197.             flushQueuedCmds();
  1198.             queueCmd(VideoPlayerQueuedCommand.SEEK,null,false,param1);
  1199.             setState(LOADING);
  1200.             cachedState = LOADING;
  1201.             _ncMgr.reconnect();
  1202.             return;
  1203.          }
  1204.          if(_state == EXEC_QUEUED_CMD)
  1205.          {
  1206.             _state = cachedState;
  1207.          }
  1208.          else
  1209.          {
  1210.             if(!stateResponsive)
  1211.             {
  1212.                queueCmd(VideoPlayerQueuedCommand.SEEK,null,false,param1);
  1213.                return;
  1214.             }
  1215.             execQueuedCmds();
  1216.          }
  1217.          if(ns == null)
  1218.          {
  1219.             createStream();
  1220.             attachNetStream(ns);
  1221.          }
  1222.          if(atEnd && param1 <= playheadTime)
  1223.          {
  1224.             atEnd = false;
  1225.          }
  1226.          switch(_state)
  1227.          {
  1228.             case PLAYING:
  1229.                _state = BUFFERING;
  1230.             case BUFFERING:
  1231.             case PAUSED:
  1232.                _seek(param1);
  1233.                setState(SEEKING);
  1234.                break;
  1235.             case STOPPED:
  1236.                if(_ncMgr.isRTMP())
  1237.                {
  1238.                   _play(0);
  1239.                   _pause(true);
  1240.                }
  1241.                _seek(param1);
  1242.                _state = PAUSED;
  1243.                setState(SEEKING);
  1244.          }
  1245.       }
  1246.       
  1247.       public function doUpdateProgress(param1:Event) : void
  1248.       {
  1249.          if(ns == null)
  1250.          {
  1251.             return;
  1252.          }
  1253.          if(ns.bytesTotal >= 0 && ns.bytesLoaded != _priorBytesLoaded)
  1254.          {
  1255.             dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS,false,false,ns.bytesLoaded,ns.bytesTotal));
  1256.          }
  1257.          if(_state == DISCONNECTED || _state == CONNECTION_ERROR || ns.bytesLoaded == ns.bytesTotal)
  1258.          {
  1259.             updateProgressTimer.reset();
  1260.          }
  1261.          _priorBytesLoaded = ns.bytesLoaded;
  1262.       }
  1263.       
  1264.       override public function get videoHeight() : int
  1265.       {
  1266.          if(internalVideoHeight > 0)
  1267.          {
  1268.             return internalVideoHeight;
  1269.          }
  1270.          if(metadata != null && !isNaN(metadata.width) && !isNaN(metadata.height))
  1271.          {
  1272.             if(metadata.width == metadata.height && readyDispatched)
  1273.             {
  1274.                return super.videoHeight;
  1275.             }
  1276.             return int(metadata.height);
  1277.          }
  1278.          if(readyDispatched)
  1279.          {
  1280.             return super.videoHeight;
  1281.          }
  1282.          return -1;
  1283.       }
  1284.       
  1285.       override public function set width(param1:Number) : void
  1286.       {
  1287.          setSize(param1,height);
  1288.       }
  1289.       
  1290.       private function _seek(param1:Number) : void
  1291.       {
  1292.          rtmpDoStopAtEndTimer.reset();
  1293.          var _loc2_:Number = Math.round(param1 * 1000) / 1000;
  1294.          if(_metadata && _metadata.audiodelay && param1 + _metadata.audiodelay < streamLength)
  1295.          {
  1296.             param1 += _metadata.audiodelay;
  1297.          }
  1298.          ns.seek(param1);
  1299.          invalidSeekTime = false;
  1300.          bufferState = BUFFER_EMPTY;
  1301.          sawPlayStop = false;
  1302.          sawSeekNotify = false;
  1303.       }
  1304.       
  1305.       public function get isRTMP() : Boolean
  1306.       {
  1307.          if(_ncMgr == null)
  1308.          {
  1309.             return true;
  1310.          }
  1311.          return _ncMgr.isRTMP();
  1312.       }
  1313.       
  1314.       public function get state() : String
  1315.       {
  1316.          return _state;
  1317.       }
  1318.       
  1319.       public function get bytesTotal() : int
  1320.       {
  1321.          if(ns == null || _ncMgr.isRTMP())
  1322.          {
  1323.             return -1;
  1324.          }
  1325.          return ns.bytesTotal;
  1326.       }
  1327.       
  1328.       public function set autoRewind(param1:Boolean) : void
  1329.       {
  1330.          _autoRewind = param1;
  1331.       }
  1332.       
  1333.       override public function set scaleX(param1:Number) : void
  1334.       {
  1335.          setScale(param1,this.scaleY);
  1336.       }
  1337.       
  1338.       private function finishAutoResize(param1:Event) : void
  1339.       {
  1340.          finishAutoResizeTimer.reset();
  1341.          if(stateResponsive)
  1342.          {
  1343.             return;
  1344.          }
  1345.          super.visible = _visible;
  1346.          _soundTransform.volume = _volume;
  1347.          ns.soundTransform = _soundTransform;
  1348.          if(autoPlay)
  1349.          {
  1350.             if(_ncMgr.isRTMP())
  1351.             {
  1352.                if(!_isLive)
  1353.                {
  1354.                   currentPos = 0;
  1355.                   _play(0);
  1356.                }
  1357.                if(_state == RESIZING)
  1358.                {
  1359.                   setState(LOADING);
  1360.                   cachedState = PLAYING;
  1361.                }
  1362.             }
  1363.             else
  1364.             {
  1365.                _pause(false);
  1366.                cachedState = PLAYING;
  1367.             }
  1368.          }
  1369.          else
  1370.          {
  1371.             setState(STOPPED);
  1372.          }
  1373.       }
  1374.       
  1375.       private function isXnOK() : Boolean
  1376.       {
  1377.          if(_state == LOADING)
  1378.          {
  1379.             return true;
  1380.          }
  1381.          if(_state == CONNECTION_ERROR)
  1382.          {
  1383.             return false;
  1384.          }
  1385.          if(_state != DISCONNECTED)
  1386.          {
  1387.             if(_ncMgr == null || _ncMgr.netConnection == null || !_ncMgr.netConnection.connected)
  1388.             {
  1389.                setState(DISCONNECTED);
  1390.                return false;
  1391.             }
  1392.             return true;
  1393.          }
  1394.          return false;
  1395.       }
  1396.       
  1397.       private function doSeek(param1:Event) : void
  1398.       {
  1399.          var _loc2_:Boolean = _state == REWINDING || _state == SEEKING;
  1400.          if(_loc2_ && httpDoSeekCount < HTTP_DO_SEEK_MAX_COUNT && (cachedPlayheadTime == playheadTime || invalidSeekTime))
  1401.          {
  1402.             ++httpDoSeekCount;
  1403.             return;
  1404.          }
  1405.          httpDoSeekCount = 0;
  1406.          httpDoSeekTimer.reset();
  1407.          if(!_loc2_)
  1408.          {
  1409.             return;
  1410.          }
  1411.          if(invalidSeekTime)
  1412.          {
  1413.             recoverInvalidSeek();
  1414.          }
  1415.          else
  1416.          {
  1417.             setStateFromCachedState();
  1418.             doUpdateTime(null);
  1419.          }
  1420.       }
  1421.       
  1422.       private function createStream() : void
  1423.       {
  1424.          ns = new VideoPlayerNetStream(_ncMgr.netConnection,this);
  1425.          ns.bufferTime = _bufferTime;
  1426.          ns.soundTransform = _soundTransform;
  1427.          ns.addEventListener(NetStatusEvent.NET_STATUS,_ncMgr.isRTMP() ? rtmpOnStatus : httpOnStatus);
  1428.          attachNetStream(ns);
  1429.       }
  1430.       
  1431.       public function setSize(param1:Number, param2:Number) : void
  1432.       {
  1433.          if(param1 == width && param2 == height)
  1434.          {
  1435.             return;
  1436.          }
  1437.          super.width = param1;
  1438.          super.height = param2;
  1439.       }
  1440.       
  1441.       private function flushQueuedCmds() : void
  1442.       {
  1443.          while(cmdQueue.length > 0)
  1444.          {
  1445.             cmdQueue.pop();
  1446.          }
  1447.       }
  1448.       
  1449.       override public function set scaleY(param1:Number) : void
  1450.       {
  1451.          setScale(this.scaleX,param1);
  1452.       }
  1453.       
  1454.       public function ncConnected() : void
  1455.       {
  1456.          if(_ncMgr == null || _ncMgr.netConnection == null)
  1457.          {
  1458.             setState(CONNECTION_ERROR);
  1459.          }
  1460.          else
  1461.          {
  1462.             createStream();
  1463.             setUpStream();
  1464.          }
  1465.       }
  1466.       
  1467.       private function closeNS(param1:Boolean = true) : void
  1468.       {
  1469.          if(ns != null)
  1470.          {
  1471.             if(param1)
  1472.             {
  1473.                updateTimeTimer.reset();
  1474.                doUpdateTime(null);
  1475.                currentPos = ns.time;
  1476.             }
  1477.             ns.removeEventListener(NetStatusEvent.NET_STATUS,httpOnStatus);
  1478.             ns.removeEventListener(NetStatusEvent.NET_STATUS,rtmpOnStatus);
  1479.             ns.close();
  1480.             ns = null;
  1481.          }
  1482.       }
  1483.       
  1484.       private function rtmpDoStopAtEnd(param1:TimerEvent) : void
  1485.       {
  1486.          if(param1 != null)
  1487.          {
  1488.             switch(_state)
  1489.             {
  1490.                case DISCONNECTED:
  1491.                case CONNECTION_ERROR:
  1492.                   rtmpDoStopAtEndTimer.reset();
  1493.                   return;
  1494.                default:
  1495.                   if(cachedPlayheadTime != playheadTime)
  1496.                   {
  1497.                      cachedPlayheadTime = playheadTime;
  1498.                      return;
  1499.                   }
  1500.                   rtmpDoStopAtEndTimer.reset();
  1501.             }
  1502.          }
  1503.          bufferState = BUFFER_EMPTY;
  1504.          sawPlayStop = false;
  1505.          atEnd = true;
  1506.          setState(STOPPED);
  1507.          if(_state != STOPPED)
  1508.          {
  1509.             return;
  1510.          }
  1511.          doUpdateTime(null);
  1512.          if(_state != STOPPED)
  1513.          {
  1514.             return;
  1515.          }
  1516.          var _loc2_:VideoEvent = new VideoEvent(VideoEvent.COMPLETE);
  1517.          _loc2_.state = _state;
  1518.          _loc2_.playheadTime = playheadTime;
  1519.          dispatchEvent(_loc2_);
  1520.          if(_state != STOPPED)
  1521.          {
  1522.             return;
  1523.          }
  1524.          if(_autoRewind && !_isLive && playheadTime != 0)
  1525.          {
  1526.             atEnd = false;
  1527.             currentPos = 0;
  1528.             _play(0,0);
  1529.             setState(REWINDING);
  1530.          }
  1531.          else
  1532.          {
  1533.             closeNS();
  1534.          }
  1535.       }
  1536.       
  1537.       public function set idleTimeout(param1:uint) : void
  1538.       {
  1539.          idleTimeoutTimer.delay = param1;
  1540.       }
  1541.       
  1542.       public function set playheadUpdateInterval(param1:uint) : void
  1543.       {
  1544.          updateTimeTimer.delay = param1;
  1545.       }
  1546.       
  1547.       private function _load(param1:String, param2:Boolean, param3:Number) : void
  1548.       {
  1549.          if(prevVideoWidth == -1)
  1550.          {
  1551.             if(videoWidth >= 0)
  1552.             {
  1553.                prevVideoWidth = videoWidth;
  1554.             }
  1555.             else
  1556.             {
  1557.                prevVideoWidth = 0;
  1558.             }
  1559.          }
  1560.          if(prevVideoHeight == -1)
  1561.          {
  1562.             if(videoHeight >= 0)
  1563.             {
  1564.                prevVideoHeight = videoHeight;
  1565.             }
  1566.             else
  1567.             {
  1568.                prevVideoHeight = 0;
  1569.             }
  1570.          }
  1571.          cachedPlayheadTime = 0;
  1572.          bufferState = BUFFER_EMPTY;
  1573.          sawPlayStop = false;
  1574.          _metadata = null;
  1575.          startingPlay = false;
  1576.          invalidSeekRecovery = false;
  1577.          invalidSeekTime = false;
  1578.          _isLive = param2;
  1579.          _url = param1;
  1580.          currentPos = 0;
  1581.          streamLength = param3;
  1582.          atEnd = false;
  1583.          internalVideoWidth = -1;
  1584.          internalVideoHeight = -1;
  1585.          readyDispatched = false;
  1586.          lastUpdateTime = -1;
  1587.          sawSeekNotify = false;
  1588.          updateTimeTimer.reset();
  1589.          updateProgressTimer.reset();
  1590.          idleTimeoutTimer.reset();
  1591.          autoResizeTimer.reset();
  1592.          rtmpDoStopAtEndTimer.reset();
  1593.          rtmpDoSeekTimer.reset();
  1594.          httpDoSeekTimer.reset();
  1595.          finishAutoResizeTimer.reset();
  1596.          delayedBufferingTimer.reset();
  1597.          closeNS(false);
  1598.          if(_ncMgr == null)
  1599.          {
  1600.             createINCManager();
  1601.          }
  1602.          var _loc4_:Boolean = _ncMgr.connectToURL(_url);
  1603.          setState(LOADING);
  1604.          cachedState = LOADING;
  1605.          if(_loc4_)
  1606.          {
  1607.             createStream();
  1608.             setUpStream();
  1609.          }
  1610.          if(!_ncMgr.isRTMP())
  1611.          {
  1612.             updateProgressTimer.start();
  1613.          }
  1614.       }
  1615.       
  1616.       public function get playheadUpdateInterval() : uint
  1617.       {
  1618.          return updateTimeTimer.delay;
  1619.       }
  1620.       
  1621.       override public function set visible(param1:Boolean) : void
  1622.       {
  1623.          _visible = param1;
  1624.          super.visible = _visible;
  1625.       }
  1626.       
  1627.       public function load(param1:String, param2:Boolean = false, param3:Number = -1) : void
  1628.       {
  1629.          var _loc4_:String = null;
  1630.          if(param1 == null)
  1631.          {
  1632.             _loc4_ = resourceManager.getString("controls","nullURL");
  1633.             throw new ArgumentError(_loc4_);
  1634.          }
  1635.          if(_state == EXEC_QUEUED_CMD)
  1636.          {
  1637.             _state = cachedState;
  1638.          }
  1639.          else
  1640.          {
  1641.             if(!stateResponsive)
  1642.             {
  1643.                queueCmd(VideoPlayerQueuedCommand.LOAD,param1,param2,param3);
  1644.                return;
  1645.             }
  1646.             execQueuedCmds();
  1647.          }
  1648.          autoPlay = false;
  1649.          _load(param1,param2,param3);
  1650.       }
  1651.       
  1652.       private function httpDoStopAtEnd() : void
  1653.       {
  1654.          atEnd = true;
  1655.          if(isNaN(streamLength) || streamLength <= 0)
  1656.          {
  1657.             streamLength = ns.time;
  1658.          }
  1659.          _pause(true);
  1660.          setState(STOPPED);
  1661.          if(_state != STOPPED)
  1662.          {
  1663.             return;
  1664.          }
  1665.          doUpdateTime(null);
  1666.          if(_state != STOPPED)
  1667.          {
  1668.             return;
  1669.          }
  1670.          var _loc1_:VideoEvent = new VideoEvent(VideoEvent.COMPLETE);
  1671.          _loc1_.state = _state;
  1672.          _loc1_.playheadTime = playheadTime;
  1673.          dispatchEvent(_loc1_);
  1674.          if(_state != STOPPED)
  1675.          {
  1676.             return;
  1677.          }
  1678.          if(_autoRewind)
  1679.          {
  1680.             atEnd = false;
  1681.             _pause(true);
  1682.             _seek(0);
  1683.             setState(REWINDING);
  1684.          }
  1685.       }
  1686.       
  1687.       public function get idleTimeout() : uint
  1688.       {
  1689.          return idleTimeoutTimer.delay;
  1690.       }
  1691.       
  1692.       public function pause() : void
  1693.       {
  1694.          if(!isXnOK())
  1695.          {
  1696.             if(_state == CONNECTION_ERROR || _ncMgr == null || _ncMgr.netConnection == null)
  1697.             {
  1698.                throw new VideoError(VideoError.NO_CONNECTION);
  1699.             }
  1700.             return;
  1701.          }
  1702.          if(_state == EXEC_QUEUED_CMD)
  1703.          {
  1704.             _state = cachedState;
  1705.          }
  1706.          else
  1707.          {
  1708.             if(!stateResponsive)
  1709.             {
  1710.                queueCmd(VideoPlayerQueuedCommand.PAUSE);
  1711.                return;
  1712.             }
  1713.             execQueuedCmds();
  1714.          }
  1715.          if(_state == PAUSED || _state == STOPPED || ns == null)
  1716.          {
  1717.             return;
  1718.          }
  1719.          _pause(true);
  1720.          setState(PAUSED);
  1721.       }
  1722.       
  1723.       private function execQueuedCmds() : void
  1724.       {
  1725.          var _loc1_:VideoPlayerQueuedCommand = null;
  1726.          while(cmdQueue.length > 0 && (stateResponsive || _state == CONNECTION_ERROR) && (cmdQueue[0].url != null || _state != DISCONNECTED && _state != CONNECTION_ERROR))
  1727.          {
  1728.             _loc1_ = cmdQueue.shift();
  1729.             cachedState = _state;
  1730.             _state = EXEC_QUEUED_CMD;
  1731.             switch(_loc1_.type)
  1732.             {
  1733.                case VideoPlayerQueuedCommand.PLAY:
  1734.                   play(_loc1_.url,_loc1_.isLive,_loc1_.time);
  1735.                   break;
  1736.                case VideoPlayerQueuedCommand.LOAD:
  1737.                   load(_loc1_.url,_loc1_.isLive,_loc1_.time);
  1738.                   break;
  1739.                case VideoPlayerQueuedCommand.PAUSE:
  1740.                   pause();
  1741.                   break;
  1742.                case VideoPlayerQueuedCommand.STOP:
  1743.                   stop();
  1744.                   break;
  1745.                case VideoPlayerQueuedCommand.SEEK:
  1746.                   seek(_loc1_.time);
  1747.                   break;
  1748.             }
  1749.          }
  1750.       }
  1751.       
  1752.       private function _pause(param1:Boolean) : void
  1753.       {
  1754.          rtmpDoStopAtEndTimer.reset();
  1755.          if(param1)
  1756.          {
  1757.             ns.pause();
  1758.          }
  1759.          else
  1760.          {
  1761.             ns.resume();
  1762.          }
  1763.       }
  1764.       
  1765.       public function close() : void
  1766.       {
  1767.          closeNS();
  1768.          if(_ncMgr != null && _ncMgr.isRTMP())
  1769.          {
  1770.             _ncMgr.close();
  1771.          }
  1772.          setState(DISCONNECTED);
  1773.          var _loc1_:VideoEvent = new VideoEvent(VideoEvent.CLOSE);
  1774.          _loc1_.state = _state;
  1775.          _loc1_.playheadTime = playheadTime;
  1776.          dispatchEvent(_loc1_);
  1777.       }
  1778.    }
  1779. }
  1780.  
  1781. import flash.net.NetConnection;
  1782. import flash.net.NetStream;
  1783.  
  1784. dynamic class VideoPlayerNetStream extends NetStream
  1785. {
  1786.    private var videoPlayer:VideoPlayer;
  1787.    
  1788.    public function VideoPlayerNetStream(param1:NetConnection, param2:VideoPlayer)
  1789.    {
  1790.       super(param1);
  1791.       this.videoPlayer = param2;
  1792.    }
  1793.    
  1794.    public function onCuePoint(param1:Object, ... rest) : void
  1795.    {
  1796.       videoPlayer.onCuePoint(param1);
  1797.    }
  1798.    
  1799.    public function onPlayStatus(... rest) : void
  1800.    {
  1801.    }
  1802.    
  1803.    public function onMetaData(param1:Object, ... rest) : void
  1804.    {
  1805.       videoPlayer.onMetaData(param1);
  1806.    }
  1807. }
  1808.