Brought up to date with the private repository (feea4c7)

This commit is contained in:
S committed 2026-10-14 20:57:33 +03:00
1 parent 1aa738d692
commit 1b1df1ae48
7925 files changed
+2617237 -20

No files matched your search

@@ -0,0 +1,72 @@
package org.osmf.net.httpstreaming
{
import org.osmf.net.SwitchingRuleBase;
public class DownloadRatioRule extends SwitchingRuleBase
{
private var aggressiveUpswitch:Boolean = false;
public function DownloadRatioRule(param1:HTTPNetStreamMetrics, param2:Boolean = true)
{
super(param1);
this.aggressiveUpswitch = param2;
}
override public function getNewIndex() : int
{
var _loc2_:Number = NaN;
var _loc1_:* = -1;
if(this.httpMetrics.downloadRatio < 1)
{
if(this.httpMetrics.currentIndex > 0)
{
_loc2_ = this.getSwitchRatio(this.httpMetrics.currentIndex - 1);
if(this.httpMetrics.downloadRatio < _loc2_)
{
_loc1_ = 0;
}
else
{
_loc1_ = int(this.httpMetrics.currentIndex - 1);
}
}
}
else if(this.httpMetrics.currentIndex < this.httpMetrics.maxAllowedIndex)
{
_loc2_ = this.getSwitchRatio(this.httpMetrics.currentIndex + 1);
if(this.httpMetrics.downloadRatio >= _loc2_)
{
if(this.httpMetrics.downloadRatio > 100 || !this.aggressiveUpswitch)
{
_loc1_ = int(this.httpMetrics.currentIndex + 1);
}
else
{
while(++_loc1_ < this.httpMetrics.maxAllowedIndex + 1)
{
_loc2_ = this.getSwitchRatio(_loc1_);
if(this.httpMetrics.downloadRatio < _loc2_)
{
break;
}
}
_loc1_--;
}
}
}
return _loc1_;
}
private function getSwitchRatio(param1:int) : Number
{
return this.httpMetrics.getBitrateForIndex(param1) / this.httpMetrics.getBitrateForIndex(metrics.currentIndex);
}
private function get httpMetrics() : HTTPNetStreamMetrics
{
return metrics as HTTPNetStreamMetrics;
}
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,27 @@
package org.osmf.net.httpstreaming
{
import org.osmf.net.NetStreamMetricsBase;
public class HTTPNetStreamMetrics extends NetStreamMetricsBase
{
private var httpNetStream:HTTPNetStream;
public function HTTPNetStreamMetrics(param1:HTTPNetStream)
{
super(param1);
this.httpNetStream = param1;
}
public function get downloadRatio() : Number
{
return this.httpNetStream.downloadRatio;
}
public function getBitrateForIndex(param1:int) : Number
{
return this.resource.streamItems[param1].bitrate;
}
}
}
@@ -0,0 +1,51 @@
package org.osmf.net.httpstreaming
{
import flash.net.URLRequest;
public class HTTPStreamRequest
{
private var _urlRequest:URLRequest;
private var _quality:int;
private var _truncateAt:Number;
private var _retryAfter:Number;
private var _unpublishNotify:Boolean;
public function HTTPStreamRequest(param1:String = null, param2:int = -1, param3:Number = -1, param4:Number = -1, param5:Boolean = false)
{
super();
if(param1)
{
this._urlRequest = new URLRequest(HTTPStreamingUtils.normalizeURL(param1));
}
else
{
this._urlRequest = null;
}
this._quality = param2;
this._truncateAt = param3;
this._retryAfter = param4;
this._unpublishNotify = param5;
}
public function get urlRequest() : URLRequest
{
return this._urlRequest;
}
public function get retryAfter() : Number
{
return this._retryAfter;
}
public function get unpublishNotify() : Boolean
{
return this._unpublishNotify;
}
}
}
@@ -0,0 +1,42 @@
package org.osmf.net.httpstreaming
{
import flash.errors.IllegalOperationError;
import flash.events.EventDispatcher;
import flash.utils.ByteArray;
import flash.utils.IDataInput;
public class HTTPStreamingFileHandlerBase extends EventDispatcher
{
public function HTTPStreamingFileHandlerBase()
{
super();
}
public function beginProcessFile(param1:Boolean, param2:Number) : void
{
throw new IllegalOperationError("The beginProcessFile() method must be overridden by HttpStreamingFileHandlerBase\'s derived class.");
}
public function get inputBytesNeeded() : Number
{
throw new IllegalOperationError("The inputBytesNeeded() method must be overridden by HttpStreamingFileHandlerBase\'s derived class.");
}
public function processFileSegment(param1:IDataInput) : ByteArray
{
throw new IllegalOperationError("The processFileSegment() method must be overridden by HttpStreamingFileHandlerBase\'s derived class.");
}
public function endProcessFile(param1:IDataInput) : ByteArray
{
throw new IllegalOperationError("The endProcessFile() method must be overridden by HttpStreamingFileHandlerBase\'s derived class.");
}
public function flushFileSegment(param1:IDataInput) : ByteArray
{
throw new IllegalOperationError("The flushFileSegment() method must be overridden by HttpStreamingFileHandlerBase\'s derived class.");
}
}
}
@@ -0,0 +1,40 @@
package org.osmf.net.httpstreaming
{
import flash.errors.IllegalOperationError;
import flash.events.EventDispatcher;
public class HTTPStreamingIndexHandlerBase extends EventDispatcher
{
public function HTTPStreamingIndexHandlerBase()
{
super();
}
public function initialize(param1:Object) : void
{
throw new IllegalOperationError("The initialize() method must be overridden by the derived class.");
}
public function processIndexData(param1:*, param2:Object) : void
{
throw new IllegalOperationError("The processIndexData() method must be overridden by the derived class.");
}
public function getFileForTime(param1:Number, param2:int) : HTTPStreamRequest
{
throw new IllegalOperationError("The getFileForTime() method must be overridden by the derived class.");
}
public function getNextFile(param1:int) : HTTPStreamRequest
{
throw new IllegalOperationError("The getNextFile() method must be overridden by the derived class.");
}
public function dvrGetStreamInfo(param1:Object) : void
{
throw new IllegalOperationError("The dvrGetStreamInfo() method must be overridden by the derived class.");
}
}
}
@@ -0,0 +1,12 @@
package org.osmf.net.httpstreaming
{
public class HTTPStreamingIndexInfoBase
{
public function HTTPStreamingIndexInfoBase()
{
super();
}
}
}
@@ -0,0 +1,96 @@
package org.osmf.net.httpstreaming
{
import flash.net.NetConnection;
import flash.net.NetStream;
import org.osmf.events.DVRStreamInfoEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.metadata.Metadata;
import org.osmf.metadata.MetadataNamespaces;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.NetLoader;
import org.osmf.net.NetStreamLoadTrait;
import org.osmf.net.NetStreamSwitchManager;
import org.osmf.net.NetStreamSwitchManagerBase;
import org.osmf.net.SwitchingRuleBase;
import org.osmf.net.httpstreaming.dvr.DVRInfo;
import org.osmf.net.httpstreaming.dvr.HTTPStreamingDVRCastDVRTrait;
import org.osmf.net.httpstreaming.dvr.HTTPStreamingDVRCastTimeTrait;
import org.osmf.net.httpstreaming.f4f.HTTPStreamingF4FFileHandler;
import org.osmf.net.httpstreaming.f4f.HTTPStreamingF4FIndexHandler;
import org.osmf.net.rtmpstreaming.DroppedFramesRule;
import org.osmf.traits.LoadState;
public class HTTPStreamingNetLoader extends NetLoader
{
public function HTTPStreamingNetLoader()
{
super();
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
return param1.getMetadataValue(MetadataNamespaces.HTTP_STREAMING_METADATA) as Metadata != null;
}
override protected function createNetStream(param1:NetConnection, param2:URLResource) : NetStream
{
var _loc3_:HTTPStreamingFileHandlerBase = new HTTPStreamingF4FFileHandler();
var _loc4_:HTTPStreamingIndexHandlerBase = new HTTPStreamingF4FIndexHandler(_loc3_);
var _loc5_:HTTPNetStream = new HTTPNetStream(param1,_loc4_,_loc3_);
_loc5_.manualSwitchMode = true;
_loc5_.indexInfo = HTTPStreamingUtils.createF4FIndexInfo(param2);
return _loc5_;
}
override protected function createNetStreamSwitchManager(param1:NetConnection, param2:NetStream, param3:DynamicStreamingResource) : NetStreamSwitchManagerBase
{
var _loc4_:HTTPNetStreamMetrics = null;
if(param3 != null)
{
_loc4_ = new HTTPNetStreamMetrics(param2 as HTTPNetStream);
return new NetStreamSwitchManager(param1,param2,param3,_loc4_,this.getDefaultSwitchingRules(_loc4_));
}
return null;
}
override protected function processFinishLoading(param1:NetStreamLoadTrait) : void
{
var netStream:HTTPNetStream = null;
var onDVRStreamInfo:Function = null;
var loadTrait:NetStreamLoadTrait = param1;
onDVRStreamInfo = function(param1:DVRStreamInfoEvent):void
{
netStream.removeEventListener(DVRStreamInfoEvent.DVRSTREAMINFO,onDVRStreamInfo);
loadTrait.setTrait(new HTTPStreamingDVRCastDVRTrait(loadTrait.connection,netStream,param1.info as DVRInfo));
loadTrait.setTrait(new HTTPStreamingDVRCastTimeTrait(loadTrait.connection,netStream,param1.info as DVRInfo));
updateLoadTrait(loadTrait,LoadState.READY);
};
var resource:URLResource = loadTrait.resource as URLResource;
if(!this.dvrMetadataPresent(resource))
{
updateLoadTrait(loadTrait,LoadState.READY);
return;
}
netStream = loadTrait.netStream as HTTPNetStream;
netStream.addEventListener(DVRStreamInfoEvent.DVRSTREAMINFO,onDVRStreamInfo);
netStream.DVRGetStreamInfo(null);
}
private function dvrMetadataPresent(param1:URLResource) : Boolean
{
var _loc2_:Metadata = param1.getMetadataValue(MetadataNamespaces.DVR_METADATA) as Metadata;
return _loc2_ != null;
}
private function getDefaultSwitchingRules(param1:HTTPNetStreamMetrics) : Vector.<SwitchingRuleBase>
{
var _loc2_:Vector.<SwitchingRuleBase> = new Vector.<SwitchingRuleBase>();
_loc2_.push(new DownloadRatioRule(param1));
_loc2_.push(new DroppedFramesRule(param1));
return _loc2_;
}
}
}
@@ -0,0 +1,42 @@
package org.osmf.net.httpstreaming
{
internal class HTTPStreamingState
{
internal static const INIT:String = "init";
internal static const LOAD_SEEK:String = "loadSeek";
internal static const LOAD_SEEK_RETRY_WAIT:String = "loadSeekRetryWait";
internal static const LOAD:String = "load";
internal static const LOAD_WAIT:String = "loadWait";
internal static const LOAD_NEXT:String = "loadNext";
internal static const LOAD_NEXT_RETRY_WAIT:String = "loadNextRetryWait";
internal static const PLAY_START_SEEK:String = "playStartSeek";
internal static const PLAY_START_NEXT:String = "playStartNext";
internal static const PLAY_START_COMMON:String = "playStartCommon";
internal static const PLAY:String = "play";
internal static const END_SEGMENT:String = "endSegment";
internal static const SEEK:String = "seek";
internal static const STOP:String = "stop";
internal static const HALT:String = "halt";
public function HTTPStreamingState()
{
super();
}
}
}
@@ -0,0 +1,185 @@
package org.osmf.net.httpstreaming
{
import flash.utils.ByteArray;
import org.osmf.elements.f4mClasses.BootstrapInfo;
import org.osmf.media.URLResource;
import org.osmf.metadata.Metadata;
import org.osmf.metadata.MetadataNamespaces;
import org.osmf.net.DynamicStreamingItem;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.httpstreaming.dvr.DVRInfo;
import org.osmf.net.httpstreaming.f4f.HTTPStreamingF4FIndexInfo;
import org.osmf.net.httpstreaming.f4f.HTTPStreamingF4FStreamInfo;
public class HTTPStreamingUtils
{
public function HTTPStreamingUtils()
{
super();
}
public static function createHTTPStreamingMetadata(param1:String, param2:ByteArray, param3:Vector.<String>) : Metadata
{
var _loc4_:Metadata = new Metadata();
var _loc5_:BootstrapInfo = new BootstrapInfo();
if(param1 != null && param1.length > 0)
{
_loc5_.url = param1;
}
_loc5_.data = param2;
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_BOOTSTRAP_KEY,_loc5_);
if(param3 != null && param3.length > 0)
{
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_SERVER_BASE_URLS_KEY,param3);
}
return _loc4_;
}
public static function createF4FIndexInfo(param1:URLResource) : HTTPStreamingF4FIndexInfo
{
var _loc5_:Vector.<String> = null;
var _loc6_:Vector.<HTTPStreamingF4FStreamInfo> = null;
var _loc7_:DVRInfo = null;
var _loc2_:HTTPStreamingF4FIndexInfo = null;
var _loc3_:Metadata = param1.getMetadataValue(MetadataNamespaces.HTTP_STREAMING_METADATA) as Metadata;
var _loc4_:Metadata = param1.getMetadataValue(MetadataNamespaces.DVR_METADATA) as Metadata;
if(_loc3_ != null)
{
_loc5_ = _loc3_.getValue(MetadataNamespaces.HTTP_STREAMING_SERVER_BASE_URLS_KEY) as Vector.<String>;
_loc6_ = generateStreamInfos(param1);
_loc7_ = generateDVRInfo(_loc4_);
_loc2_ = new HTTPStreamingF4FIndexInfo(_loc5_ != null && _loc5_.length > 0 ? _loc5_[0] : null,_loc6_,_loc7_);
}
return _loc2_;
}
public static function normalizeURL(param1:String) : String
{
var _loc4_:String = null;
var _loc7_:int = 0;
var _loc2_:String = "";
var _loc3_:String = "";
if(param1.indexOf("http://") == 0)
{
_loc3_ = "http://";
}
else if(param1.indexOf("https://") == 0)
{
_loc3_ = "https://";
}
if(_loc3_.length > 0)
{
_loc4_ = param1.substr(_loc3_.length);
}
else
{
_loc4_ = param1;
}
var _loc5_:Array = _loc4_.split("/");
var _loc6_:int = _loc5_.indexOf("..");
while(_loc6_ >= 0)
{
_loc5_.splice(_loc6_ - 1,2);
_loc6_ = _loc5_.indexOf("..");
}
_loc2_ = _loc3_;
if(_loc5_.length > 0)
{
_loc7_ = 0;
while(_loc7_ < _loc5_.length)
{
if(_loc7_ != 0)
{
_loc2_ += "/";
}
_loc2_ += _loc5_[_loc7_] as String;
_loc7_++;
}
}
return _loc2_;
}
private static function generateDVRInfo(param1:Metadata) : DVRInfo
{
if(param1 == null)
{
return null;
}
var _loc2_:DVRInfo = new DVRInfo();
_loc2_.id = "";
_loc2_.beginOffset = NaN;
_loc2_.endOffset = NaN;
_loc2_.offline = false;
if(param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_ID_KEY) != null)
{
_loc2_.id = param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_ID_KEY) as String;
}
if(param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_BEGIN_OFFSET_KEY) != null)
{
_loc2_.beginOffset = param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_BEGIN_OFFSET_KEY) as uint;
}
if(param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_END_OFFSET_KEY) != null)
{
_loc2_.endOffset = param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_END_OFFSET_KEY) as uint;
}
if(param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_OFFLINE_KEY) != null)
{
_loc2_.offline = param1.getValue(MetadataNamespaces.HTTP_STREAMING_DVR_OFFLINE_KEY) as Boolean;
}
return _loc2_;
}
private static function generateStreamInfos(param1:URLResource) : Vector.<HTTPStreamingF4FStreamInfo>
{
var _loc8_:Object = null;
var _loc9_:ByteArray = null;
var _loc10_:DynamicStreamingItem = null;
var _loc11_:String = null;
var _loc2_:Vector.<HTTPStreamingF4FStreamInfo> = new Vector.<HTTPStreamingF4FStreamInfo>();
var _loc3_:Metadata = param1.getMetadataValue(MetadataNamespaces.DRM_METADATA) as Metadata;
var _loc4_:Metadata = param1.getMetadataValue(MetadataNamespaces.HTTP_STREAMING_METADATA) as Metadata;
var _loc5_:ByteArray = null;
var _loc6_:BootstrapInfo = null;
var _loc7_:DynamicStreamingResource = param1 as DynamicStreamingResource;
if(_loc7_ != null)
{
for each(_loc10_ in _loc7_.streamItems)
{
_loc5_ = null;
_loc6_ = null;
_loc8_ = null;
_loc9_ = null;
if(_loc3_ != null)
{
_loc5_ = _loc3_.getValue(MetadataNamespaces.DRM_ADDITIONAL_HEADER_KEY + _loc10_.streamName) as ByteArray;
}
if(_loc4_ != null)
{
_loc6_ = _loc4_.getValue(MetadataNamespaces.HTTP_STREAMING_BOOTSTRAP_KEY + _loc10_.streamName) as BootstrapInfo;
_loc8_ = _loc4_.getValue(MetadataNamespaces.HTTP_STREAMING_STREAM_METADATA_KEY + _loc10_.streamName);
_loc9_ = _loc4_.getValue(MetadataNamespaces.HTTP_STREAMING_XMP_METADATA_KEY + _loc10_.streamName) as ByteArray;
}
_loc2_.push(new HTTPStreamingF4FStreamInfo(_loc6_,_loc10_.streamName,_loc10_.bitrate,_loc5_,_loc8_,_loc9_));
}
}
else
{
if(_loc3_ != null)
{
_loc5_ = _loc3_.getValue(MetadataNamespaces.DRM_ADDITIONAL_HEADER_KEY) as ByteArray;
}
if(_loc4_ != null)
{
_loc6_ = _loc4_.getValue(MetadataNamespaces.HTTP_STREAMING_BOOTSTRAP_KEY) as BootstrapInfo;
_loc8_ = _loc4_.getValue(MetadataNamespaces.HTTP_STREAMING_STREAM_METADATA_KEY);
_loc9_ = _loc4_.getValue(MetadataNamespaces.HTTP_STREAMING_XMP_METADATA_KEY) as ByteArray;
}
_loc11_ = param1.url;
_loc2_.push(new HTTPStreamingF4FStreamInfo(_loc6_,_loc11_,NaN,_loc5_,_loc8_,_loc9_));
}
return _loc2_;
}
}
}
@@ -0,0 +1,28 @@
package org.osmf.net.httpstreaming.dvr
{
public class DVRInfo
{
public var id:String;
public var url:String;
public var beginOffset:uint = 0;
public var endOffset:uint = 0;
public var offline:Boolean;
public var isRecording:Boolean;
public var curLength:Number;
public var startTime:Number = NaN;
public function DVRInfo()
{
super();
}
}
}
@@ -0,0 +1,33 @@
package org.osmf.net.httpstreaming.dvr
{
import flash.net.NetConnection;
import org.osmf.events.DVRStreamInfoEvent;
import org.osmf.net.httpstreaming.HTTPNetStream;
import org.osmf.traits.DVRTrait;
public class HTTPStreamingDVRCastDVRTrait extends DVRTrait
{
private var _connection:NetConnection;
private var _stream:HTTPNetStream;
private var _dvrInfo:DVRInfo;
public function HTTPStreamingDVRCastDVRTrait(param1:NetConnection, param2:HTTPNetStream, param3:DVRInfo)
{
this._connection = param1;
this._stream = param2;
this._dvrInfo = param3;
this._stream.addEventListener(DVRStreamInfoEvent.DVRSTREAMINFO,this.onDVRStreamInfo);
super(param3.isRecording);
}
private function onDVRStreamInfo(param1:DVRStreamInfoEvent) : void
{
this._dvrInfo = param1.info as DVRInfo;
setIsRecording(this._dvrInfo == null ? false : this._dvrInfo.isRecording);
}
}
}
@@ -0,0 +1,59 @@
package org.osmf.net.httpstreaming.dvr
{
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import org.osmf.events.DVRStreamInfoEvent;
import org.osmf.net.NetStreamCodes;
import org.osmf.net.httpstreaming.HTTPNetStream;
import org.osmf.traits.TimeTrait;
public class HTTPStreamingDVRCastTimeTrait extends TimeTrait
{
private var _connection:NetConnection;
private var _stream:HTTPNetStream;
private var _dvrInfo:DVRInfo;
public function HTTPStreamingDVRCastTimeTrait(param1:NetConnection, param2:HTTPNetStream, param3:DVRInfo)
{
super(NaN);
this._connection = param1;
this._stream = param2;
this._dvrInfo = param3;
this._stream.addEventListener(DVRStreamInfoEvent.DVRSTREAMINFO,this.onDVRStreamInfo);
this._stream.addEventListener(NetStatusEvent.NET_STATUS,this.onNetStatus);
}
override public function get duration() : Number
{
if(this._dvrInfo == null)
{
return NaN;
}
return this._dvrInfo.curLength;
}
override public function get currentTime() : Number
{
return this._stream.time;
}
private function onDVRStreamInfo(param1:DVRStreamInfoEvent) : void
{
this._dvrInfo = param1.info as DVRInfo;
setDuration(this._dvrInfo.curLength);
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case NetStreamCodes.NETSTREAM_PLAY_UNPUBLISH_NOTIFY:
signalComplete();
}
}
}
}
@@ -0,0 +1,223 @@
package org.osmf.net.httpstreaming.f4f
{
public class AdobeBootstrapBox extends FullBox
{
private var _bootstrapVersion:uint;
private var _profile:uint;
private var _live:Boolean;
private var _update:Boolean;
private var _timeScale:uint;
private var _currentMediaTime:Number;
private var _smpteTimeCodeOffset:Number;
private var _movieIdentifier:String;
private var _serverEntryCount:uint;
private var _serverBaseURLs:Vector.<String>;
private var _qualitySegmentURLModifiers:Vector.<String>;
private var _drmData:String;
private var _metadata:String;
private var _segmentRunTables:Vector.<AdobeSegmentRunTable>;
private var _fragmentRunTables:Vector.<AdobeFragmentRunTable>;
public function AdobeBootstrapBox()
{
super();
}
public function get bootstrapVersion() : uint
{
return this._bootstrapVersion;
}
public function set bootstrapVersion(param1:uint) : void
{
this._bootstrapVersion = param1;
}
public function get profile() : uint
{
return this._profile;
}
public function set profile(param1:uint) : void
{
this._profile = param1;
}
public function get live() : Boolean
{
return this._live;
}
public function set live(param1:Boolean) : void
{
this._live = param1;
}
public function get update() : Boolean
{
return this._update;
}
public function set update(param1:Boolean) : void
{
this._update = param1;
}
public function get timeScale() : uint
{
return this._timeScale;
}
public function set timeScale(param1:uint) : void
{
this._timeScale = param1;
}
public function get currentMediaTime() : Number
{
return this._currentMediaTime;
}
public function set currentMediaTime(param1:Number) : void
{
this._currentMediaTime = param1;
}
public function get smpteTimeCodeOffset() : Number
{
return this._smpteTimeCodeOffset;
}
public function set smpteTimeCodeOffset(param1:Number) : void
{
this._smpteTimeCodeOffset = param1;
}
public function get movieIdentifier() : String
{
return this._movieIdentifier;
}
public function set movieIdentifier(param1:String) : void
{
this._movieIdentifier = param1;
}
public function get serverBaseURLs() : Vector.<String>
{
return this._serverBaseURLs;
}
public function set serverBaseURLs(param1:Vector.<String>) : void
{
this._serverBaseURLs = param1;
}
public function get qualitySegmentURLModifiers() : Vector.<String>
{
return this._qualitySegmentURLModifiers;
}
public function set qualitySegmentURLModifiers(param1:Vector.<String>) : void
{
this._qualitySegmentURLModifiers = param1;
}
public function get drmData() : String
{
return this._drmData;
}
public function set drmData(param1:String) : void
{
this._drmData = param1;
}
public function get metadata() : String
{
return this._metadata;
}
public function set metadata(param1:String) : void
{
this._metadata = param1;
}
public function get segmentRunTables() : Vector.<AdobeSegmentRunTable>
{
return this._segmentRunTables;
}
public function set segmentRunTables(param1:Vector.<AdobeSegmentRunTable>) : void
{
this._segmentRunTables = param1;
}
public function get fragmentRunTables() : Vector.<AdobeFragmentRunTable>
{
return this._fragmentRunTables;
}
public function set fragmentRunTables(param1:Vector.<AdobeFragmentRunTable>) : void
{
var _loc2_:AdobeFragmentRunTable = null;
this._fragmentRunTables = param1;
if(param1 != null && param1.length > 0)
{
_loc2_ = param1[param1.length - 1];
_loc2_.adjustEndEntryDurationAccrued(this._currentMediaTime);
}
}
public function findSegmentId(param1:uint) : uint
{
return this._segmentRunTables[0].findSegmentIdByFragmentId(param1);
}
public function get totalFragments() : uint
{
var _loc1_:AdobeFragmentRunTable = this._fragmentRunTables[this._fragmentRunTables.length - 1];
var _loc2_:Vector.<FragmentDurationPair> = _loc1_.fragmentDurationPairs;
var _loc3_:FragmentDurationPair = _loc2_[_loc2_.length - 1];
if(_loc3_.duration == 0)
{
_loc3_ = _loc2_[_loc2_.length - 2];
}
var _loc4_:Number = this._currentMediaTime - _loc3_.durationAccrued;
var _loc5_:uint = _loc4_ <= 0 ? 0 : uint(_loc4_ / _loc3_.duration);
return _loc3_.firstFragment + _loc5_ - 1;
}
public function get totalDuration() : uint
{
if(this._fragmentRunTables == null || this._fragmentRunTables.length < 1)
{
return 0;
}
var _loc1_:AdobeFragmentRunTable = this._fragmentRunTables[0];
return this._currentMediaTime - _loc1_.fragmentDurationPairs[0].durationAccrued;
}
public function contentComplete() : Boolean
{
var _loc1_:AdobeFragmentRunTable = this._fragmentRunTables[this._fragmentRunTables.length - 1];
return _loc1_.tableComplete();
}
}
}
@@ -0,0 +1,64 @@
package org.osmf.net.httpstreaming.f4f
{
internal class AdobeFragmentRandomAccessBox extends FullBox
{
private var _timeScale:uint;
private var _localRandomAccessEntries:Vector.<LocalRandomAccessEntry>;
private var _globalRandomAccessEntries:Vector.<GlobalRandomAccessEntry>;
public function AdobeFragmentRandomAccessBox()
{
super();
}
public function get timeScale() : uint
{
return this._timeScale;
}
public function set timeScale(param1:uint) : void
{
this._timeScale = param1;
}
public function get localRandomAccessEntries() : Vector.<LocalRandomAccessEntry>
{
return this._localRandomAccessEntries;
}
public function set localRandomAccessEntries(param1:Vector.<LocalRandomAccessEntry>) : void
{
this._localRandomAccessEntries = param1;
}
public function get globalRandomAccessEntries() : Vector.<GlobalRandomAccessEntry>
{
return this._globalRandomAccessEntries;
}
public function set globalRandomAccessEntries(param1:Vector.<GlobalRandomAccessEntry>) : void
{
this._globalRandomAccessEntries = param1;
}
public function findNearestKeyFrameOffset(param1:Number) : LocalRandomAccessEntry
{
var _loc3_:LocalRandomAccessEntry = null;
var _loc2_:* = int(this._localRandomAccessEntries.length - 1);
while(_loc2_ >= 0)
{
_loc3_ = this._localRandomAccessEntries[_loc2_];
if(_loc3_.time <= param1)
{
return _loc3_;
}
_loc2_--;
}
return null;
}
}
}
@@ -0,0 +1,244 @@
package org.osmf.net.httpstreaming.f4f
{
internal class AdobeFragmentRunTable extends FullBox
{
private var _timeScale:uint;
private var _qualitySegmentURLModifiers:Vector.<String>;
private var _fragmentDurationPairs:Vector.<FragmentDurationPair>;
public function AdobeFragmentRunTable()
{
super();
this._fragmentDurationPairs = new Vector.<FragmentDurationPair>();
}
public function get timeScale() : uint
{
return this._timeScale;
}
public function set timeScale(param1:uint) : void
{
this._timeScale = param1;
}
public function get qualitySegmentURLModifiers() : Vector.<String>
{
return this._qualitySegmentURLModifiers;
}
public function set qualitySegmentURLModifiers(param1:Vector.<String>) : void
{
this._qualitySegmentURLModifiers = param1;
}
public function get fragmentDurationPairs() : Vector.<FragmentDurationPair>
{
return this._fragmentDurationPairs;
}
public function addFragmentDurationPair(param1:FragmentDurationPair) : void
{
this._fragmentDurationPairs.push(param1);
}
public function findFragmentIdByTime(param1:Number, param2:Number, param3:Boolean = false) : FragmentAccessInformation
{
if(this._fragmentDurationPairs.length <= 0)
{
return null;
}
var _loc4_:FragmentDurationPair = null;
var _loc5_:uint = 1;
while(_loc5_ < this._fragmentDurationPairs.length)
{
_loc4_ = this._fragmentDurationPairs[_loc5_];
if(_loc4_.durationAccrued >= param1)
{
return this.validateFragment(this.calculateFragmentId(this._fragmentDurationPairs[_loc5_ - 1],param1),param2,param3);
}
_loc5_++;
}
return this.validateFragment(this.calculateFragmentId(this._fragmentDurationPairs[this._fragmentDurationPairs.length - 1],param1),param2,param3);
}
public function validateFragment(param1:uint, param2:Number, param3:Boolean = false) : FragmentAccessInformation
{
var _loc7_:FragmentDurationPair = null;
var _loc8_:FragmentDurationPair = null;
var _loc9_:Number = NaN;
var _loc10_:Number = NaN;
var _loc11_:Number = NaN;
var _loc12_:FragmentDurationPair = null;
var _loc4_:uint = this._fragmentDurationPairs.length - 1;
var _loc5_:FragmentAccessInformation = null;
var _loc6_:uint = 0;
while(_loc6_ < _loc4_)
{
_loc7_ = this._fragmentDurationPairs[_loc6_];
_loc8_ = this._fragmentDurationPairs[_loc6_ + 1];
if(_loc7_.firstFragment <= param1 && param1 < _loc8_.firstFragment)
{
if(_loc7_.duration <= 0)
{
_loc5_ = this.getNextValidFragment(_loc6_ + 1,param2);
}
else
{
_loc5_ = new FragmentAccessInformation();
_loc5_.fragId = param1;
_loc5_.fragDuration = _loc7_.duration;
_loc5_.fragmentEndTime = _loc7_.durationAccrued + _loc7_.duration * (param1 - _loc7_.firstFragment + 1);
}
break;
}
if(_loc7_.firstFragment <= param1 && this.endOfStreamEntry(_loc8_))
{
if(_loc7_.duration > 0)
{
_loc9_ = param2 - _loc7_.durationAccrued;
_loc10_ = (param1 - _loc7_.firstFragment + 1) * _loc7_.duration;
_loc11_ = (param1 - _loc7_.firstFragment) * _loc7_.duration;
if(_loc9_ > _loc11_)
{
if(!param3 || _loc11_ + _loc7_.duration + _loc7_.durationAccrued <= param2)
{
_loc5_ = new FragmentAccessInformation();
_loc5_.fragId = param1;
_loc5_.fragDuration = _loc7_.duration;
if(_loc9_ >= _loc10_)
{
_loc5_.fragmentEndTime = _loc7_.durationAccrued + _loc10_;
}
else
{
_loc5_.fragmentEndTime = _loc7_.durationAccrued + _loc9_;
}
break;
}
}
}
}
_loc6_++;
}
if(_loc5_ == null)
{
_loc12_ = this._fragmentDurationPairs[_loc4_];
if(_loc12_.duration > 0 && param1 >= _loc12_.firstFragment)
{
_loc9_ = param2 - _loc12_.durationAccrued;
_loc10_ = (param1 - _loc12_.firstFragment + 1) * _loc12_.duration;
_loc11_ = (param1 - _loc12_.firstFragment) * _loc12_.duration;
if(_loc9_ > _loc11_)
{
if(!param3 || _loc11_ + _loc12_.duration + _loc12_.durationAccrued <= param2)
{
_loc5_ = new FragmentAccessInformation();
_loc5_.fragId = param1;
_loc5_.fragDuration = _loc12_.duration;
if(_loc9_ >= _loc10_)
{
_loc5_.fragmentEndTime = _loc12_.durationAccrued + _loc10_;
}
else
{
_loc5_.fragmentEndTime = _loc12_.durationAccrued + _loc9_;
}
}
}
}
}
return _loc5_;
}
private function getNextValidFragment(param1:uint, param2:Number) : FragmentAccessInformation
{
var _loc5_:FragmentDurationPair = null;
var _loc3_:FragmentAccessInformation = null;
var _loc4_:uint = param1;
while(_loc4_ < this._fragmentDurationPairs.length)
{
_loc5_ = this._fragmentDurationPairs[_loc4_];
if(_loc5_.duration > 0)
{
_loc3_ = new FragmentAccessInformation();
_loc3_.fragId = _loc5_.firstFragment;
_loc3_.fragDuration = _loc5_.duration;
_loc3_.fragmentEndTime = _loc5_.durationAccrued + _loc5_.duration;
break;
}
_loc4_++;
}
return _loc3_;
}
private function endOfStreamEntry(param1:FragmentDurationPair) : Boolean
{
return param1.duration == 0 && param1.discontinuityIndicator == 0;
}
public function fragmentsLeft(param1:uint, param2:Number) : uint
{
if(this._fragmentDurationPairs == null || this._fragmentDurationPairs.length == 0)
{
return 0;
}
var _loc3_:FragmentDurationPair = this._fragmentDurationPairs[this.fragmentDurationPairs.length - 1] as FragmentDurationPair;
return uint((param2 - _loc3_.durationAccrued) / _loc3_.duration + _loc3_.firstFragment - param1 - 1);
}
public function tableComplete() : Boolean
{
if(this._fragmentDurationPairs == null || this._fragmentDurationPairs.length <= 0)
{
return false;
}
var _loc1_:FragmentDurationPair = this._fragmentDurationPairs[this.fragmentDurationPairs.length - 1] as FragmentDurationPair;
return _loc1_.duration == 0 && _loc1_.discontinuityIndicator == 0;
}
public function adjustEndEntryDurationAccrued(param1:Number) : void
{
var _loc2_:FragmentDurationPair = this._fragmentDurationPairs[this._fragmentDurationPairs.length - 1];
if(_loc2_.duration == 0)
{
_loc2_.durationAccrued = param1;
}
}
private function findValidFragmentDurationPair(param1:uint) : FragmentDurationPair
{
var _loc3_:FragmentDurationPair = null;
var _loc2_:uint = param1;
while(param1 < this._fragmentDurationPairs.length)
{
_loc3_ = this._fragmentDurationPairs[_loc2_];
if(_loc3_.duration > 0)
{
return _loc3_;
}
_loc2_++;
}
return null;
}
private function calculateFragmentId(param1:FragmentDurationPair, param2:Number) : uint
{
if(param1.duration <= 0)
{
return param1.firstFragment;
}
var _loc3_:Number = param2 - param1.durationAccrued;
var _loc4_:uint = _loc3_ > 0 ? uint(_loc3_ / param1.duration) : 1;
if(_loc3_ % param1.duration > 0)
{
_loc4_++;
}
return param1.firstFragment + _loc4_ - 1;
}
}
}
@@ -0,0 +1,74 @@
package org.osmf.net.httpstreaming.f4f
{
internal class AdobeSegmentRunTable extends FullBox
{
private var _qualitySegmentURLModifiers:Vector.<String>;
private var _segmentFragmentPairs:Vector.<SegmentFragmentPair>;
public function AdobeSegmentRunTable()
{
super();
this._segmentFragmentPairs = new Vector.<SegmentFragmentPair>();
}
public function get qualitySegmentURLModifiers() : Vector.<String>
{
return this._qualitySegmentURLModifiers;
}
public function set qualitySegmentURLModifiers(param1:Vector.<String>) : void
{
this._qualitySegmentURLModifiers = param1;
}
public function get segmentFragmentPairs() : Vector.<SegmentFragmentPair>
{
return this._segmentFragmentPairs;
}
public function addSegmentFragmentPair(param1:SegmentFragmentPair) : void
{
var _loc2_:SegmentFragmentPair = this._segmentFragmentPairs.length <= 0 ? null : this._segmentFragmentPairs[this._segmentFragmentPairs.length - 1];
var _loc3_:uint = 0;
if(_loc2_ != null)
{
_loc3_ = _loc2_.fragmentsAccrued + (param1.firstSegment - _loc2_.firstSegment) * _loc2_.fragmentsPerSegment;
}
param1.fragmentsAccrued = _loc3_;
this._segmentFragmentPairs.push(param1);
}
public function findSegmentIdByFragmentId(param1:uint) : uint
{
var _loc2_:SegmentFragmentPair = null;
if(param1 < 1)
{
return 0;
}
var _loc3_:uint = 1;
while(_loc3_ < this._segmentFragmentPairs.length)
{
_loc2_ = this._segmentFragmentPairs[_loc3_];
if(_loc2_.fragmentsAccrued >= param1)
{
return this.calculateSegmentId(this._segmentFragmentPairs[_loc3_ - 1],param1);
}
_loc3_++;
}
return this.calculateSegmentId(this._segmentFragmentPairs[this._segmentFragmentPairs.length - 1],param1);
}
public function get totalFragments() : uint
{
return this._segmentFragmentPairs[this._segmentFragmentPairs.length - 1].fragmentsPerSegment + this._segmentFragmentPairs[this._segmentFragmentPairs.length - 1].fragmentsAccrued;
}
private function calculateSegmentId(param1:SegmentFragmentPair, param2:uint) : uint
{
return param1.firstSegment + int((param2 - param1.fragmentsAccrued - 1) / param1.fragmentsPerSegment);
}
}
}
@@ -0,0 +1,48 @@
package org.osmf.net.httpstreaming.f4f
{
internal class Box
{
private var _size:Number;
private var _type:String;
private var _boxLength:uint;
public function Box()
{
super();
}
public function get size() : Number
{
return this._size;
}
public function set size(param1:Number) : void
{
this._size = param1;
}
public function get type() : String
{
return this._type;
}
public function set type(param1:String) : void
{
this._type = param1;
}
public function get boxLength() : uint
{
return this._boxLength;
}
public function set boxLength(param1:uint) : void
{
this._boxLength = param1;
}
}
}
@@ -0,0 +1,33 @@
package org.osmf.net.httpstreaming.f4f
{
internal class BoxInfo
{
private var _size:Number;
private var _type:String;
public function BoxInfo(param1:Number, param2:String)
{
super();
this._size = param1;
this._type = param2;
}
public function get size() : Number
{
return this._size;
}
public function set size(param1:Number) : void
{
this._size = param1;
}
public function get type() : String
{
return this._type;
}
}
}
@@ -0,0 +1,412 @@
package org.osmf.net.httpstreaming.f4f
{
import flash.errors.IllegalOperationError;
import flash.events.EventDispatcher;
import flash.utils.ByteArray;
internal class BoxParser extends EventDispatcher
{
private static const FULL_BOX_FIELD_FLAGS_LENGTH:uint = 3;
private static const AFRA_MASK_LONG_ID:uint = 128;
private static const AFRA_MASK_LONG_OFFSET:uint = 64;
private static const AFRA_MASK_GLOBAL_ENTRIES:uint = 32;
private var _ba:ByteArray;
public function BoxParser()
{
super();
this._ba = null;
}
public function init(param1:ByteArray) : void
{
this._ba = param1;
this._ba.position = 0;
}
public function getNextBoxInfo() : BoxInfo
{
if(this._ba == null || this._ba.bytesAvailable < F4FConstants.FIELD_SIZE_LENGTH + F4FConstants.FIELD_TYPE_LENGTH)
{
return null;
}
var _loc1_:Number = this._ba.readUnsignedInt();
var _loc2_:String = this._ba.readUTFBytes(F4FConstants.FIELD_TYPE_LENGTH);
return new BoxInfo(_loc1_,_loc2_);
}
public function getBoxes() : Vector.<Box>
{
var _loc3_:AdobeBootstrapBox = null;
var _loc4_:AdobeFragmentRandomAccessBox = null;
var _loc5_:MediaDataBox = null;
var _loc1_:Vector.<Box> = new Vector.<Box>();
var _loc2_:BoxInfo = this.getNextBoxInfo();
while(_loc2_ != null)
{
if(_loc2_.type == F4FConstants.BOX_TYPE_ABST)
{
_loc3_ = new AdobeBootstrapBox();
this.parseAdobeBootstrapBox(_loc2_,_loc3_);
_loc1_.push(_loc3_);
}
else if(_loc2_.type == F4FConstants.BOX_TYPE_AFRA)
{
_loc4_ = new AdobeFragmentRandomAccessBox();
this.parseAdobeFragmentRandomAccessBox(_loc2_,_loc4_);
_loc1_.push(_loc4_);
}
else if(_loc2_.type == F4FConstants.BOX_TYPE_MDAT)
{
_loc5_ = new MediaDataBox();
this.parseMediaDataBox(_loc2_,_loc5_);
_loc1_.push(_loc5_);
}
else
{
this._ba.position = this._ba.position + _loc2_.size - (F4FConstants.FIELD_SIZE_LENGTH + F4FConstants.FIELD_TYPE_LENGTH);
}
_loc2_ = this.getNextBoxInfo();
if(_loc2_ != null && _loc2_.size <= 0)
{
break;
}
}
return _loc1_;
}
public function readFragmentRandomAccessBox(param1:BoxInfo) : AdobeFragmentRandomAccessBox
{
var _loc2_:AdobeFragmentRandomAccessBox = new AdobeFragmentRandomAccessBox();
this.parseAdobeFragmentRandomAccessBox(param1,_loc2_);
return _loc2_;
}
public function readAdobeBootstrapBox(param1:BoxInfo) : AdobeBootstrapBox
{
var _loc2_:AdobeBootstrapBox = new AdobeBootstrapBox();
this.parseAdobeBootstrapBox(param1,_loc2_);
return _loc2_;
}
internal function readLongUIntToNumber() : Number
{
if(this._ba == null || this._ba.bytesAvailable < 8)
{
throw new IllegalOperationError("not enough length for readLongUIntToNumer");
}
var _loc1_:Number = this._ba.readUnsignedInt();
_loc1_ *= 4294967296;
return _loc1_ + this._ba.readUnsignedInt();
}
private function readUnsignedInt() : uint
{
if(this._ba == null || this._ba.bytesAvailable < 4)
{
throw new IllegalOperationError("not enough length for readUnsignedInt");
}
return this._ba.readUnsignedInt();
}
private function readBytes(param1:ByteArray, param2:uint = 0, param3:uint = 0) : void
{
if(this._ba == null || this._ba.bytesAvailable < param3)
{
throw new IllegalOperationError("not enough length for readBytes: " + param3);
}
return this._ba.readBytes(param1,param2,param3);
}
private function readUnsignedByte() : uint
{
if(this._ba == null || this._ba.bytesAvailable < 1)
{
throw new IllegalOperationError("not enough length for readUnsingedByte");
}
return this._ba.readUnsignedByte();
}
private function readBytesToUint(param1:uint) : uint
{
var _loc4_:uint = 0;
if(this._ba == null || this._ba.bytesAvailable < param1)
{
throw new IllegalOperationError("not enough length for readUnsingedByte");
}
if(param1 > 4)
{
throw new IllegalOperationError("number of bytes to read must be equal or less than 4");
}
var _loc2_:uint = 0;
var _loc3_:uint = 0;
while(_loc3_ < param1)
{
_loc2_ <<= 8;
_loc4_ = this._ba.readUnsignedByte();
_loc2_ += _loc4_;
_loc3_++;
}
return _loc2_;
}
private function readString() : String
{
var _loc3_:uint = 0;
var _loc1_:uint = this._ba.position;
while(this._ba.position < this._ba.length)
{
_loc3_ = uint(this._ba.readByte());
if(_loc3_ == 0)
{
break;
}
}
var _loc2_:uint = this._ba.position - _loc1_;
this._ba.position = _loc1_;
return this._ba.readUTFBytes(_loc2_);
}
private function parseBox(param1:BoxInfo, param2:Box) : void
{
var _loc5_:ByteArray = null;
var _loc3_:Number = param1.size;
var _loc4_:uint = F4FConstants.FIELD_SIZE_LENGTH + F4FConstants.FIELD_TYPE_LENGTH;
if(param1.size == F4FConstants.FLAG_USE_LARGE_SIZE)
{
_loc3_ = this.readLongUIntToNumber();
_loc4_ += F4FConstants.FIELD_LARGE_SIZE_LENGTH;
}
if(param1.type == F4FConstants.EXTENDED_TYPE)
{
_loc5_ = new ByteArray();
this.readBytes(_loc5_,0,F4FConstants.FIELD_EXTENDED_TYPE_LENGTH);
_loc4_ += F4FConstants.FIELD_EXTENDED_TYPE_LENGTH;
}
param2.size = _loc3_;
param2.type = param1.type;
param2.boxLength = _loc4_;
}
private function parseFullBox(param1:BoxInfo, param2:FullBox) : void
{
this.parseBox(param1,param2);
param2.version = this.readUnsignedByte();
param2.flags = this.readBytesToUint(FULL_BOX_FIELD_FLAGS_LENGTH);
}
private function parseAdobeBootstrapBox(param1:BoxInfo, param2:AdobeBootstrapBox) : void
{
var _loc13_:AdobeSegmentRunTable = null;
var _loc14_:AdobeFragmentRunTable = null;
this.parseFullBox(param1,param2);
param2.bootstrapVersion = this.readUnsignedInt();
var _loc3_:uint = this.readUnsignedByte();
param2.profile = _loc3_ >> 6;
param2.live = (_loc3_ & 0x20) == 32;
param2.update = (_loc3_ & 1) == 1;
param2.timeScale = this.readUnsignedInt();
param2.currentMediaTime = this.readLongUIntToNumber();
param2.smpteTimeCodeOffset = this.readLongUIntToNumber();
param2.movieIdentifier = this.readString();
var _loc4_:uint = this.readUnsignedByte();
var _loc5_:Vector.<String> = new Vector.<String>();
var _loc6_:int = 0;
while(_loc6_ < _loc4_)
{
_loc5_.push(this.readString());
_loc6_++;
}
param2.serverBaseURLs = _loc5_;
var _loc7_:uint = this.readUnsignedByte();
var _loc8_:Vector.<String> = new Vector.<String>();
_loc6_ = 0;
while(_loc6_ < _loc7_)
{
_loc8_.push(this.readString());
_loc6_++;
}
param2.qualitySegmentURLModifiers = _loc8_;
param2.drmData = this.readString();
param2.metadata = this.readString();
var _loc9_:uint = this.readUnsignedByte();
var _loc10_:Vector.<AdobeSegmentRunTable> = new Vector.<AdobeSegmentRunTable>();
_loc6_ = 0;
while(_loc6_ < _loc9_)
{
param1 = this.getNextBoxInfo();
if(param1.type != F4FConstants.BOX_TYPE_ASRT)
{
throw new IllegalOperationError("Unexpected data structure: " + param1.type);
}
_loc13_ = new AdobeSegmentRunTable();
this.parseAdobeSegmentRunTable(param1,_loc13_);
_loc10_.push(_loc13_);
_loc6_++;
}
param2.segmentRunTables = _loc10_;
var _loc11_:uint = this.readUnsignedByte();
var _loc12_:Vector.<AdobeFragmentRunTable> = new Vector.<AdobeFragmentRunTable>();
_loc6_ = 0;
while(_loc6_ < _loc11_)
{
param1 = this.getNextBoxInfo();
if(param1.type != F4FConstants.BOX_TYPE_AFRT)
{
throw new IllegalOperationError("Unexpected data structure: " + param1.type);
}
_loc14_ = new AdobeFragmentRunTable();
this.parseAdobeFragmentRunTable(param1,_loc14_);
_loc12_.push(_loc14_);
_loc6_++;
}
param2.fragmentRunTables = _loc12_;
}
private function parseAdobeSegmentRunTable(param1:BoxInfo, param2:AdobeSegmentRunTable) : void
{
this.parseFullBox(param1,param2);
var _loc3_:uint = this.readUnsignedByte();
var _loc4_:Vector.<String> = new Vector.<String>();
var _loc5_:uint = 0;
while(_loc5_ < _loc3_)
{
_loc4_.push(this.readString());
_loc5_++;
}
param2.qualitySegmentURLModifiers = _loc4_;
var _loc6_:uint = this.readUnsignedInt();
_loc5_ = 0;
while(_loc5_ < _loc6_)
{
param2.addSegmentFragmentPair(new SegmentFragmentPair(this.readUnsignedInt(),this.readUnsignedInt()));
_loc5_++;
}
}
private function parseAdobeFragmentRunTable(param1:BoxInfo, param2:AdobeFragmentRunTable) : void
{
var _loc7_:FragmentDurationPair = null;
this.parseFullBox(param1,param2);
param2.timeScale = this.readUnsignedInt();
var _loc3_:uint = this.readUnsignedByte();
var _loc4_:Vector.<String> = new Vector.<String>();
var _loc5_:uint = 0;
while(_loc5_ < _loc3_)
{
_loc4_.push(this.readString());
_loc5_++;
}
param2.qualitySegmentURLModifiers = _loc4_;
var _loc6_:uint = this.readUnsignedInt();
_loc5_ = 0;
while(_loc5_ < _loc6_)
{
_loc7_ = new FragmentDurationPair();
this.parseFragmentDurationPair(_loc7_);
param2.addFragmentDurationPair(_loc7_);
_loc5_++;
}
}
private function parseFragmentDurationPair(param1:FragmentDurationPair) : void
{
param1.firstFragment = this.readUnsignedInt();
param1.durationAccrued = this.readLongUIntToNumber();
param1.duration = this.readUnsignedInt();
if(param1.duration == 0)
{
param1.discontinuityIndicator = this.readUnsignedByte();
}
}
private function parseAdobeFragmentRandomAccessBox(param1:BoxInfo, param2:AdobeFragmentRandomAccessBox) : void
{
var _loc11_:LocalRandomAccessEntry = null;
var _loc12_:GlobalRandomAccessEntry = null;
this.parseFullBox(param1,param2);
var _loc3_:uint = this.readBytesToUint(1);
var _loc4_:Boolean = (_loc3_ & AFRA_MASK_LONG_ID) > 0;
var _loc5_:Boolean = (_loc3_ & AFRA_MASK_LONG_OFFSET) > 0;
var _loc6_:Boolean = (_loc3_ & AFRA_MASK_GLOBAL_ENTRIES) > 0;
param2.timeScale = this.readUnsignedInt();
var _loc7_:uint = this.readUnsignedInt();
var _loc8_:Vector.<LocalRandomAccessEntry> = new Vector.<LocalRandomAccessEntry>();
var _loc9_:uint = 0;
while(_loc9_ < _loc7_)
{
_loc11_ = new LocalRandomAccessEntry();
this.parseLocalRandomAccessEntry(_loc11_,_loc5_);
_loc8_.push(_loc11_);
_loc9_++;
}
param2.localRandomAccessEntries = _loc8_;
var _loc10_:Vector.<GlobalRandomAccessEntry> = new Vector.<GlobalRandomAccessEntry>();
if(_loc6_)
{
_loc7_ = this.readUnsignedInt();
_loc9_ = 0;
while(_loc9_ < _loc7_)
{
_loc12_ = new GlobalRandomAccessEntry();
this.parseGlobalRandomAccessEntry(_loc12_,_loc4_,_loc5_);
_loc10_.push(_loc12_);
_loc9_++;
}
}
param2.globalRandomAccessEntries = _loc10_;
}
private function parseLocalRandomAccessEntry(param1:LocalRandomAccessEntry, param2:Boolean) : void
{
param1.time = this.readLongUIntToNumber();
if(param2)
{
param1.offset = this.readLongUIntToNumber();
}
else
{
param1.offset = this.readUnsignedInt();
}
}
private function parseGlobalRandomAccessEntry(param1:GlobalRandomAccessEntry, param2:Boolean, param3:Boolean) : void
{
param1.time = this.readLongUIntToNumber();
if(param2)
{
param1.segment = this.readUnsignedInt();
param1.fragment = this.readUnsignedInt();
}
else
{
param1.segment = this.readBytesToUint(2);
param1.fragment = this.readBytesToUint(2);
}
if(param3)
{
param1.afraOffset = this.readLongUIntToNumber();
param1.offsetFromAfra = this.readLongUIntToNumber();
}
else
{
param1.afraOffset = this.readUnsignedInt();
param1.offsetFromAfra = this.readUnsignedInt();
}
}
private function parseMediaDataBox(param1:BoxInfo, param2:MediaDataBox) : void
{
this.parseBox(param1,param2);
var _loc3_:ByteArray = new ByteArray();
this.readBytes(_loc3_,0,param2.size - param2.boxLength);
param2.data = _loc3_;
}
}
}
@@ -0,0 +1,38 @@
package org.osmf.net.httpstreaming.f4f
{
internal class F4FConstants
{
internal static const BOX_TYPE_UUID:String = "uuid";
internal static const BOX_TYPE_ABST:String = "abst";
internal static const BOX_TYPE_ASRT:String = "asrt";
internal static const BOX_TYPE_AFRT:String = "afrt";
internal static const BOX_TYPE_AFRA:String = "afra";
internal static const BOX_TYPE_MDAT:String = "mdat";
internal static const BOX_TYPE_MOOF:String = "moof";
internal static const EXTENDED_TYPE:String = "uuid";
internal static const FIELD_SIZE_LENGTH:uint = 4;
internal static const FIELD_TYPE_LENGTH:uint = 4;
internal static const FIELD_LARGE_SIZE_LENGTH:uint = 8;
internal static const FIELD_EXTENDED_TYPE_LENGTH:uint = 16;
internal static const FLAG_USE_LARGE_SIZE:uint = 1;
public function F4FConstants()
{
super();
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.net.httpstreaming.f4f
{
internal class FragmentAccessInformation
{
public var fragId:uint;
public var fragmentEndTime:Number;
public var fragDuration:uint;
public function FragmentAccessInformation()
{
super();
}
}
}
@@ -0,0 +1,60 @@
package org.osmf.net.httpstreaming.f4f
{
internal class FragmentDurationPair
{
private var _firstFragment:uint;
private var _duration:uint;
private var _durationAccrued:Number;
private var _discontinuityIndicator:uint = 0;
public function FragmentDurationPair()
{
super();
}
public function get firstFragment() : uint
{
return this._firstFragment;
}
public function set firstFragment(param1:uint) : void
{
this._firstFragment = param1;
}
public function get duration() : uint
{
return this._duration;
}
public function set duration(param1:uint) : void
{
this._duration = param1;
}
public function get durationAccrued() : Number
{
return this._durationAccrued;
}
public function set durationAccrued(param1:Number) : void
{
this._durationAccrued = param1;
}
public function get discontinuityIndicator() : uint
{
return this._discontinuityIndicator;
}
public function set discontinuityIndicator(param1:uint) : void
{
this._discontinuityIndicator = param1;
}
}
}
@@ -0,0 +1,36 @@
package org.osmf.net.httpstreaming.f4f
{
internal class FullBox extends Box
{
private var _version:uint;
private var _flags:uint;
public function FullBox()
{
super();
}
public function get version() : uint
{
return this._version;
}
public function set version(param1:uint) : void
{
this._version = param1;
}
public function get flags() : uint
{
return this._flags;
}
public function set flags(param1:uint) : void
{
this._flags = param1;
}
}
}
@@ -0,0 +1,72 @@
package org.osmf.net.httpstreaming.f4f
{
internal class GlobalRandomAccessEntry
{
private var _time:Number;
private var _segment:uint;
private var _fragment:uint;
private var _afraOffset:Number;
private var _offsetFromAfra:Number;
public function GlobalRandomAccessEntry()
{
super();
}
public function get time() : Number
{
return this._time;
}
public function set time(param1:Number) : void
{
this._time = param1;
}
public function get segment() : uint
{
return this._segment;
}
public function set segment(param1:uint) : void
{
this._segment = param1;
}
public function get fragment() : uint
{
return this._fragment;
}
public function set fragment(param1:uint) : void
{
this._fragment = param1;
}
public function get afraOffset() : Number
{
return this._afraOffset;
}
public function set afraOffset(param1:Number) : void
{
this._afraOffset = param1;
}
public function get offsetFromAfra() : Number
{
return this._offsetFromAfra;
}
public function set offsetFromAfra(param1:Number) : void
{
this._offsetFromAfra = param1;
}
}
}
@@ -0,0 +1,226 @@
package org.osmf.net.httpstreaming.f4f
{
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import org.osmf.events.HTTPStreamingFileHandlerEvent;
import org.osmf.net.httpstreaming.HTTPStreamingFileHandlerBase;
public class HTTPStreamingF4FFileHandler extends HTTPStreamingFileHandlerBase
{
private static const MAX_BYTES_PER_MDAT_READ:uint = 5 * 1024;
private var _afra:AdobeFragmentRandomAccessBox;
private var _ba:ByteArray;
private var _boxInfoPending:Boolean;
private var _bytesNeeded:uint;
private var _bytesReadSinceAfraStart:uint;
private var _countingReadBytes:Boolean;
private var _mdatBytesPending:uint;
private var _nextBox:BoxInfo;
private var _parser:BoxParser = new BoxParser();
private var _seekToTime:Number;
private var _mdatBytesOffset:Number;
private var _processRequestWasSeek:Boolean = false;
public function HTTPStreamingF4FFileHandler()
{
super();
}
override public function beginProcessFile(param1:Boolean, param2:Number) : void
{
this._processRequestWasSeek = param1;
this._seekToTime = param1 ? param2 : 0;
this._bytesNeeded = F4FConstants.FIELD_SIZE_LENGTH + F4FConstants.FIELD_TYPE_LENGTH + F4FConstants.FIELD_LARGE_SIZE_LENGTH + F4FConstants.FIELD_EXTENDED_TYPE_LENGTH;
this._bytesReadSinceAfraStart = 0;
this._countingReadBytes = false;
this._boxInfoPending = true;
this._nextBox = null;
}
override public function get inputBytesNeeded() : Number
{
return this._bytesNeeded;
}
override public function processFileSegment(param1:IDataInput) : ByteArray
{
var _loc4_:uint = 0;
var _loc5_:AdobeBootstrapBox = null;
if(param1.bytesAvailable < this._bytesNeeded)
{
return null;
}
var _loc2_:ByteArray = null;
var _loc3_:Number = F4FConstants.FIELD_SIZE_LENGTH + F4FConstants.FIELD_TYPE_LENGTH;
if(this._boxInfoPending)
{
this._ba = new ByteArray();
param1.readBytes(this._ba,0,_loc3_);
if(this._countingReadBytes)
{
this._bytesReadSinceAfraStart += _loc3_;
}
this._parser.init(this._ba);
this._nextBox = this._parser.getNextBoxInfo();
if(this._nextBox.size == F4FConstants.FLAG_USE_LARGE_SIZE)
{
_loc3_ += F4FConstants.FIELD_LARGE_SIZE_LENGTH;
this._ba.position = 0;
param1.readBytes(this._ba,0,F4FConstants.FIELD_LARGE_SIZE_LENGTH);
if(this._countingReadBytes)
{
this._bytesReadSinceAfraStart += F4FConstants.FIELD_LARGE_SIZE_LENGTH;
}
this._nextBox.size = this._parser.readLongUIntToNumber();
}
this._boxInfoPending = false;
if(this._nextBox.type == F4FConstants.BOX_TYPE_MDAT)
{
this._bytesNeeded = 0;
this._mdatBytesPending = this._nextBox.size - _loc3_;
}
else
{
this._bytesNeeded = this._nextBox.size - _loc3_;
this._mdatBytesPending = 0;
if(this._nextBox.type == F4FConstants.BOX_TYPE_AFRA)
{
this._bytesReadSinceAfraStart = _loc3_;
this._countingReadBytes = true;
}
}
}
else if(this._bytesNeeded > 0)
{
_loc4_ = this._ba.position;
param1.readBytes(this._ba,this._ba.length,this._nextBox.size - _loc3_);
if(this._countingReadBytes)
{
this._bytesReadSinceAfraStart += this._nextBox.size - _loc3_;
}
this._ba.position = _loc4_;
if(this._nextBox.type == F4FConstants.BOX_TYPE_ABST)
{
_loc5_ = this._parser.readAdobeBootstrapBox(this._nextBox);
if(_loc5_ != null)
{
dispatchEvent(new HTTPStreamingFileHandlerEvent(HTTPStreamingFileHandlerEvent.NOTIFY_BOOTSTRAP_BOX,false,false,0,null,false,false,_loc5_));
}
}
else if(this._nextBox.type == F4FConstants.BOX_TYPE_AFRA)
{
this._afra = this._parser.readFragmentRandomAccessBox(this._nextBox);
this.processSeekToTime();
}
else if(this._nextBox.type == F4FConstants.BOX_TYPE_MOOF)
{
}
this._bytesNeeded = F4FConstants.FIELD_SIZE_LENGTH + F4FConstants.FIELD_TYPE_LENGTH + F4FConstants.FIELD_LARGE_SIZE_LENGTH + F4FConstants.FIELD_EXTENDED_TYPE_LENGTH;
this._boxInfoPending = true;
this._nextBox = null;
}
else
{
_loc2_ = this.getMDATBytes(param1,false);
}
return _loc2_;
}
override public function endProcessFile(param1:IDataInput) : ByteArray
{
if(this._bytesNeeded > 0)
{
dispatchEvent(new HTTPStreamingFileHandlerEvent(HTTPStreamingFileHandlerEvent.NOTIFY_ERROR,false,false,0,null,false,false,null,true));
}
return this.getMDATBytes(param1,true);
}
override public function flushFileSegment(param1:IDataInput) : ByteArray
{
return null;
}
private function getMDATBytes(param1:IDataInput, param2:Boolean) : ByteArray
{
var _loc3_:ByteArray = null;
var _loc4_:uint = 0;
if(param1 == null)
{
return null;
}
this.skipSeekBytes(param1);
if(this._mdatBytesPending > 0)
{
_loc4_ = this._mdatBytesPending < param1.bytesAvailable ? this._mdatBytesPending : param1.bytesAvailable;
if(!param2 && _loc4_ > MAX_BYTES_PER_MDAT_READ)
{
_loc4_ = MAX_BYTES_PER_MDAT_READ;
}
_loc3_ = new ByteArray();
this._mdatBytesPending -= _loc4_;
param1.readBytes(_loc3_,0,_loc4_);
}
return _loc3_;
}
private function skipSeekBytes(param1:IDataInput) : void
{
var _loc2_:uint = 0;
var _loc3_:ByteArray = null;
if(this._bytesReadSinceAfraStart < this._mdatBytesOffset)
{
_loc2_ = this._mdatBytesOffset - this._bytesReadSinceAfraStart;
if(param1.bytesAvailable < _loc2_)
{
_loc2_ = param1.bytesAvailable;
}
_loc3_ = new ByteArray();
param1.readBytes(_loc3_,0,_loc2_);
this._bytesReadSinceAfraStart += _loc2_;
this._mdatBytesPending -= _loc2_;
}
}
private function processSeekToTime() : void
{
var _loc1_:Number = 0;
var _loc2_:LocalRandomAccessEntry = null;
if(this._seekToTime <= 0)
{
this._mdatBytesOffset = 0;
}
else
{
_loc2_ = this.getMDATBytesOffset(this._seekToTime);
if(_loc2_ != null)
{
this._mdatBytesOffset = _loc2_.offset;
_loc1_ = _loc2_.time;
}
else
{
this._mdatBytesOffset = 0;
}
}
}
private function getMDATBytesOffset(param1:Number) : LocalRandomAccessEntry
{
return !isNaN(param1) ? this._afra.findNearestKeyFrameOffset(param1 * this._afra.timeScale) : null;
}
}
}
@@ -0,0 +1,496 @@
package org.osmf.net.httpstreaming.f4f
{
import flash.net.URLRequest;
import flash.utils.ByteArray;
import org.osmf.elements.f4mClasses.BootstrapInfo;
import org.osmf.events.DVRStreamInfoEvent;
import org.osmf.events.HTTPStreamingFileHandlerEvent;
import org.osmf.events.HTTPStreamingIndexHandlerEvent;
import org.osmf.net.dvr.DVRUtils;
import org.osmf.net.httpstreaming.HTTPStreamRequest;
import org.osmf.net.httpstreaming.HTTPStreamingFileHandlerBase;
import org.osmf.net.httpstreaming.HTTPStreamingIndexHandlerBase;
import org.osmf.net.httpstreaming.HTTPStreamingUtils;
import org.osmf.net.httpstreaming.flv.FLVTagScriptDataObject;
public class HTTPStreamingF4FIndexHandler extends HTTPStreamingIndexHandlerBase
{
public static const DEFAULT_FRAGMENTS_THRESHOLD:uint = 5;
private var pendingIndexLoads:int;
private var pendingIndexUpdates:int;
private var bootstrapBoxes:Vector.<AdobeBootstrapBox>;
private var serverBaseURL:String;
private var streamInfos:Vector.<HTTPStreamingF4FStreamInfo>;
private var currentQuality:int;
private var currentFAI:FragmentAccessInformation;
private var fragmentsThreshold:uint;
private var fragmentRunTablesUpdating:Boolean;
private var f4fIndexInfo:HTTPStreamingF4FIndexInfo;
private var fileHandler:HTTPStreamingFileHandlerBase;
private var dvrGetStreamInfoCall:Boolean;
private var playInProgress:Boolean;
private var offsetFromCurrent:Number = 5;
private var delay:Number = 0.05;
private var pureLiveOffset:Number = NaN;
public function HTTPStreamingF4FIndexHandler(param1:HTTPStreamingFileHandlerBase, param2:uint = 5)
{
super();
this.currentQuality = -1;
this.currentFAI = null;
this.fragmentRunTablesUpdating = false;
this.fileHandler = param1;
this.fragmentsThreshold = param2;
this.dvrGetStreamInfoCall = false;
param1.addEventListener(HTTPStreamingFileHandlerEvent.NOTIFY_BOOTSTRAP_BOX,this.onNewBootstrapBox);
}
public function get bootstrapInfo() : AdobeBootstrapBox
{
return this.currentQuality < 0 ? null : this.bootstrapBoxes[this.currentQuality];
}
override public function dvrGetStreamInfo(param1:Object) : void
{
this.dvrGetStreamInfoCall = true;
this.playInProgress = false;
this.initialize(param1);
}
override public function initialize(param1:Object) : void
{
var _loc2_:AdobeBootstrapBox = null;
var _loc4_:BootstrapInfo = null;
this.f4fIndexInfo = param1 as HTTPStreamingF4FIndexInfo;
if(this.f4fIndexInfo == null || this.f4fIndexInfo.streamInfos == null || this.f4fIndexInfo.streamInfos.length <= 0)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_ERROR));
return;
}
this.bootstrapBoxes = new Vector.<AdobeBootstrapBox>(this.f4fIndexInfo.streamInfos.length);
this.fragmentRunTablesUpdating = false;
this.playInProgress = false;
this.pendingIndexLoads = 0;
this.pureLiveOffset = NaN;
this.serverBaseURL = this.f4fIndexInfo.serverBaseURL;
this.streamInfos = this.f4fIndexInfo.streamInfos;
var _loc3_:int = 0;
while(_loc3_ < this.streamInfos.length)
{
_loc4_ = this.streamInfos[_loc3_].bootstrapInfo;
if(_loc4_ == null || _loc4_.url == null && _loc4_.data == null)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_ERROR));
return;
}
if(_loc4_.data != null)
{
_loc2_ = this.processBootstrapData(_loc4_.data,null);
if(_loc2_ == null)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_ERROR));
return;
}
this.bootstrapBoxes[_loc3_] = _loc2_;
}
else
{
++this.pendingIndexLoads;
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.REQUEST_LOAD_INDEX,false,false,false,NaN,null,null,new URLRequest(HTTPStreamingUtils.normalizeURL(_loc4_.url)),_loc3_,true));
}
_loc3_++;
}
if(this.pendingIndexLoads == 0)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_RATES,false,false,false,NaN,this.getStreamNames(this.streamInfos),this.getQualityRates(this.streamInfos)));
this.notifyIndexReady(0);
}
}
override public function processIndexData(param1:*, param2:Object) : void
{
var _loc3_:int = param2 as int;
var _loc4_:AdobeBootstrapBox = this.processBootstrapData(param1,_loc3_);
if(_loc4_ == null)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_ERROR));
return;
}
if(!this.fragmentRunTablesUpdating)
{
--this.pendingIndexLoads;
}
else
{
--this.pendingIndexUpdates;
if(this.pendingIndexUpdates == 0)
{
this.fragmentRunTablesUpdating = false;
this.dispatchDVRStreamInfo(_loc4_);
}
}
if(this.bootstrapBoxes[_loc3_] == null || this.bootstrapBoxes[_loc3_].bootstrapVersion < _loc4_.bootstrapVersion || this.bootstrapBoxes[_loc3_].currentMediaTime < _loc4_.currentMediaTime)
{
this.delay = 0.05;
this.bootstrapBoxes[_loc3_] = _loc4_;
}
if(this.pendingIndexLoads == 0 && !this.fragmentRunTablesUpdating)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_RATES,false,false,false,NaN,this.getStreamNames(this.streamInfos),this.getQualityRates(this.streamInfos)));
this.notifyIndexReady(_loc3_);
}
}
override public function getFileForTime(param1:Number, param2:int) : HTTPStreamRequest
{
var _loc6_:FragmentDurationPair = null;
var _loc7_:uint = 0;
var _loc8_:String = null;
var _loc3_:AdobeBootstrapBox = this.bootstrapBoxes[param2];
var _loc4_:HTTPStreamRequest = null;
if(!this.playInProgress && this.stopPlaying(_loc3_))
{
return null;
}
this.checkMetadata(param2,_loc3_);
var _loc5_:AdobeFragmentRunTable = this.getFragmentRunTable(_loc3_);
if(param1 >= 0 && param1 * _loc3_.timeScale <= _loc3_.currentMediaTime && param2 >= 0 && param2 < this.streamInfos.length)
{
this.currentFAI = _loc5_.findFragmentIdByTime(param1 * _loc3_.timeScale,_loc3_.currentMediaTime,_loc3_.contentComplete() ? false : _loc3_.live);
if(this.currentFAI == null || this.fragmentOverflow(_loc3_,this.currentFAI.fragId))
{
if(_loc3_.contentComplete())
{
if(_loc3_.live)
{
return new HTTPStreamRequest(null,param2,-1,-1,true);
}
return null;
}
this.adjustDelay();
this.refreshBootstrapInfo(param2);
return new HTTPStreamRequest(null,param2,0,this.delay);
}
this.playInProgress = true;
_loc6_ = _loc5_.fragmentDurationPairs[0];
_loc7_ = _loc3_.findSegmentId(this.currentFAI.fragId - _loc6_.firstFragment + 1);
_loc8_ = "";
if((this.streamInfos[param2].streamName as String).indexOf("http") != 0)
{
_loc8_ = this.serverBaseURL + "/" + this.streamInfos[param2].streamName + "Seg" + _loc7_ + "-Frag" + this.currentFAI.fragId;
}
else
{
_loc8_ = this.streamInfos[param2].streamName + "Seg" + _loc7_ + "-Frag" + this.currentFAI.fragId;
}
_loc4_ = new HTTPStreamRequest(_loc8_);
this.checkQuality(param2);
this.notifyFragmentDuration(this.currentFAI.fragDuration / _loc3_.timeScale);
}
return _loc4_;
}
override public function getNextFile(param1:int) : HTTPStreamRequest
{
var _loc4_:AdobeFragmentRunTable = null;
var _loc5_:FragmentAccessInformation = null;
var _loc6_:FragmentDurationPair = null;
var _loc7_:uint = 0;
var _loc8_:String = null;
var _loc2_:AdobeBootstrapBox = this.bootstrapBoxes[param1];
var _loc3_:HTTPStreamRequest = null;
if(!this.playInProgress && this.stopPlaying(_loc2_))
{
return null;
}
this.checkMetadata(param1,_loc2_);
if(param1 >= 0 && param1 < this.streamInfos.length)
{
_loc4_ = this.getFragmentRunTable(_loc2_);
_loc5_ = this.currentFAI;
this.currentFAI = _loc4_.validateFragment(this.currentFAI.fragId + 1,_loc2_.currentMediaTime,_loc2_.contentComplete() ? false : _loc2_.live);
if(this.currentFAI == null || this.fragmentOverflow(_loc2_,this.currentFAI.fragId))
{
if(!_loc2_.live || _loc2_.contentComplete())
{
if(_loc2_.live)
{
return new HTTPStreamRequest(null,param1,-1,-1,true);
}
return null;
}
this.adjustDelay();
this.currentFAI = _loc5_;
this.refreshBootstrapInfo(param1);
return new HTTPStreamRequest(null,param1,0,this.delay);
}
this.playInProgress = true;
_loc6_ = _loc4_.fragmentDurationPairs[0];
_loc7_ = _loc2_.findSegmentId(this.currentFAI.fragId - _loc6_.firstFragment + 1);
_loc8_ = "";
if((this.streamInfos[param1].streamName as String).indexOf("http") != 0)
{
_loc8_ = this.serverBaseURL + "/" + this.streamInfos[param1].streamName + "Seg" + _loc7_ + "-Frag" + this.currentFAI.fragId;
}
else
{
_loc8_ = this.streamInfos[param1].streamName + "Seg" + _loc7_ + "-Frag" + this.currentFAI.fragId;
}
_loc3_ = new HTTPStreamRequest(_loc8_);
this.checkQuality(param1);
this.notifyFragmentDuration(this.currentFAI.fragDuration / _loc2_.timeScale);
}
return _loc3_;
}
internal function calculateSegmentDuration(param1:AdobeBootstrapBox, param2:Number) : Number
{
var _loc6_:FragmentDurationPair = null;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
var _loc3_:Vector.<FragmentDurationPair> = param1.fragmentRunTables[0].fragmentDurationPairs;
var _loc4_:uint = this.currentFAI.fragId;
var _loc5_:* = int(_loc3_.length - 1);
while(_loc5_ >= 0)
{
_loc6_ = _loc3_[_loc5_];
if(_loc6_.firstFragment <= _loc4_)
{
_loc7_ = _loc6_.duration;
_loc8_ = _loc6_.durationAccrued;
_loc8_ = _loc8_ + (_loc4_ - _loc6_.firstFragment) * _loc6_.duration;
if(param2 > 0)
{
_loc7_ -= param2 - _loc8_;
}
return _loc7_;
}
_loc5_--;
}
return 0;
}
private function checkQuality(param1:int) : void
{
var _loc2_:ByteArray = null;
var _loc3_:ByteArray = null;
var _loc4_:FLVTagScriptDataObject = null;
if(this.currentQuality != param1)
{
_loc2_ = this.currentQuality < 0 ? null : this.streamInfos[this.currentQuality].additionalHeader;
this.currentQuality = param1;
_loc3_ = this.streamInfos[this.currentQuality].additionalHeader;
if(_loc3_ != _loc2_ && _loc3_ != null)
{
_loc4_ = new FLVTagScriptDataObject();
_loc4_.data = _loc3_;
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_SCRIPT_DATA,false,false,false,NaN,null,null,null,null,true,0,_loc4_,true,false));
}
}
}
private function checkMetadata(param1:int, param2:AdobeBootstrapBox) : void
{
if(this.currentQuality != param1)
{
this.notifyTotalDuration(param2.totalDuration / param2.timeScale,param1);
}
}
private function refreshBootstrapInfo(param1:uint) : void
{
++this.pendingIndexUpdates;
this.fragmentRunTablesUpdating = true;
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.REQUEST_LOAD_INDEX,false,false,false,NaN,null,null,new URLRequest(HTTPStreamingUtils.normalizeURL((this.streamInfos[param1] as HTTPStreamingF4FStreamInfo).bootstrapInfo.url)),param1,true));
}
private function processBootstrapData(param1:*, param2:Object) : AdobeBootstrapBox
{
var boxes:Vector.<Box> = null;
var data:* = param1;
var indexContext:Object = param2;
var bootstrapBox:AdobeBootstrapBox = null;
var parser:BoxParser = new BoxParser();
data.position = 0;
parser.init(data);
try
{
boxes = parser.getBoxes();
}
catch(e:Error)
{
boxes = null;
}
if(boxes == null || boxes.length < 1)
{
return null;
}
bootstrapBox = boxes[0] as AdobeBootstrapBox;
if(bootstrapBox == null)
{
return null;
}
if(this.serverBaseURL == null || this.serverBaseURL.length <= 0)
{
if(bootstrapBox.serverBaseURLs == null || bootstrapBox.serverBaseURLs.length <= 0)
{
return null;
}
}
return bootstrapBox;
}
private function getQualityRates(param1:Vector.<HTTPStreamingF4FStreamInfo>) : Array
{
var _loc3_:int = 0;
var _loc4_:HTTPStreamingF4FStreamInfo = null;
var _loc2_:Array = [];
if(param1.length >= 1)
{
_loc3_ = 0;
while(_loc3_ < param1.length)
{
_loc4_ = param1[_loc3_] as HTTPStreamingF4FStreamInfo;
_loc2_.push(_loc4_.bitrate);
_loc3_++;
}
}
return _loc2_;
}
private function getStreamNames(param1:Vector.<HTTPStreamingF4FStreamInfo>) : Array
{
var _loc3_:int = 0;
var _loc4_:HTTPStreamingF4FStreamInfo = null;
var _loc2_:Array = [];
if(param1.length >= 1)
{
_loc3_ = 0;
while(_loc3_ < param1.length)
{
_loc4_ = param1[_loc3_] as HTTPStreamingF4FStreamInfo;
_loc2_.push(_loc4_.streamName);
_loc3_++;
}
}
return _loc2_;
}
private function getFragmentRunTable(param1:AdobeBootstrapBox) : AdobeFragmentRunTable
{
return param1.fragmentRunTables[0];
}
private function notifyTotalDuration(param1:Number, param2:int) : void
{
var _loc3_:FLVTagScriptDataObject = new FLVTagScriptDataObject();
var _loc4_:Object = this.f4fIndexInfo.streamInfos[param2].streamMetadata;
if(_loc4_ == null)
{
_loc4_ = new Object();
}
_loc4_.duration = param1;
_loc3_.objects = ["onMetaData",_loc4_];
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_SCRIPT_DATA,false,false,false,NaN,null,null,null,null,false,0,_loc3_,false,true));
}
private function notifyFragmentDuration(param1:Number) : void
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_SEGMENT_DURATION,false,false,false,NaN,null,null,null,null,true,param1));
}
private function notifyIndexReady(param1:int) : void
{
var _loc2_:AdobeBootstrapBox = this.bootstrapBoxes[param1];
var _loc3_:AdobeFragmentRunTable = this.getFragmentRunTable(_loc2_);
this.dispatchDVRStreamInfo(_loc2_);
if(!this.dvrGetStreamInfoCall)
{
if(_loc2_.live && this.f4fIndexInfo.dvrInfo == null && isNaN(this.pureLiveOffset))
{
this.pureLiveOffset = _loc2_.currentMediaTime - this.offsetFromCurrent * _loc2_.timeScale > 0 ? _loc2_.currentMediaTime / _loc2_.timeScale - this.offsetFromCurrent : NaN;
}
dispatchEvent(new HTTPStreamingIndexHandlerEvent(HTTPStreamingIndexHandlerEvent.NOTIFY_INDEX_READY,false,false,_loc2_.live,this.pureLiveOffset));
}
this.dvrGetStreamInfoCall = false;
}
private function stopPlaying(param1:AdobeBootstrapBox) : Boolean
{
var _loc2_:AdobeFragmentRunTable = this.getFragmentRunTable(param1);
if(this.f4fIndexInfo.dvrInfo == null && param1.live && _loc2_.tableComplete() || this.f4fIndexInfo.dvrInfo != null && this.f4fIndexInfo.dvrInfo.offline)
{
return true;
}
return false;
}
private function onNewBootstrapBox(param1:HTTPStreamingFileHandlerEvent) : void
{
var _loc2_:AdobeBootstrapBox = this.bootstrapBoxes[this.currentQuality];
if(_loc2_.bootstrapVersion < param1.bootstrapBox.bootstrapVersion || _loc2_.currentMediaTime < param1.bootstrapBox.currentMediaTime)
{
this.bootstrapBoxes[this.currentQuality] = param1.bootstrapBox;
this.dispatchDVRStreamInfo(param1.bootstrapBox);
}
}
private function dispatchDVRStreamInfo(param1:AdobeBootstrapBox) : void
{
var _loc2_:AdobeFragmentRunTable = this.getFragmentRunTable(param1);
if(this.f4fIndexInfo.dvrInfo != null)
{
this.f4fIndexInfo.dvrInfo.isRecording = !_loc2_.tableComplete();
if(isNaN(this.f4fIndexInfo.dvrInfo.startTime))
{
this.f4fIndexInfo.dvrInfo.startTime = _loc2_.tableComplete() ? 0 : DVRUtils.calculateOffset(this.f4fIndexInfo.dvrInfo.beginOffset < 0 || isNaN(this.f4fIndexInfo.dvrInfo.beginOffset) ? 0 : this.f4fIndexInfo.dvrInfo.beginOffset,this.f4fIndexInfo.dvrInfo.endOffset < 0 || isNaN(this.f4fIndexInfo.dvrInfo.endOffset) ? 0 : this.f4fIndexInfo.dvrInfo.endOffset,param1.totalDuration / param1.timeScale);
this.f4fIndexInfo.dvrInfo.startTime += _loc2_.fragmentDurationPairs[0].durationAccrued / param1.timeScale;
if(this.f4fIndexInfo.dvrInfo.startTime > param1.currentMediaTime)
{
this.f4fIndexInfo.dvrInfo.startTime = param1.currentMediaTime;
}
}
this.f4fIndexInfo.dvrInfo.curLength = param1.currentMediaTime / param1.timeScale - this.f4fIndexInfo.dvrInfo.startTime;
dispatchEvent(new DVRStreamInfoEvent(DVRStreamInfoEvent.DVRSTREAMINFO,false,false,this.f4fIndexInfo.dvrInfo));
}
}
private function fragmentOverflow(param1:AdobeBootstrapBox, param2:uint) : Boolean
{
var _loc3_:AdobeFragmentRunTable = param1.fragmentRunTables[0];
var _loc4_:FragmentDurationPair = _loc3_.fragmentDurationPairs[0];
var _loc5_:AdobeSegmentRunTable = param1.segmentRunTables[0];
return _loc5_ == null || _loc5_.totalFragments + _loc4_.firstFragment - 1 < param2;
}
private function adjustDelay() : void
{
if(this.delay < 1)
{
this.delay *= 2;
if(this.delay > 1)
{
this.delay = 1;
}
}
}
}
}
@@ -0,0 +1,39 @@
package org.osmf.net.httpstreaming.f4f
{
import org.osmf.net.httpstreaming.HTTPStreamingIndexInfoBase;
import org.osmf.net.httpstreaming.dvr.DVRInfo;
public class HTTPStreamingF4FIndexInfo extends HTTPStreamingIndexInfoBase
{
private var _serverBaseURL:String;
private var _dvrInfo:DVRInfo;
private var _streamInfos:Vector.<HTTPStreamingF4FStreamInfo>;
public function HTTPStreamingF4FIndexInfo(param1:String = null, param2:Vector.<HTTPStreamingF4FStreamInfo> = null, param3:DVRInfo = null)
{
super();
this._serverBaseURL = param1;
this._streamInfos = param2;
this._dvrInfo = param3;
}
public function get serverBaseURL() : String
{
return this._serverBaseURL;
}
public function get streamInfos() : Vector.<HTTPStreamingF4FStreamInfo>
{
return this._streamInfos;
}
public function get dvrInfo() : DVRInfo
{
return this._dvrInfo;
}
}
}
@@ -0,0 +1,63 @@
package org.osmf.net.httpstreaming.f4f
{
import flash.utils.ByteArray;
import org.osmf.elements.f4mClasses.BootstrapInfo;
public class HTTPStreamingF4FStreamInfo
{
private var _streamName:String;
private var _bitrate:Number;
private var _bootstrap:BootstrapInfo;
private var _additionalHeader:ByteArray;
private var _streamMetadata:Object;
private var _xmpMetadata:ByteArray;
public function HTTPStreamingF4FStreamInfo(param1:BootstrapInfo, param2:String, param3:Number, param4:ByteArray, param5:Object, param6:ByteArray)
{
super();
this._streamName = param2;
this._bitrate = param3;
this._additionalHeader = param4;
this._bootstrap = param1;
this._streamMetadata = param5;
this._xmpMetadata = param6;
}
public function get streamName() : String
{
return this._streamName;
}
public function get bitrate() : Number
{
return this._bitrate;
}
public function get additionalHeader() : ByteArray
{
return this._additionalHeader;
}
public function get bootstrapInfo() : BootstrapInfo
{
return this._bootstrap;
}
public function get streamMetadata() : Object
{
return this._streamMetadata;
}
public function get xmpMetadata() : ByteArray
{
return this._xmpMetadata;
}
}
}
@@ -0,0 +1,36 @@
package org.osmf.net.httpstreaming.f4f
{
internal class LocalRandomAccessEntry
{
private var _time:Number;
private var _offset:Number;
public function LocalRandomAccessEntry()
{
super();
}
public function get time() : Number
{
return this._time;
}
public function set time(param1:Number) : void
{
this._time = param1;
}
public function get offset() : Number
{
return this._offset;
}
public function set offset(param1:Number) : void
{
this._offset = param1;
}
}
}
@@ -0,0 +1,26 @@
package org.osmf.net.httpstreaming.f4f
{
import flash.utils.ByteArray;
internal class MediaDataBox extends Box
{
private var _data:ByteArray;
public function MediaDataBox()
{
super();
}
public function get data() : ByteArray
{
return this._data;
}
public function set data(param1:ByteArray) : void
{
this._data = param1;
}
}
}
@@ -0,0 +1,40 @@
package org.osmf.net.httpstreaming.f4f
{
internal class SegmentFragmentPair
{
private var _firstSegment:uint;
private var _fragmentsPerSegment:uint;
private var _fragmentsAccrued:uint;
public function SegmentFragmentPair(param1:uint, param2:uint)
{
super();
this._firstSegment = param1;
this._fragmentsPerSegment = param2;
}
public function get firstSegment() : uint
{
return this._firstSegment;
}
public function get fragmentsPerSegment() : uint
{
return this._fragmentsPerSegment;
}
public function set fragmentsAccrued(param1:uint) : void
{
this._fragmentsAccrued = param1;
}
public function get fragmentsAccrued() : uint
{
return this._fragmentsAccrued;
}
}
}
@@ -0,0 +1,127 @@
package org.osmf.net.httpstreaming.flv
{
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class FLVHeader
{
public static const MIN_FILE_HEADER_BYTE_COUNT:int = 9;
private var _hasVideoTags:Boolean = true;
private var _hasAudioTags:Boolean = true;
private var offset:uint;
public function FLVHeader(param1:IDataInput = null)
{
super();
if(param1 != null)
{
this.readHeader(param1);
this.readRest(param1);
}
}
public function get hasAudioTags() : Boolean
{
return this._hasAudioTags;
}
public function set hasAudioTags(param1:Boolean) : void
{
this._hasAudioTags = param1;
}
public function get hasVideoTags() : Boolean
{
return this._hasVideoTags;
}
public function set hasVideoTags(param1:Boolean) : void
{
this._hasVideoTags = param1;
}
public function write(param1:IDataOutput) : void
{
param1.writeByte(70);
param1.writeByte(76);
param1.writeByte(86);
param1.writeByte(1);
var _loc2_:uint = 0;
if(this._hasAudioTags)
{
_loc2_ |= 4;
}
if(this._hasVideoTags)
{
_loc2_ |= 1;
}
param1.writeByte(_loc2_);
var _loc3_:uint = uint(MIN_FILE_HEADER_BYTE_COUNT);
param1.writeUnsignedInt(_loc3_);
var _loc4_:uint = 0;
param1.writeUnsignedInt(_loc4_);
}
internal function readHeader(param1:IDataInput) : void
{
if(param1.bytesAvailable < MIN_FILE_HEADER_BYTE_COUNT)
{
throw new Error("FLVHeader() input too short");
}
if(param1.readByte() != 70)
{
throw new Error("FLVHeader readHeader() Signature[0] not \'F\'");
}
if(param1.readByte() != 76)
{
throw new Error("FLVHeader readHeader() Signature[1] not \'L\'");
}
if(param1.readByte() != 86)
{
throw new Error("FLVHeader readHeader() Signature[2] not \'V\'");
}
if(param1.readByte() != 1)
{
throw new Error("FLVHeader readHeader() Version not 0x01");
}
var _loc2_:int = param1.readByte();
this._hasAudioTags = _loc2_ & 4 ? true : false;
this._hasVideoTags = _loc2_ & 1 ? true : false;
this.offset = param1.readUnsignedInt();
if(this.offset < MIN_FILE_HEADER_BYTE_COUNT)
{
throw new Error("FLVHeader() offset smaller than minimum");
}
}
internal function readRest(param1:IDataInput) : void
{
var _loc2_:ByteArray = null;
if(this.offset > MIN_FILE_HEADER_BYTE_COUNT)
{
if(this.offset - MIN_FILE_HEADER_BYTE_COUNT < param1.bytesAvailable - FLVTag.PREV_TAG_BYTE_COUNT)
{
throw new Error("FLVHeader() input too short for nonstandard offset");
}
_loc2_ = new ByteArray();
param1.readBytes(_loc2_,0,this.offset - MIN_FILE_HEADER_BYTE_COUNT);
}
if(param1.bytesAvailable < FLVTag.PREV_TAG_BYTE_COUNT)
{
throw new Error("FLVHeader() input too short for previousTagSize0");
}
param1.readUnsignedInt();
}
internal function get restBytesNeeded() : int
{
return FLVTag.PREV_TAG_BYTE_COUNT + (this.offset - MIN_FILE_HEADER_BYTE_COUNT);
}
}
}
@@ -0,0 +1,175 @@
package org.osmf.net.httpstreaming.flv
{
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class FLVParser
{
private var state:String;
private var savedBytes:ByteArray;
private var currentTag:FLVTag = null;
private var flvHeader:FLVHeader;
public function FLVParser(param1:Boolean)
{
super();
this.savedBytes = new ByteArray();
if(param1)
{
this.state = FLVParserState.FILE_HEADER;
}
else
{
this.state = FLVParserState.TYPE;
}
}
public function flush(param1:IDataOutput) : void
{
param1.writeBytes(this.savedBytes);
}
public function parse(param1:IDataInput, param2:Boolean, param3:Function) : void
{
var _loc5_:IDataInput = null;
var _loc6_:int = 0;
var _loc4_:Boolean = true;
while(_loc4_)
{
switch(this.state)
{
case FLVParserState.FILE_HEADER:
_loc5_ = this.byteSource(param1,FLVHeader.MIN_FILE_HEADER_BYTE_COUNT);
if(_loc5_ != null)
{
this.flvHeader = new FLVHeader();
this.flvHeader.readHeader(_loc5_);
this.state = FLVParserState.FILE_HEADER_REST;
}
else
{
_loc4_ = false;
}
break;
case FLVParserState.FILE_HEADER_REST:
_loc5_ = this.byteSource(param1,this.flvHeader.restBytesNeeded);
if(_loc5_ != null)
{
this.flvHeader.readRest(_loc5_);
this.state = FLVParserState.TYPE;
}
else
{
_loc4_ = false;
}
break;
case FLVParserState.TYPE:
_loc5_ = this.byteSource(param1,1);
if(_loc5_ != null)
{
_loc6_ = _loc5_.readByte();
switch(_loc6_)
{
case FLVTag.TAG_TYPE_AUDIO:
case FLVTag.TAG_TYPE_ENCRYPTED_AUDIO:
this.currentTag = new FLVTagAudio(_loc6_);
break;
case FLVTag.TAG_TYPE_VIDEO:
case FLVTag.TAG_TYPE_ENCRYPTED_VIDEO:
this.currentTag = new FLVTagVideo(_loc6_);
break;
case FLVTag.TAG_TYPE_SCRIPTDATAOBJECT:
case FLVTag.TAG_TYPE_ENCRYPTED_SCRIPTDATAOBJECT:
this.currentTag = new FLVTagScriptDataObject(_loc6_);
break;
default:
this.currentTag = new FLVTag(_loc6_);
}
this.state = FLVParserState.HEADER;
}
else
{
_loc4_ = false;
}
break;
case FLVParserState.HEADER:
_loc5_ = this.byteSource(param1,FLVTag.TAG_HEADER_BYTE_COUNT - 1);
if(_loc5_ != null)
{
this.currentTag.readRemainingHeader(_loc5_);
if(this.currentTag.dataSize)
{
this.state = FLVParserState.DATA;
}
else
{
this.state = FLVParserState.PREV_TAG;
}
}
else
{
_loc4_ = false;
}
break;
case FLVParserState.DATA:
_loc5_ = this.byteSource(param1,this.currentTag.dataSize);
if(_loc5_ != null)
{
this.currentTag.readData(_loc5_);
this.state = FLVParserState.PREV_TAG;
}
else
{
_loc4_ = false;
}
break;
case FLVParserState.PREV_TAG:
_loc5_ = this.byteSource(param1,FLVTag.PREV_TAG_BYTE_COUNT);
if(_loc5_ != null)
{
this.currentTag.readPrevTag(_loc5_);
this.state = FLVParserState.TYPE;
_loc4_ = param3(this.currentTag);
}
else
{
_loc4_ = false;
}
break;
default:
throw new Error("FLVParser state machine in unknown state");
}
}
if(param2)
{
param1.readBytes(this.savedBytes,this.savedBytes.length);
}
}
private function byteSource(param1:IDataInput, param2:int) : IDataInput
{
var _loc3_:int = 0;
if(this.savedBytes.bytesAvailable + param1.bytesAvailable < param2)
{
return null;
}
if(this.savedBytes.bytesAvailable)
{
_loc3_ = param2 - this.savedBytes.bytesAvailable;
if(_loc3_ > 0)
{
param1.readBytes(this.savedBytes,this.savedBytes.length,_loc3_);
}
return this.savedBytes;
}
this.savedBytes.length = 0;
return param1;
}
}
}
@@ -0,0 +1,24 @@
package org.osmf.net.httpstreaming.flv
{
internal class FLVParserState
{
internal static const FILE_HEADER:String = "fileHeader";
internal static const FILE_HEADER_REST:String = "fileHeaderRest";
internal static const TYPE:String = "type";
internal static const HEADER:String = "header";
internal static const DATA:String = "data";
internal static const PREV_TAG:String = "prevTag";
public function FLVParserState()
{
super();
}
}
}
@@ -0,0 +1,155 @@
package org.osmf.net.httpstreaming.flv
{
import flash.utils.ByteArray;
import flash.utils.IDataInput;
import flash.utils.IDataOutput;
public class FLVTag
{
public static const TAG_TYPE_AUDIO:int = 8;
public static const TAG_TYPE_VIDEO:int = 9;
public static const TAG_TYPE_SCRIPTDATAOBJECT:int = 18;
public static const TAG_FLAG_ENCRYPTED:int = 32;
public static const TAG_TYPE_ENCRYPTED_AUDIO:int = TAG_TYPE_AUDIO + TAG_FLAG_ENCRYPTED;
public static const TAG_TYPE_ENCRYPTED_VIDEO:int = TAG_TYPE_VIDEO + TAG_FLAG_ENCRYPTED;
public static const TAG_TYPE_ENCRYPTED_SCRIPTDATAOBJECT:int = TAG_TYPE_SCRIPTDATAOBJECT + TAG_FLAG_ENCRYPTED;
internal static const TAG_HEADER_BYTE_COUNT:int = 11;
internal static const PREV_TAG_BYTE_COUNT:int = 4;
protected var bytes:ByteArray = null;
public function FLVTag(param1:int)
{
super();
this.bytes = new ByteArray();
this.bytes.length = TAG_HEADER_BYTE_COUNT;
this.bytes[0] = param1;
}
public function read(param1:IDataInput) : void
{
this.readType(param1);
this.readRemainingHeader(param1);
this.readData(param1);
this.readPrevTag(param1);
}
public function readType(param1:IDataInput) : void
{
if(param1.bytesAvailable < 1)
{
throw new Error("FLVTag.readType() input too short");
}
param1.readBytes(this.bytes,0,1);
}
public function readRemaining(param1:IDataInput) : void
{
this.readRemainingHeader(param1);
this.readData(param1);
this.readPrevTag(param1);
}
public function readRemainingHeader(param1:IDataInput) : void
{
if(param1.bytesAvailable < 10)
{
throw new Error("FLVTag.readHeader() input too short");
}
param1.readBytes(this.bytes,1,TAG_HEADER_BYTE_COUNT - 1);
}
public function readData(param1:IDataInput) : void
{
if(this.dataSize > 0)
{
if(param1.bytesAvailable < this.dataSize)
{
throw new Error("FLVTag().readData input shorter than dataSize");
}
param1.readBytes(this.bytes,TAG_HEADER_BYTE_COUNT,this.dataSize);
}
}
public function readPrevTag(param1:IDataInput) : void
{
if(param1.bytesAvailable < 4)
{
throw new Error("FLVTag.readPrevTag() input too short");
}
param1.readUnsignedInt();
}
public function write(param1:IDataOutput) : void
{
param1.writeBytes(this.bytes,0,TAG_HEADER_BYTE_COUNT + this.dataSize);
param1.writeUnsignedInt(TAG_HEADER_BYTE_COUNT + this.dataSize);
}
public function get tagType() : uint
{
return this.bytes[0];
}
public function set tagType(param1:uint) : void
{
this.bytes[0] = param1;
}
public function get isEncrpted() : Boolean
{
return this.bytes[0] & TAG_FLAG_ENCRYPTED ? true : false;
}
public function get dataSize() : uint
{
return this.bytes[1] << 16 | this.bytes[2] << 8 | this.bytes[3];
}
public function set dataSize(param1:uint) : void
{
this.bytes[1] = param1 >> 16 & 0xFF;
this.bytes[2] = param1 >> 8 & 0xFF;
this.bytes[3] = param1 & 0xFF;
this.bytes.length = TAG_HEADER_BYTE_COUNT + param1;
}
public function get timestamp() : uint
{
return this.bytes[7] << 24 | this.bytes[4] << 16 | this.bytes[5] << 8 | this.bytes[6];
}
public function set timestamp(param1:uint) : void
{
this.bytes[7] = param1 >> 24 & 0xFF;
this.bytes[4] = param1 >> 16 & 0xFF;
this.bytes[5] = param1 >> 8 & 0xFF;
this.bytes[6] = param1 & 0xFF;
}
public function get data() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
_loc1_.writeBytes(this.bytes,TAG_HEADER_BYTE_COUNT,this.dataSize);
return _loc1_;
}
public function set data(param1:ByteArray) : void
{
this.bytes.length = TAG_HEADER_BYTE_COUNT + param1.length;
this.bytes.position = TAG_HEADER_BYTE_COUNT;
this.bytes.writeBytes(param1,0,param1.length);
this.dataSize = param1.length;
}
}
}
@@ -0,0 +1,246 @@
package org.osmf.net.httpstreaming.flv
{
import flash.utils.ByteArray;
public class FLVTagAudio extends FLVTag
{
public static const SOUND_FORMAT_LINEAR:int = 0;
public static const SOUND_FORMAT_ADPCM:int = 1;
public static const SOUND_FORMAT_MP3:int = 2;
public static const SOUND_FORMAT_LINEAR_LE:int = 3;
public static const SOUND_FORMAT_NELLYMOSER_16K:int = 4;
public static const SOUND_FORMAT_NELLYMOSER_8K:int = 5;
public static const SOUND_FORMAT_NELLYMOSER:int = 6;
public static const SOUND_FORMAT_G711A:int = 7;
public static const SOUND_FORMAT_G711U:int = 8;
public static const SOUND_FORMAT_AAC:int = 10;
public static const SOUND_FORMAT_SPEEX:int = 11;
public static const SOUND_FORMAT_MP3_8K:int = 14;
public static const SOUND_FORMAT_DEVICE_SPECIFIC:int = 15;
public static const SOUND_RATE_5K:Number = 5512.5;
public static const SOUND_RATE_11K:Number = 11025;
public static const SOUND_RATE_22K:Number = 22050;
public static const SOUND_RATE_44K:Number = 44100;
public static const SOUND_SIZE_8BITS:int = 8;
public static const SOUND_SIZE_16BITS:int = 16;
public static const SOUND_CHANNELS_MONO:int = 1;
public static const SOUND_CHANNELS_STEREO:int = 2;
public function FLVTagAudio(param1:int = 8)
{
super(param1);
}
public function get soundFormatByte() : int
{
return bytes[TAG_HEADER_BYTE_COUNT + 0];
}
public function set soundFormatByte(param1:int) : void
{
bytes[TAG_HEADER_BYTE_COUNT + 0] = param1;
}
public function get soundFormat() : int
{
return bytes[TAG_HEADER_BYTE_COUNT + 0] >> 4 & 0x0F;
}
public function set soundFormat(param1:int) : void
{
bytes[TAG_HEADER_BYTE_COUNT + 0] &= 15;
bytes[TAG_HEADER_BYTE_COUNT + 0] |= param1 << 4 & 0xF0;
if(param1 == SOUND_FORMAT_AAC)
{
this.soundRate = SOUND_RATE_44K;
this.soundChannels = SOUND_CHANNELS_STEREO;
this.isAACSequenceHeader = false;
}
}
public function get soundRate() : Number
{
switch(bytes[TAG_HEADER_BYTE_COUNT + 0] >> 2 & 3)
{
case 0:
return SOUND_RATE_5K;
case 1:
return SOUND_RATE_11K;
case 2:
return SOUND_RATE_22K;
case 3:
return SOUND_RATE_44K;
default:
throw new Error("get soundRate() a two-bit number wasn\'t 0, 1, 2, or 3. impossible.");
}
}
public function set soundRate(param1:Number) : void
{
var _loc2_:int = 0;
switch(param1)
{
case SOUND_RATE_5K:
_loc2_ = 0;
break;
case SOUND_RATE_11K:
_loc2_ = 1;
break;
case SOUND_RATE_22K:
_loc2_ = 2;
break;
case SOUND_RATE_44K:
_loc2_ = 3;
break;
default:
throw new Error("set soundRate valid values 5512.5, 11025, 22050, 44100");
}
bytes[TAG_HEADER_BYTE_COUNT + 0] &= 243;
bytes[TAG_HEADER_BYTE_COUNT + 0] |= _loc2_ << 2;
}
public function get soundSize() : int
{
if(bytes[TAG_HEADER_BYTE_COUNT + 0] >> 1 & 1)
{
return SOUND_SIZE_16BITS;
}
return SOUND_SIZE_8BITS;
}
public function set soundSize(param1:int) : void
{
switch(param1)
{
case SOUND_SIZE_8BITS:
bytes[TAG_HEADER_BYTE_COUNT + 0] &= 253;
break;
case SOUND_SIZE_16BITS:
bytes[TAG_HEADER_BYTE_COUNT + 0] |= 2;
break;
default:
throw new Error("set soundSize valid values 8, 16");
}
}
public function get soundChannels() : int
{
if(bytes[TAG_HEADER_BYTE_COUNT + 0] & 1)
{
return SOUND_CHANNELS_STEREO;
}
return SOUND_CHANNELS_MONO;
}
public function set soundChannels(param1:int) : void
{
switch(param1)
{
case SOUND_CHANNELS_MONO:
bytes[TAG_HEADER_BYTE_COUNT + 0] &= 254;
break;
case SOUND_CHANNELS_STEREO:
bytes[TAG_HEADER_BYTE_COUNT + 0] |= 1;
break;
default:
throw new Error("set soundChannels valid values 1, 2");
}
}
public function get isAACSequenceHeader() : Boolean
{
if(this.soundFormat != SOUND_FORMAT_AAC)
{
throw new Error("get isAACSequenceHeader not valid if soundFormat != SOUND_FORMAT_AAC");
}
if(bytes[TAG_HEADER_BYTE_COUNT + 1] == 0)
{
return true;
}
return false;
}
public function set isAACSequenceHeader(param1:Boolean) : void
{
if(this.soundFormat != SOUND_FORMAT_AAC)
{
throw new Error("set isAACSequenceHeader not valid if soundFormat != SOUND_FORMAT_AAC");
}
if(param1)
{
bytes[TAG_HEADER_BYTE_COUNT + 1] = 0;
}
else
{
bytes[TAG_HEADER_BYTE_COUNT + 1] = 1;
}
}
public function get isCodecConfiguration() : Boolean
{
switch(this.soundFormat)
{
case FLVTagAudio.SOUND_FORMAT_AAC:
if(this.isAACSequenceHeader)
{
return true;
}
}
return false;
}
override public function get data() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
if(this.soundFormat == SOUND_FORMAT_AAC)
{
_loc1_.writeBytes(bytes,TAG_HEADER_BYTE_COUNT + 2,dataSize - 2);
}
else
{
_loc1_.writeBytes(bytes,TAG_HEADER_BYTE_COUNT + 1,dataSize - 1);
}
return _loc1_;
}
override public function set data(param1:ByteArray) : void
{
if(this.soundFormat == SOUND_FORMAT_AAC)
{
bytes.length = TAG_HEADER_BYTE_COUNT + param1.length + 2;
bytes.position = TAG_HEADER_BYTE_COUNT + 2;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 2;
}
else
{
bytes.length = TAG_HEADER_BYTE_COUNT + param1.length + 1;
bytes.position = TAG_HEADER_BYTE_COUNT + 1;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 1;
}
}
}
}
@@ -0,0 +1,38 @@
package org.osmf.net.httpstreaming.flv
{
import flash.net.ObjectEncoding;
public class FLVTagScriptDataObject extends FLVTag
{
public function FLVTagScriptDataObject(param1:int = 18)
{
super(param1);
}
public function get objects() : Array
{
var _loc1_:Array = new Array();
bytes.position = TAG_HEADER_BYTE_COUNT;
while(bytes.bytesAvailable)
{
_loc1_.push(bytes.readObject());
}
return _loc1_;
}
public function set objects(param1:Array) : void
{
var _loc2_:Object = null;
bytes.objectEncoding = ObjectEncoding.AMF0;
bytes.length = TAG_HEADER_BYTE_COUNT;
bytes.position = TAG_HEADER_BYTE_COUNT;
for each(_loc2_ in param1)
{
bytes.writeObject(_loc2_);
}
dataSize = bytes.length - TAG_HEADER_BYTE_COUNT;
}
}
}
@@ -0,0 +1,175 @@
package org.osmf.net.httpstreaming.flv
{
import flash.utils.ByteArray;
public class FLVTagVideo extends FLVTag
{
public static const FRAME_TYPE_KEYFRAME:int = 1;
public static const FRAME_TYPE_INTER:int = 2;
public static const FRAME_TYPE_DISPOSABLE_INTER:int = 3;
public static const FRAME_TYPE_GENERATED_KEYFRAME:int = 4;
public static const FRAME_TYPE_INFO:int = 5;
public static const CODEC_ID_JPEG:int = 1;
public static const CODEC_ID_SORENSON:int = 2;
public static const CODEC_ID_SCREEN:int = 3;
public static const CODEC_ID_VP6:int = 4;
public static const CODEC_ID_VP6_ALPHA:int = 5;
public static const CODEC_ID_SCREEN_V2:int = 6;
public static const CODEC_ID_AVC:int = 7;
public static const AVC_PACKET_TYPE_SEQUENCE_HEADER:int = 0;
public static const AVC_PACKET_TYPE_NALU:int = 1;
public static const AVC_PACKET_TYPE_END_OF_SEQUENCE:int = 2;
public static const INFO_PACKET_SEEK_START:int = 0;
public static const INFO_PACKET_SEEK_END:int = 1;
public function FLVTagVideo(param1:int = 9)
{
super(param1);
}
public function get frameType() : int
{
return bytes[TAG_HEADER_BYTE_COUNT + 0] >> 4 & 0x0F;
}
public function set frameType(param1:int) : void
{
bytes[TAG_HEADER_BYTE_COUNT + 0] &= 15;
bytes[TAG_HEADER_BYTE_COUNT + 0] |= (param1 & 0x0F) << 4;
}
public function get codecID() : int
{
return bytes[TAG_HEADER_BYTE_COUNT + 0] & 0x0F;
}
public function set codecID(param1:int) : void
{
bytes[TAG_HEADER_BYTE_COUNT + 0] &= 240;
bytes[TAG_HEADER_BYTE_COUNT + 0] |= param1 & 0x0F;
}
public function get infoPacketValue() : int
{
if(this.frameType != FRAME_TYPE_INFO)
{
throw new Error("get infoPacketValue() not permitted unless frameType is FRAME_TYPE_INFO");
}
return bytes[TAG_HEADER_BYTE_COUNT + 1];
}
public function set infoPacketValue(param1:int) : void
{
if(this.frameType != FRAME_TYPE_INFO)
{
throw new Error("get infoPacketValue() not permitted unless frameType is FRAME_TYPE_INFO");
}
bytes[TAG_HEADER_BYTE_COUNT + 1] = param1;
bytes.length = TAG_HEADER_BYTE_COUNT + 2;
dataSize = 2;
}
public function get avcPacketType() : int
{
if(this.codecID != CODEC_ID_AVC)
{
throw new Error("get avcPacketType() not permitted unless codecID is CODEC_ID_AVC");
}
return bytes[TAG_HEADER_BYTE_COUNT + 1];
}
public function set avcPacketType(param1:int) : void
{
if(this.codecID != CODEC_ID_AVC)
{
throw new Error("set avcPacketType() not permitted unless codecID is CODEC_ID_AVC");
}
bytes[TAG_HEADER_BYTE_COUNT + 1] = param1;
if(this.avcPacketType != AVC_PACKET_TYPE_NALU)
{
bytes[TAG_HEADER_BYTE_COUNT + 2] = 0;
bytes[TAG_HEADER_BYTE_COUNT + 3] = 0;
bytes[TAG_HEADER_BYTE_COUNT + 4] = 0;
bytes.length = TAG_HEADER_BYTE_COUNT + 5;
dataSize = 5;
}
}
public function get avcCompositionTimeOffset() : int
{
if(this.codecID != CODEC_ID_AVC || this.avcPacketType != AVC_PACKET_TYPE_NALU)
{
throw new Error("get avcCompositionTimeOffset() not permitted unless codecID is CODEC_ID_AVC and avcPacketType is AVC NALU");
}
var _loc1_:int = bytes[TAG_HEADER_BYTE_COUNT + 2] << 16;
_loc1_ |= bytes[TAG_HEADER_BYTE_COUNT + 3] << 8;
_loc1_ |= bytes[TAG_HEADER_BYTE_COUNT + 4];
if(_loc1_ & 0x800000)
{
_loc1_ |= 4278190080;
}
return _loc1_;
}
public function set avcCompositionTimeOffset(param1:int) : void
{
if(this.codecID != CODEC_ID_AVC || this.avcPacketType != AVC_PACKET_TYPE_NALU)
{
throw new Error("set avcCompositionTimeOffset() not permitted unless codecID is CODEC_ID_AVC and avcPacketType is AVC NALU");
}
bytes[TAG_HEADER_BYTE_COUNT + 2] = param1 >> 16 & 0xFF;
bytes[TAG_HEADER_BYTE_COUNT + 3] = param1 >> 8 & 0xFF;
bytes[TAG_HEADER_BYTE_COUNT + 4] = param1 & 0xFF;
}
override public function get data() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
if(this.codecID == CODEC_ID_AVC)
{
_loc1_.writeBytes(bytes,TAG_HEADER_BYTE_COUNT + 5,dataSize - 5);
}
else
{
_loc1_.writeBytes(bytes,TAG_HEADER_BYTE_COUNT + 1,dataSize - 1);
}
return _loc1_;
}
override public function set data(param1:ByteArray) : void
{
if(this.codecID == CODEC_ID_AVC)
{
bytes.length = TAG_HEADER_BYTE_COUNT + param1.length + 5;
bytes.position = TAG_HEADER_BYTE_COUNT + 5;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 5;
}
else
{
bytes.length = TAG_HEADER_BYTE_COUNT + param1.length + 1;
bytes.position = TAG_HEADER_BYTE_COUNT + 1;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 1;
}
}
}
}