mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-18 17:27:50 -05:00
1087 lines
36 KiB
ActionScript
1087 lines
36 KiB
ActionScript
package org.osmf.net.httpstreaming
|
|
{
|
|
import flash.events.Event;
|
|
import flash.events.NetStatusEvent;
|
|
import flash.events.ProgressEvent;
|
|
import flash.events.TimerEvent;
|
|
import flash.net.NetConnection;
|
|
import flash.net.NetStream;
|
|
import flash.net.NetStreamPlayOptions;
|
|
import flash.net.URLLoader;
|
|
import flash.net.URLStream;
|
|
import flash.utils.ByteArray;
|
|
import flash.utils.IDataInput;
|
|
import flash.utils.Timer;
|
|
import org.osmf.events.DVRStreamInfoEvent;
|
|
import org.osmf.events.HTTPStreamingFileHandlerEvent;
|
|
import org.osmf.events.HTTPStreamingIndexHandlerEvent;
|
|
import org.osmf.net.httpstreaming.dvr.DVRInfo;
|
|
import org.osmf.net.httpstreaming.flv.FLVHeader;
|
|
import org.osmf.net.httpstreaming.flv.FLVParser;
|
|
import org.osmf.net.httpstreaming.flv.FLVTag;
|
|
import org.osmf.net.httpstreaming.flv.FLVTagAudio;
|
|
import org.osmf.net.httpstreaming.flv.FLVTagScriptDataObject;
|
|
import org.osmf.net.httpstreaming.flv.FLVTagVideo;
|
|
|
|
public class HTTPNetStream extends NetStream
|
|
{
|
|
|
|
private static const MAIN_TIMER_INTERVAL:int = 25;
|
|
|
|
private var _indexInfo:HTTPStreamingIndexInfoBase = null;
|
|
|
|
private var _numQualityLevels:int = 0;
|
|
|
|
private var _qualityRates:Array;
|
|
|
|
private var _streamNames:Array;
|
|
|
|
private var _segmentDuration:Number = -1;
|
|
|
|
private var _urlStreamVideo:URLStream = null;
|
|
|
|
private var _loadComplete:Boolean = false;
|
|
|
|
private var mainTimer:Timer;
|
|
|
|
private var _dataAvailable:Boolean = false;
|
|
|
|
private var _qualityLevel:int = 0;
|
|
|
|
private var qualityLevelHasChanged:Boolean = false;
|
|
|
|
private var _seekTarget:Number = -1;
|
|
|
|
private var _lastDownloadStartTime:Number = -1;
|
|
|
|
private var _lastDownloadDuration:Number;
|
|
|
|
private var _lastDownloadRatio:Number = 0;
|
|
|
|
private var _manualSwitchMode:Boolean = false;
|
|
|
|
private var _aggressiveUpswitch:Boolean = true;
|
|
|
|
private var indexHandler:HTTPStreamingIndexHandlerBase;
|
|
|
|
private var fileHandler:HTTPStreamingFileHandlerBase;
|
|
|
|
private var _totalDuration:Number = -1;
|
|
|
|
private var _enhancedSeekTarget:Number = -1;
|
|
|
|
private var _enhancedSeekEnabled:Boolean = false;
|
|
|
|
private var _enhancedSeekTags:Vector.<FLVTagVideo>;
|
|
|
|
private var _flvParserIsSegmentStart:Boolean = false;
|
|
|
|
private var _savedBytes:ByteArray = null;
|
|
|
|
private var _state:String = "init";
|
|
|
|
private var _prevState:String = null;
|
|
|
|
private var _seekAfterInit:Boolean;
|
|
|
|
private var indexIsReady:Boolean = false;
|
|
|
|
private var _insertScriptDataTags:Vector.<FLVTagScriptDataObject> = null;
|
|
|
|
private var _flvParser:FLVParser = null;
|
|
|
|
private var _flvParserDone:Boolean = true;
|
|
|
|
private var _flvParserProcessed:uint;
|
|
|
|
private var _initialTime:Number = -1;
|
|
|
|
private var _seekTime:Number = -1;
|
|
|
|
private var _fileTimeAdjustment:Number = 0;
|
|
|
|
private var _playForDuration:Number = -1;
|
|
|
|
private var _lastValidTimeTime:Number = 0;
|
|
|
|
private var _retryAfterWaitUntil:Number = 0;
|
|
|
|
private var _dvrInfo:DVRInfo = null;
|
|
|
|
private var _unpublishNotifyPending:Boolean = false;
|
|
|
|
private var _signalPlayStartPending:Boolean = false;
|
|
|
|
public function HTTPNetStream(param1:NetConnection, param2:HTTPStreamingIndexHandlerBase, param3:HTTPStreamingFileHandlerBase)
|
|
{
|
|
super(param1);
|
|
_savedBytes = new ByteArray();
|
|
this.indexHandler = param2;
|
|
this.fileHandler = param3;
|
|
param2.addEventListener("notifyIndexReady",onIndexReady);
|
|
param2.addEventListener("notifyRates",onRates);
|
|
param2.addEventListener("requestLoadIndex",onRequestLoadIndexFile);
|
|
param2.addEventListener("notifyError",onIndexError);
|
|
param2.addEventListener("notifySegmentDuration",onSegmentDurationFromIndexHandler);
|
|
param2.addEventListener("notifyScriptData",onScriptDataFromIndexHandler);
|
|
param2.addEventListener("DVRStreamInfo",onDVRStreamInfo);
|
|
param3.addEventListener("notifySegmentDuration",onSegmentDurationFromFileHandler);
|
|
param3.addEventListener("notifyScriptData",onScriptDataFromFileHandler);
|
|
param3.addEventListener("notifyError",onErrorFromFileHandler);
|
|
mainTimer = new Timer(25);
|
|
mainTimer.addEventListener("timer",onMainTimer);
|
|
mainTimer.start();
|
|
this.addEventListener("netStatus",onNetStatus);
|
|
}
|
|
|
|
public function set enhancedSeek(param1:Boolean) : void
|
|
{
|
|
_enhancedSeekEnabled = param1;
|
|
}
|
|
|
|
public function get enhancedSeek() : Boolean
|
|
{
|
|
return _enhancedSeekEnabled;
|
|
}
|
|
|
|
public function get downloadRatio() : Number
|
|
{
|
|
return _lastDownloadRatio;
|
|
}
|
|
|
|
public function set qualityLevel(param1:int) : void
|
|
{
|
|
if(_manualSwitchMode)
|
|
{
|
|
setQualityLevel(param1);
|
|
return;
|
|
}
|
|
throw new Error("qualityLevel cannot be set to this value at this time");
|
|
}
|
|
|
|
public function get qualityLevel() : int
|
|
{
|
|
return _qualityLevel;
|
|
}
|
|
|
|
public function get manualSwitchMode() : Boolean
|
|
{
|
|
return _manualSwitchMode;
|
|
}
|
|
|
|
public function set manualSwitchMode(param1:Boolean) : void
|
|
{
|
|
_manualSwitchMode = param1;
|
|
}
|
|
|
|
public function get indexInfo() : HTTPStreamingIndexInfoBase
|
|
{
|
|
return _indexInfo;
|
|
}
|
|
|
|
public function set indexInfo(param1:HTTPStreamingIndexInfoBase) : void
|
|
{
|
|
_indexInfo = param1;
|
|
}
|
|
|
|
public function DVRGetStreamInfo(param1:Object) : void
|
|
{
|
|
if(!indexIsReady)
|
|
{
|
|
indexHandler.dvrGetStreamInfo(_indexInfo != null ? _indexInfo : param1);
|
|
}
|
|
}
|
|
|
|
override public function play(... rest) : void
|
|
{
|
|
if(rest.length < 1)
|
|
{
|
|
throw new Error("HTTPStream.play() requires at least one argument");
|
|
}
|
|
super.play(null);
|
|
_signalPlayStartPending = true;
|
|
var _loc3_:FLVHeader = new FLVHeader();
|
|
var _loc2_:ByteArray = new ByteArray();
|
|
_loc3_.write(_loc2_);
|
|
attemptAppendBytes(_loc2_);
|
|
setState("init");
|
|
_initialTime = -1;
|
|
_seekTime = -1;
|
|
indexIsReady = false;
|
|
indexHandler.initialize(_indexInfo != null ? _indexInfo : rest[0]);
|
|
if(rest.length >= 2)
|
|
{
|
|
_seekTarget = Number(rest[1]);
|
|
if(_seekTarget < 0)
|
|
{
|
|
if(_dvrInfo != null)
|
|
{
|
|
_seekTarget = _dvrInfo.startTime;
|
|
}
|
|
else
|
|
{
|
|
_seekTarget = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_seekTarget = 0;
|
|
}
|
|
if(rest.length >= 3)
|
|
{
|
|
_playForDuration = Number(rest[2]);
|
|
}
|
|
else
|
|
{
|
|
_playForDuration = -1;
|
|
}
|
|
_unpublishNotifyPending = false;
|
|
}
|
|
|
|
private function signalPlayStart() : void
|
|
{
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.Start",
|
|
"level":"status"
|
|
}));
|
|
}
|
|
|
|
override public function play2(param1:NetStreamPlayOptions) : void
|
|
{
|
|
if(param1.transition == "reset")
|
|
{
|
|
setQualityLevelForStreamName(param1.streamName);
|
|
play(param1.streamName,param1.start,param1.len);
|
|
}
|
|
else if(param1.transition == "switch")
|
|
{
|
|
setQualityLevelForStreamName(param1.streamName);
|
|
}
|
|
else
|
|
{
|
|
super.play2(param1);
|
|
}
|
|
}
|
|
|
|
override public function seek(param1:Number) : void
|
|
{
|
|
if(param1 < 0)
|
|
{
|
|
param1 = 0;
|
|
}
|
|
if(_state != "init")
|
|
{
|
|
if(_initialTime < 0)
|
|
{
|
|
_seekTarget = param1 + 0;
|
|
}
|
|
else
|
|
{
|
|
_seekTarget = param1 + _initialTime;
|
|
}
|
|
_seekTime = -1;
|
|
setState("seek");
|
|
super.seek(param1);
|
|
}
|
|
_unpublishNotifyPending = false;
|
|
}
|
|
|
|
override public function close() : void
|
|
{
|
|
indexIsReady = false;
|
|
switch(_state)
|
|
{
|
|
case "play":
|
|
case "playStartNext":
|
|
case "playStartSeek":
|
|
_urlStreamVideo.close();
|
|
}
|
|
setState("halt");
|
|
mainTimer.stop();
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.Stop",
|
|
"level":"status"
|
|
}));
|
|
super.close();
|
|
}
|
|
|
|
override public function get time() : Number
|
|
{
|
|
if(_seekTime >= 0 && _initialTime >= 0)
|
|
{
|
|
_lastValidTimeTime = super.time + _seekTime - _initialTime;
|
|
}
|
|
return _lastValidTimeTime;
|
|
}
|
|
|
|
private function setState(param1:String) : void
|
|
{
|
|
_prevState = _state;
|
|
_state = param1;
|
|
}
|
|
|
|
private function insertScriptDataTag(param1:FLVTagScriptDataObject, param2:Boolean = false) : void
|
|
{
|
|
if(!_insertScriptDataTags)
|
|
{
|
|
_insertScriptDataTags = new Vector.<FLVTagScriptDataObject>();
|
|
}
|
|
if(param2)
|
|
{
|
|
_insertScriptDataTags.unshift(param1);
|
|
}
|
|
else
|
|
{
|
|
_insertScriptDataTags.push(param1);
|
|
}
|
|
}
|
|
|
|
private function flvTagHandler(param1:FLVTag) : Boolean
|
|
{
|
|
var _loc9_:int = 0;
|
|
var _loc5_:FLVTagScriptDataObject = null;
|
|
var _loc7_:ByteArray = null;
|
|
var _loc2_:Number = NaN;
|
|
var _loc11_:FLVTagVideo = null;
|
|
var _loc3_:FLVTagVideo = null;
|
|
var _loc4_:FLVTagVideo = null;
|
|
var _loc10_:int = 0;
|
|
var _loc8_:int = 0;
|
|
var _loc6_:FLVTagAudio = null;
|
|
if(_insertScriptDataTags)
|
|
{
|
|
_loc9_ = 0;
|
|
while(_loc9_ < _insertScriptDataTags.length)
|
|
{
|
|
_loc5_ = _insertScriptDataTags[_loc9_];
|
|
_loc5_.timestamp = param1.timestamp;
|
|
_loc7_ = new ByteArray();
|
|
_loc5_.write(_loc7_);
|
|
_flvParserProcessed += _loc7_.length;
|
|
attemptAppendBytes(_loc7_);
|
|
_loc9_++;
|
|
}
|
|
_insertScriptDataTags = null;
|
|
}
|
|
if(_playForDuration >= 0)
|
|
{
|
|
if(_initialTime >= 0)
|
|
{
|
|
_loc2_ = param1.timestamp / 1000 + _fileTimeAdjustment;
|
|
if(_loc2_ > _initialTime + _playForDuration)
|
|
{
|
|
setState("stop");
|
|
_flvParserDone = true;
|
|
if(_seekTime < 0)
|
|
{
|
|
_seekTime = _playForDuration + _initialTime;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if(_enhancedSeekTarget < 0)
|
|
{
|
|
if(_initialTime < 0)
|
|
{
|
|
if(_dvrInfo != null)
|
|
{
|
|
_initialTime = _dvrInfo.startTime;
|
|
}
|
|
else
|
|
{
|
|
_initialTime = param1.timestamp / 1000 + _fileTimeAdjustment;
|
|
}
|
|
}
|
|
if(_seekTime < 0)
|
|
{
|
|
_seekTime = param1.timestamp / 1000 + _fileTimeAdjustment;
|
|
}
|
|
_loc7_ = new ByteArray();
|
|
param1.write(_loc7_);
|
|
_flvParserProcessed += _loc7_.length;
|
|
attemptAppendBytes(_loc7_);
|
|
if(_playForDuration >= 0)
|
|
{
|
|
if(_segmentDuration >= 0 && _flvParserIsSegmentStart)
|
|
{
|
|
_flvParserIsSegmentStart = false;
|
|
_loc2_ = param1.timestamp / 1000 + _fileTimeAdjustment;
|
|
if(_loc2_ + _segmentDuration >= _initialTime + _playForDuration)
|
|
{
|
|
return true;
|
|
}
|
|
_flvParserDone = true;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
_flvParserDone = true;
|
|
return false;
|
|
}
|
|
if(param1 is FLVTagVideo)
|
|
{
|
|
if(_flvParserIsSegmentStart)
|
|
{
|
|
_loc11_ = new FLVTagVideo();
|
|
_loc11_.timestamp = param1.timestamp;
|
|
_loc11_.codecID = FLVTagVideo(param1).codecID;
|
|
_loc11_.frameType = 5;
|
|
_loc11_.infoPacketValue = 0;
|
|
_enhancedSeekTags = new Vector.<FLVTagVideo>();
|
|
_enhancedSeekTags.push(_loc11_);
|
|
_flvParserIsSegmentStart = false;
|
|
}
|
|
if(param1.timestamp / 1000 + _fileTimeAdjustment >= _enhancedSeekTarget)
|
|
{
|
|
_enhancedSeekTarget = -1;
|
|
_seekTime = param1.timestamp / 1000 + _fileTimeAdjustment;
|
|
if(_initialTime < 0)
|
|
{
|
|
_initialTime = _seekTime;
|
|
}
|
|
_loc3_ = new FLVTagVideo();
|
|
_loc3_.timestamp = param1.timestamp;
|
|
_loc3_.codecID = _enhancedSeekTags[0].codecID;
|
|
_loc3_.frameType = 5;
|
|
_loc3_.infoPacketValue = 1;
|
|
_enhancedSeekTags.push(_loc3_);
|
|
_loc9_ = 0;
|
|
while(_loc9_ < _enhancedSeekTags.length)
|
|
{
|
|
_loc4_ = _enhancedSeekTags[_loc9_];
|
|
if(_loc4_.codecID == 7 && _loc4_.avcPacketType == 1)
|
|
{
|
|
_loc10_ = param1.timestamp - _loc4_.timestamp;
|
|
_loc8_ = _loc4_.avcCompositionTimeOffset;
|
|
_loc8_ = _loc4_.avcCompositionTimeOffset;
|
|
_loc8_ = _loc8_ - _loc10_;
|
|
_loc4_.avcCompositionTimeOffset = _loc8_;
|
|
_loc4_.timestamp = param1.timestamp;
|
|
}
|
|
else
|
|
{
|
|
_loc4_.timestamp = param1.timestamp;
|
|
}
|
|
_loc7_ = new ByteArray();
|
|
_loc4_.write(_loc7_);
|
|
_flvParserProcessed += _loc7_.length;
|
|
attemptAppendBytes(_loc7_);
|
|
_loc9_++;
|
|
}
|
|
_enhancedSeekTags = null;
|
|
_loc7_ = new ByteArray();
|
|
param1.write(_loc7_);
|
|
_flvParserProcessed += _loc7_.length;
|
|
attemptAppendBytes(_loc7_);
|
|
if(_playForDuration >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
_flvParserDone = true;
|
|
return false;
|
|
}
|
|
_enhancedSeekTags.push(param1);
|
|
}
|
|
else if(param1 is FLVTagScriptDataObject)
|
|
{
|
|
_loc7_ = new ByteArray();
|
|
param1.write(_loc7_);
|
|
_flvParserProcessed += _loc7_.length;
|
|
attemptAppendBytes(_loc7_);
|
|
}
|
|
else if(param1 is FLVTagAudio)
|
|
{
|
|
_loc6_ = param1 as FLVTagAudio;
|
|
if(_loc6_.isCodecConfiguration)
|
|
{
|
|
_loc7_ = new ByteArray();
|
|
param1.write(_loc7_);
|
|
_flvParserProcessed += _loc7_.length;
|
|
attemptAppendBytes(_loc7_);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private function autoAdjustQuality(param1:Boolean) : void
|
|
{
|
|
var _loc2_:int = 0;
|
|
var _loc3_:Number = NaN;
|
|
if(!_manualSwitchMode)
|
|
{
|
|
if(param1)
|
|
{
|
|
setQualityLevel(0);
|
|
return;
|
|
}
|
|
if(_lastDownloadRatio < 1)
|
|
{
|
|
if(qualityLevel > 0)
|
|
{
|
|
_loc2_ = qualityLevel - 1;
|
|
_loc3_ = _qualityRates[_loc2_] / _qualityRates[qualityLevel];
|
|
if(_lastDownloadRatio < _loc3_)
|
|
{
|
|
setQualityLevel(0);
|
|
}
|
|
else
|
|
{
|
|
setQualityLevel(_loc2_);
|
|
}
|
|
}
|
|
}
|
|
else if(qualityLevel < _numQualityLevels - 1)
|
|
{
|
|
_loc2_ = qualityLevel + 1;
|
|
_loc3_ = _qualityRates[_loc2_] / _qualityRates[qualityLevel];
|
|
if(_lastDownloadRatio >= _loc3_)
|
|
{
|
|
if(!(_lastDownloadRatio > 100 || !_aggressiveUpswitch))
|
|
{
|
|
while(++_loc2_ < _numQualityLevels)
|
|
{
|
|
_loc3_ = _qualityRates[_loc2_] / _qualityRates[qualityLevel];
|
|
if(_lastDownloadRatio < _loc3_)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
_loc2_--;
|
|
}
|
|
setQualityLevel(_loc2_);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function byteSource(param1:IDataInput, param2:Number) : IDataInput
|
|
{
|
|
var _loc3_:int = 0;
|
|
if(param2 < 0)
|
|
{
|
|
return null;
|
|
}
|
|
if(param2)
|
|
{
|
|
if(_savedBytes.bytesAvailable + param1.bytesAvailable < param2)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
else if(_savedBytes.bytesAvailable + param1.bytesAvailable < 1)
|
|
{
|
|
return null;
|
|
}
|
|
if(_savedBytes.bytesAvailable)
|
|
{
|
|
_loc3_ = param2 - _savedBytes.bytesAvailable;
|
|
if(_loc3_ > 0)
|
|
{
|
|
param1.readBytes(_savedBytes,_savedBytes.length,_loc3_);
|
|
}
|
|
return _savedBytes;
|
|
}
|
|
_savedBytes.length = 0;
|
|
return param1;
|
|
}
|
|
|
|
private function processAndAppend(param1:ByteArray) : uint
|
|
{
|
|
var _loc3_:ByteArray = null;
|
|
var _loc2_:uint = 0;
|
|
if(!param1)
|
|
{
|
|
return 0;
|
|
}
|
|
if(_flvParser)
|
|
{
|
|
param1.position = 0;
|
|
_flvParserProcessed = 0;
|
|
_flvParser.parse(param1,true,flvTagHandler);
|
|
_loc2_ += _flvParserProcessed;
|
|
if(!_flvParserDone)
|
|
{
|
|
return _loc2_;
|
|
}
|
|
_loc3_ = new ByteArray();
|
|
_flvParser.flush(_loc3_);
|
|
_flvParser = null;
|
|
}
|
|
else
|
|
{
|
|
_loc3_ = param1;
|
|
}
|
|
_loc2_ += _loc3_.length;
|
|
if(_state != "stop")
|
|
{
|
|
attemptAppendBytes(_loc3_);
|
|
}
|
|
return _loc2_;
|
|
}
|
|
|
|
private function onMainTimer(param1:TimerEvent) : void
|
|
{
|
|
var _loc11_:ByteArray = null;
|
|
var _loc13_:Object = null;
|
|
var _loc4_:FLVTagScriptDataObject = null;
|
|
var _loc12_:HTTPStreamRequest = null;
|
|
var _loc2_:Date = null;
|
|
var _loc3_:Boolean = false;
|
|
var _loc8_:int = 0;
|
|
var _loc6_:int = 0;
|
|
var _loc7_:IDataInput = null;
|
|
var _loc10_:Object = null;
|
|
var _loc5_:FLVTagScriptDataObject = null;
|
|
var _loc9_:ByteArray = null;
|
|
switch(_state)
|
|
{
|
|
case "init":
|
|
_seekAfterInit = true;
|
|
break;
|
|
case "seek":
|
|
switch(_prevState)
|
|
{
|
|
case "play":
|
|
case "playStartNext":
|
|
case "playStartSeek":
|
|
_urlStreamVideo.close();
|
|
}
|
|
_dataAvailable = false;
|
|
_savedBytes.length = 0;
|
|
if(_enhancedSeekEnabled)
|
|
{
|
|
_enhancedSeekTarget = _seekTarget;
|
|
}
|
|
setState("loadSeek");
|
|
break;
|
|
case "loadWait":
|
|
if(this._lastDownloadRatio < 2)
|
|
{
|
|
if(this.bufferLength < Math.max(7.5,this.bufferTime))
|
|
{
|
|
setState("loadNext");
|
|
}
|
|
}
|
|
else if(this.bufferLength < Math.max(3.75,this.bufferTime))
|
|
{
|
|
setState("loadNext");
|
|
}
|
|
break;
|
|
case "loadNext":
|
|
autoAdjustQuality(false);
|
|
if(qualityLevelHasChanged)
|
|
{
|
|
_loc11_ = fileHandler.flushFileSegment(_savedBytes.bytesAvailable ? _savedBytes : null);
|
|
processAndAppend(_loc11_);
|
|
_loc13_ = {};
|
|
_loc13_.code = "NetStream.Play.TransitionComplete";
|
|
_loc13_.level = "status";
|
|
_loc4_ = new FLVTagScriptDataObject();
|
|
_loc4_.objects = ["onPlayStatus",_loc13_];
|
|
insertScriptDataTag(_loc4_);
|
|
qualityLevelHasChanged = false;
|
|
}
|
|
setState("load");
|
|
break;
|
|
case "loadSeek":
|
|
if(!_seekAfterInit)
|
|
{
|
|
_loc11_ = fileHandler.flushFileSegment(_savedBytes.bytesAvailable ? _savedBytes : null);
|
|
}
|
|
appendBytesAction("resetSeek");
|
|
if(!_seekAfterInit)
|
|
{
|
|
autoAdjustQuality(true);
|
|
}
|
|
_seekAfterInit = false;
|
|
setState("load");
|
|
break;
|
|
case "load":
|
|
if(_signalPlayStartPending)
|
|
{
|
|
signalPlayStart();
|
|
_signalPlayStartPending = false;
|
|
}
|
|
_segmentDuration = -1;
|
|
switch(_prevState)
|
|
{
|
|
case "loadSeek":
|
|
case "loadSeekRetryWait":
|
|
_loc12_ = indexHandler.getFileForTime(_seekTarget,qualityLevel);
|
|
break;
|
|
case "loadNext":
|
|
case "loadNextRetryWait":
|
|
_loc12_ = indexHandler.getNextFile(qualityLevel);
|
|
break;
|
|
default:
|
|
throw new Error("in HTTPStreamState.LOAD with unknown _prevState " + _prevState);
|
|
}
|
|
if(_loc12_ != null && _loc12_.urlRequest != null)
|
|
{
|
|
_loadComplete = false;
|
|
_urlStreamVideo.load(_loc12_.urlRequest);
|
|
_loc2_ = new Date();
|
|
_lastDownloadStartTime = _loc2_.getTime();
|
|
switch(_prevState)
|
|
{
|
|
case "loadSeek":
|
|
case "loadSeekRetryWait":
|
|
setState("playStartSeek");
|
|
break;
|
|
case "loadNext":
|
|
case "loadNextRetryWait":
|
|
setState("playStartNext");
|
|
break;
|
|
default:
|
|
throw new Error("in HTTPStreamState.LOAD(2) with unknown _prevState " + _prevState);
|
|
}
|
|
}
|
|
else if(_loc12_ != null && _loc12_.retryAfter >= 0)
|
|
{
|
|
_loc2_ = new Date();
|
|
_retryAfterWaitUntil = _loc2_.getTime() + 1000 * _loc12_.retryAfter;
|
|
switch(_prevState)
|
|
{
|
|
case "loadSeek":
|
|
case "loadSeekRetryWait":
|
|
setState("loadSeekRetryWait");
|
|
break;
|
|
case "loadNext":
|
|
case "loadNextRetryWait":
|
|
setState("loadNextRetryWait");
|
|
break;
|
|
default:
|
|
throw new Error("in HTTPStreamState.LOAD(3) with unknown _prevState " + _prevState);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_loc11_ = fileHandler.flushFileSegment(_savedBytes.bytesAvailable ? _savedBytes : null);
|
|
processAndAppend(_loc11_);
|
|
setState("stop");
|
|
if(_loc12_ != null && _loc12_.unpublishNotify)
|
|
{
|
|
_unpublishNotifyPending = true;
|
|
}
|
|
}
|
|
break;
|
|
case "loadSeekRetryWait":
|
|
case "loadNextRetryWait":
|
|
_loc2_ = new Date();
|
|
if(_loc2_.getTime() > _retryAfterWaitUntil)
|
|
{
|
|
setState("load");
|
|
}
|
|
break;
|
|
case "playStartNext":
|
|
fileHandler.beginProcessFile(false,0);
|
|
setState("playStartCommon");
|
|
break;
|
|
case "playStartSeek":
|
|
fileHandler.beginProcessFile(true,_seekTarget);
|
|
setState("playStartCommon");
|
|
break;
|
|
case "playStartCommon":
|
|
if(_initialTime < 0 || _seekTime < 0 || _insertScriptDataTags || _enhancedSeekTarget >= 0 || _playForDuration >= 0)
|
|
{
|
|
if(_enhancedSeekTarget >= 0 || _playForDuration >= 0)
|
|
{
|
|
_flvParserIsSegmentStart = true;
|
|
}
|
|
_flvParser = new FLVParser(false);
|
|
_flvParserDone = false;
|
|
}
|
|
setState("play");
|
|
break;
|
|
case "play":
|
|
_loc3_ = false;
|
|
if(_dataAvailable)
|
|
{
|
|
_loc8_ = 260000;
|
|
_loc6_ = 0;
|
|
if(_enhancedSeekTarget >= 0)
|
|
{
|
|
_loc8_ = 0;
|
|
}
|
|
_loc7_ = null;
|
|
_dataAvailable = false;
|
|
while(_state == "play" && _loc7_ == byteSource(_urlStreamVideo,fileHandler.inputBytesNeeded))
|
|
{
|
|
_loc11_ = fileHandler.processFileSegment(_loc7_);
|
|
_loc6_ += processAndAppend(_loc11_);
|
|
if(_loc8_ > 0 && _loc6_ >= _loc8_)
|
|
{
|
|
_dataAvailable = true;
|
|
break;
|
|
}
|
|
}
|
|
if(_state != "play")
|
|
{
|
|
break;
|
|
}
|
|
if(_loadComplete && !_loc7_)
|
|
{
|
|
_loc3_ = true;
|
|
}
|
|
}
|
|
else if(_loadComplete)
|
|
{
|
|
_loc3_ = true;
|
|
}
|
|
if(_loc3_)
|
|
{
|
|
if(_urlStreamVideo.bytesAvailable)
|
|
{
|
|
_urlStreamVideo.readBytes(_savedBytes);
|
|
}
|
|
else
|
|
{
|
|
_savedBytes.length = 0;
|
|
}
|
|
setState("endSegment");
|
|
}
|
|
break;
|
|
case "endSegment":
|
|
_loc11_ = fileHandler.endProcessFile(_savedBytes.bytesAvailable ? _savedBytes : null);
|
|
processAndAppend(_loc11_);
|
|
_lastDownloadRatio = _segmentDuration / _lastDownloadDuration;
|
|
if(_state != "stop" && _state != "halt")
|
|
{
|
|
setState("loadWait");
|
|
}
|
|
break;
|
|
case "stop":
|
|
_loc10_ = {};
|
|
_loc10_.code = "NetStream.Play.Complete";
|
|
_loc10_.level = "status";
|
|
_loc5_ = new FLVTagScriptDataObject();
|
|
_loc5_.objects = ["onPlayStatus",_loc10_];
|
|
_loc9_ = new ByteArray();
|
|
_loc5_.write(_loc9_);
|
|
appendBytesAction("endSequence");
|
|
appendBytesAction("resetSeek");
|
|
attemptAppendBytes(_loc9_);
|
|
setState("halt");
|
|
break;
|
|
case "halt":
|
|
break;
|
|
default:
|
|
throw new Error("HTTPStream cannot run undefined _state " + _state);
|
|
}
|
|
}
|
|
|
|
private function onURLStatus(param1:ProgressEvent) : void
|
|
{
|
|
_dataAvailable = true;
|
|
}
|
|
|
|
private function onURLComplete(param1:Event) : void
|
|
{
|
|
var _loc2_:Date = new Date();
|
|
_lastDownloadDuration = (_loc2_.getTime() - _lastDownloadStartTime) / 1000;
|
|
_loadComplete = true;
|
|
}
|
|
|
|
private function onRequestLoadIndexFile(param1:HTTPStreamingIndexHandlerEvent) : void
|
|
{
|
|
var event:HTTPStreamingIndexHandlerEvent = param1;
|
|
var onIndexLoadComplete:* = function(param1:Event):void
|
|
{
|
|
urlLoader.removeEventListener("complete",onIndexLoadComplete);
|
|
urlLoader.removeEventListener("ioError",onIndexURLError);
|
|
urlLoader.removeEventListener("securityError",onIndexURLError);
|
|
indexHandler.processIndexData(urlLoader.data,requestContext);
|
|
};
|
|
var onIndexURLError:* = function(param1:Event):void
|
|
{
|
|
urlLoader.removeEventListener("complete",onIndexLoadComplete);
|
|
urlLoader.removeEventListener("ioError",onIndexURLError);
|
|
urlLoader.removeEventListener("securityError",onIndexURLError);
|
|
handleURLError();
|
|
};
|
|
var urlLoader:URLLoader = new URLLoader(event.request);
|
|
var requestContext:Object = event.requestContext;
|
|
if(event.binaryData)
|
|
{
|
|
urlLoader.dataFormat = "binary";
|
|
}
|
|
else
|
|
{
|
|
urlLoader.dataFormat = "text";
|
|
}
|
|
urlLoader.addEventListener("complete",onIndexLoadComplete);
|
|
urlLoader.addEventListener("ioError",onIndexURLError);
|
|
urlLoader.addEventListener("securityError",onIndexURLError);
|
|
}
|
|
|
|
private function onSegmentDurationFromFileHandler(param1:HTTPStreamingFileHandlerEvent) : void
|
|
{
|
|
_segmentDuration = param1.segmentDuration;
|
|
}
|
|
|
|
private function onSegmentDurationFromIndexHandler(param1:HTTPStreamingIndexHandlerEvent) : void
|
|
{
|
|
_segmentDuration = param1.segmentDuration;
|
|
}
|
|
|
|
private function onRates(param1:HTTPStreamingIndexHandlerEvent) : void
|
|
{
|
|
_qualityRates = param1.rates;
|
|
_streamNames = param1.streamNames;
|
|
_numQualityLevels = _qualityRates.length;
|
|
}
|
|
|
|
private function onIndexReady(param1:HTTPStreamingIndexHandlerEvent) : void
|
|
{
|
|
if(!indexIsReady)
|
|
{
|
|
if(param1.live && _dvrInfo == null && !isNaN(param1.offset))
|
|
{
|
|
_seekTarget = param1.offset;
|
|
}
|
|
_urlStreamVideo = new URLStream();
|
|
_urlStreamVideo.addEventListener("progress",onURLStatus,false,0,true);
|
|
_urlStreamVideo.addEventListener("complete",onURLComplete,false,0,true);
|
|
_urlStreamVideo.addEventListener("ioError",onVideoURLError,false,0,true);
|
|
_urlStreamVideo.addEventListener("securityError",onVideoURLError,false,0,true);
|
|
setState("seek");
|
|
indexIsReady = true;
|
|
}
|
|
}
|
|
|
|
private function onVideoURLError(param1:Event) : void
|
|
{
|
|
handleURLError();
|
|
}
|
|
|
|
private function handleURLError() : void
|
|
{
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.StreamNotFound",
|
|
"level":"error"
|
|
}));
|
|
}
|
|
|
|
private function onScriptDataFromIndexHandler(param1:HTTPStreamingIndexHandlerEvent) : void
|
|
{
|
|
onScriptData(param1.scriptDataObject,param1.scriptDataFirst,param1.scriptDataImmediate);
|
|
}
|
|
|
|
private function onScriptDataFromFileHandler(param1:HTTPStreamingFileHandlerEvent) : void
|
|
{
|
|
onScriptData(param1.scriptDataObject,param1.scriptDataFirst,param1.scriptDataImmediate);
|
|
}
|
|
|
|
private function onErrorFromFileHandler(param1:HTTPStreamingFileHandlerEvent) : void
|
|
{
|
|
setState("halt");
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.FileStructureInvalid",
|
|
"level":"error"
|
|
}));
|
|
}
|
|
|
|
private function onScriptData(param1:FLVTagScriptDataObject, param2:Boolean, param3:Boolean) : void
|
|
{
|
|
if(param3)
|
|
{
|
|
if(client)
|
|
{
|
|
if(client.hasOwnProperty(param1.objects[0]))
|
|
{
|
|
client[param1.objects[0]](param1.objects[1]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
insertScriptDataTag(param1,param2);
|
|
}
|
|
}
|
|
|
|
private function onDVRStreamInfo(param1:DVRStreamInfoEvent) : void
|
|
{
|
|
_dvrInfo = param1.info as DVRInfo;
|
|
dispatchEvent(param1.clone());
|
|
}
|
|
|
|
private function onIndexError(param1:HTTPStreamingIndexHandlerEvent) : void
|
|
{
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.StreamNotFound",
|
|
"level":"error"
|
|
}));
|
|
}
|
|
|
|
private function setQualityLevel(param1:int) : void
|
|
{
|
|
if(param1 >= 0 && param1 < _numQualityLevels)
|
|
{
|
|
if(param1 != _qualityLevel)
|
|
{
|
|
_qualityLevel = param1;
|
|
qualityLevelHasChanged = true;
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.Transition",
|
|
"level":"status",
|
|
"details":_streamNames[param1]
|
|
}));
|
|
}
|
|
return;
|
|
}
|
|
throw new Error("qualityLevel cannot be set to this value at this time");
|
|
}
|
|
|
|
private function setQualityLevelForStreamName(param1:String) : void
|
|
{
|
|
var _loc3_:int = 0;
|
|
var _loc2_:* = -1;
|
|
if(_streamNames != null)
|
|
{
|
|
_loc3_ = 0;
|
|
while(_loc3_ < _streamNames.length)
|
|
{
|
|
if(param1 == _streamNames[_loc3_])
|
|
{
|
|
_loc2_ = _loc3_;
|
|
break;
|
|
}
|
|
_loc3_++;
|
|
}
|
|
}
|
|
if(_loc2_ != -1)
|
|
{
|
|
setQualityLevel(_loc2_);
|
|
}
|
|
}
|
|
|
|
private function attemptAppendBytes(param1:ByteArray) : void
|
|
{
|
|
appendBytes(param1);
|
|
}
|
|
|
|
private function onNetStatus(param1:NetStatusEvent) : void
|
|
{
|
|
if(param1.info.code == "NetStream.Buffer.Empty" && _state == "halt")
|
|
{
|
|
finishStopProcess();
|
|
}
|
|
}
|
|
|
|
private function finishStopProcess() : void
|
|
{
|
|
if(_unpublishNotifyPending)
|
|
{
|
|
dispatchEvent(new NetStatusEvent("netStatus",false,false,{
|
|
"code":"NetStream.Play.UnpublishNotify",
|
|
"level":"status"
|
|
}));
|
|
_unpublishNotifyPending = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|