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,64 @@
package org.osmf.net
{
public class DynamicStreamingItem
{
private var _bitrate:Number;
private var _stream:String;
private var _width:int;
private var _height:int;
public function DynamicStreamingItem(param1:String, param2:Number, param3:int = -1, param4:int = -1)
{
super();
_stream = param1;
_bitrate = param2;
_width = param3;
_height = param4;
}
public function get streamName() : String
{
return _stream;
}
public function set streamName(param1:String) : void
{
_stream = param1;
}
public function get bitrate() : Number
{
return _bitrate;
}
public function set bitrate(param1:Number) : void
{
_bitrate = param1;
}
public function get width() : int
{
return _width;
}
public function set width(param1:int) : void
{
_width = param1;
}
public function get height() : int
{
return _height;
}
public function set height(param1:int) : void
{
_height = param1;
}
}
}
@@ -0,0 +1,85 @@
package org.osmf.net
{
import org.osmf.utils.OSMFStrings;
public class DynamicStreamingResource extends StreamingURLResource
{
private var _streamItems:Vector.<DynamicStreamingItem>;
private var _initialIndex:int;
public function DynamicStreamingResource(param1:String, param2:String = null)
{
super(param1,param2);
_initialIndex = 0;
}
public function get host() : String
{
return url;
}
public function get streamItems() : Vector.<DynamicStreamingItem>
{
if(_streamItems == null)
{
_streamItems = new Vector.<DynamicStreamingItem>();
}
return _streamItems;
}
public function set streamItems(param1:Vector.<DynamicStreamingItem>) : void
{
_streamItems = param1;
if(param1 != null)
{
param1.sort(compareStreamItems);
}
}
public function get initialIndex() : int
{
return _initialIndex;
}
public function set initialIndex(param1:int) : void
{
if(_streamItems == null || param1 >= _streamItems.length)
{
throw new RangeError(OSMFStrings.getString("invalidParam"));
}
_initialIndex = param1;
}
internal function indexFromName(param1:String) : int
{
var _loc2_:int = 0;
_loc2_ = 0;
while(_loc2_ < _streamItems.length)
{
if(_streamItems[_loc2_].streamName.indexOf(param1) == 0 || _streamItems[_loc2_].streamName.indexOf("mp4:" + param1) == 0)
{
return _loc2_;
}
_loc2_++;
}
return -1;
}
private function compareStreamItems(param1:DynamicStreamingItem, param2:DynamicStreamingItem) : Number
{
var _loc3_:Number = -1;
if(param1.bitrate == param2.bitrate)
{
_loc3_ = 0;
}
else if(param1.bitrate > param2.bitrate)
{
_loc3_ = 1;
}
return _loc3_;
}
}
}
+38
View File
@@ -0,0 +1,38 @@
package org.osmf.net
{
internal class FMSHost
{
private var _host:String;
private var _port:String;
public function FMSHost(param1:String, param2:String = "1935")
{
super();
_host = param1;
_port = param2;
}
public function get host() : String
{
return _host;
}
public function set host(param1:String) : void
{
_host = param1;
}
public function get port() : String
{
return _port;
}
public function set port(param1:String) : void
{
_port = param1;
}
}
}
+272
View File
@@ -0,0 +1,272 @@
package org.osmf.net
{
import org.osmf.utils.URL;
public class FMSURL extends URL
{
private static const APPNAME_START_INDEX:uint = 0;
private static const INSTANCENAME_START_INDEX:uint = 2;
private static const STREAMNAME_START_INDEX:uint = 4;
private static const DEFAULT_INSTANCE_NAME:String = "_definst_";
public static const MP4_STREAM:String = "mp4";
public static const MP3_STREAM:String = "mp3";
public static const ID3_STREAM:String = "id3";
public static const QUERY_STRING_STREAM:String = "streamName";
public static const QUERY_STRING_STREAMTYPE:String = "streamType";
private var _useInstance:Boolean;
private var _appName:String;
private var _instanceName:String;
private var _streamName:String;
private var _fileFormat:String;
private var _origins:Vector.<FMSHost>;
private var _edges:Vector.<FMSHost>;
public function FMSURL(param1:String, param2:Boolean = false)
{
super(param1);
_useInstance = param2;
_appName = "";
_instanceName = "";
_streamName = "";
_fileFormat = "";
parsePath();
parseQuery();
}
public function get useInstance() : Boolean
{
return _useInstance;
}
public function get appName() : String
{
return _appName;
}
public function get instanceName() : String
{
return _instanceName;
}
public function get streamName() : String
{
return _streamName;
}
public function get fileFormat() : String
{
return _fileFormat;
}
public function get edges() : Vector.<FMSHost>
{
return _edges;
}
public function get origins() : Vector.<FMSHost>
{
return _origins;
}
private function parsePath() : void
{
var _loc9_:RegExp = null;
var _loc3_:* = 0;
var _loc7_:int = 0;
if(path == null || path.length == 0)
{
_streamName = getParamValue("streamName");
_fileFormat = getParamValue("streamType");
return;
}
var _loc6_:RegExp = /(\/)/;
var _loc1_:Array = path.split(_loc6_);
if(_loc1_ != null)
{
_appName = _loc1_[0];
_instanceName = "";
_streamName = "";
_loc9_ = new RegExp("^.*/_definst_","i");
if(path.search(_loc9_) > -1)
{
_useInstance = true;
}
_loc3_ = 4;
if(_useInstance)
{
_instanceName = _loc1_[2];
}
else
{
_loc3_ = 2;
}
_loc7_ = _loc3_;
while(_loc7_ < _loc1_.length)
{
_streamName += _loc1_[_loc7_];
_loc7_++;
}
if(_streamName == null || _streamName == "")
{
_streamName = getParamValue("streamName");
}
if(_streamName.search(/^mp4:/i) > -1)
{
_fileFormat = "mp4";
}
else if(_streamName.search(/^mp3:/i) > -1)
{
_fileFormat = "mp3";
}
else if(_streamName.search(/^id3:/i) > -1)
{
_fileFormat = "id3";
}
if(_fileFormat == null || _fileFormat == "")
{
_fileFormat = getParamValue("streamType");
}
}
var _loc8_:int = _streamName.indexOf("/mp4:");
var _loc4_:int = _streamName.indexOf("/mp3:");
var _loc2_:int = _streamName.indexOf("/id3:");
var _loc5_:int = -1;
if(_loc8_ > 0)
{
_loc5_ = _loc8_;
}
else if(_loc4_ > 0)
{
_loc5_ = _loc4_;
}
else if(_loc2_ > 0)
{
_loc5_ = _loc2_;
}
if(useInstance && _loc5_ > 0)
{
_instanceName += "/";
_instanceName += _streamName.substr(0,_loc5_);
_streamName = streamName.substr(_loc5_ + 1);
}
}
private function parseQuery() : void
{
var _loc2_:int = 0;
var _loc5_:int = 0;
var _loc6_:int = 0;
var _loc9_:int = 0;
var _loc8_:FMSURL = null;
if(query == null || query.length == 0 || query.search(/:\//) == -1)
{
return;
}
var _loc7_:Array = query.split("?");
_loc2_ = 0;
while(_loc2_ < _loc7_.length)
{
_loc5_ = int(_loc7_[_loc2_].toString().search(/:\//));
if(_loc5_ == -1)
{
_loc7_.splice(_loc2_,1);
}
_loc2_++;
}
var _loc11_:Boolean = false;
var _loc4_:int = 0;
if(_loc7_.length >= 2)
{
_loc11_ = true;
_loc4_ = _loc7_.length - 1;
}
var _loc13_:String = "";
var _loc3_:String = "";
var _loc1_:int = 0;
var _loc14_:int = 0;
var _loc10_:int = 0;
var _loc12_:int = 0;
_loc6_ = 0;
while(_loc6_ < _loc7_.length)
{
_loc9_ = int(_loc7_[_loc6_].toString().search(/:\//));
_loc10_ = _loc9_ + 2;
if(_loc7_[_loc6_].charAt(_loc10_) == "/")
{
_loc10_++;
}
_loc1_ = int(_loc7_[_loc6_].indexOf(":",_loc10_));
_loc14_ = int(_loc7_[_loc6_].indexOf("/",_loc10_));
if(_loc14_ < 0 && _loc1_ < 0)
{
_loc13_ = _loc7_[_loc6_].slice(_loc10_);
}
else if(_loc1_ >= 0 && _loc1_ < _loc14_)
{
_loc12_ = _loc1_;
_loc13_ = _loc7_[_loc6_].slice(_loc10_,_loc12_);
_loc10_ = _loc12_ + 1;
_loc12_ = _loc14_;
_loc3_ = _loc7_[_loc6_].slice(_loc10_,_loc12_);
}
else if(_loc7_[_loc6_].indexOf("://") != -1)
{
_loc12_ = _loc14_;
_loc13_ = _loc7_[_loc6_].slice(_loc10_,_loc12_);
}
else
{
_loc12_ = int(_loc7_[_loc6_].indexOf("/"));
_loc13_ = "localhost";
}
if(_loc6_ == _loc4_)
{
if(_origins == null)
{
_origins = new Vector.<FMSHost>();
}
_origins.push(new FMSHost(_loc13_,_loc3_));
_loc8_ = new FMSURL(_loc7_[_loc6_],_useInstance);
if(_appName == "")
{
_appName = _loc8_.appName;
}
if(_useInstance && _instanceName == "")
{
_instanceName = _loc8_.instanceName;
}
if(_streamName == "")
{
_streamName = _loc8_.streamName;
}
}
else if(_loc7_[_loc6_] != query && _loc11_)
{
if(_edges == null)
{
_edges = new Vector.<FMSHost>();
}
_edges.push(new FMSHost(_loc13_,_loc3_));
}
_loc6_++;
}
}
}
}
@@ -0,0 +1,19 @@
package org.osmf.net
{
import org.osmf.traits.TimeTrait;
public class ModifiableTimeTrait extends TimeTrait
{
public function ModifiableTimeTrait(param1:Number = NaN)
{
super(param1);
}
public function set duration(param1:Number) : void
{
super.setDuration(param1);
}
}
}
@@ -0,0 +1,70 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import flash.net.NetGroup;
import flash.net.NetStream;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.traits.LoadTrait;
public class MulticastNetLoader extends NetLoader
{
public function MulticastNetLoader(param1:NetConnectionFactoryBase = null)
{
var _loc2_:NetConnectionFactory = null;
if(param1 == null)
{
_loc2_ = new NetConnectionFactory();
_loc2_.timeout = 60000;
}
super(param1 != null ? param1 : _loc2_);
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc2_:MulticastResource = param1 as MulticastResource;
return _loc2_ != null && _loc2_.groupspec != null && _loc2_.groupspec.length > 0 && _loc2_.streamName != null && _loc2_.streamName.length > 0;
}
override protected function createNetStream(param1:NetConnection, param2:URLResource) : NetStream
{
var _loc3_:MulticastResource = param2 as MulticastResource;
return new NetStream(param1,_loc3_.groupspec);
}
override protected function processCreationComplete(param1:NetConnection, param2:LoadTrait, param3:NetConnectionFactoryBase = null) : void
{
var netGroup:NetGroup;
var connection:NetConnection = param1;
var loadTrait:LoadTrait = param2;
var factory:NetConnectionFactoryBase = param3;
var onNetStatus:* = function(param1:NetStatusEvent):void
{
switch(param1.info.code)
{
case "NetGroup.Connect.Success":
connection.removeEventListener("netStatus",onNetStatus);
netLoadTrait.netGroup = netGroup;
doProcessCreationComplete(connection,loadTrait,factory);
break;
case "NetGroup.Connect.Failed":
case "NetGroup.Connect.Rejected":
connection.removeEventListener("netStatus",onNetStatus);
updateLoadTrait(loadTrait,"loadError");
}
};
var netLoadTrait:NetStreamLoadTrait = loadTrait as NetStreamLoadTrait;
var multicastResource:MulticastResource = netLoadTrait.resource as MulticastResource;
connection.addEventListener("netStatus",onNetStatus);
netGroup = new NetGroup(connection,multicastResource.groupspec);
}
private function doProcessCreationComplete(param1:NetConnection, param2:LoadTrait, param3:NetConnectionFactoryBase = null) : void
{
super.processCreationComplete(param1,param2,param3);
}
}
}
@@ -0,0 +1,40 @@
package org.osmf.net
{
import flash.utils.ByteArray;
public class MulticastResource extends StreamingURLResource
{
private var _groupspec:String;
private var _streamName:String;
public function MulticastResource(param1:String, param2:String = null, param3:String = null, param4:Vector.<Object> = null, param5:Boolean = false, param6:ByteArray = null)
{
super(param1,"live",NaN,NaN,param4,param5,param6);
_groupspec = param2;
_streamName = param3;
}
public function get groupspec() : String
{
return _groupspec;
}
public function set groupspec(param1:String) : void
{
_groupspec = param1;
}
public function get streamName() : String
{
return _streamName;
}
public function set streamName(param1:String) : void
{
_streamName = param1;
}
}
}
+121
View File
@@ -0,0 +1,121 @@
package org.osmf.net
{
import flash.utils.Dictionary;
import flash.utils.Proxy;
import flash.utils.flash_proxy;
use namespace flash_proxy;
public dynamic class NetClient extends Proxy
{
private var handlers:Dictionary = new Dictionary();
public function NetClient()
{
super();
}
public function addHandler(param1:String, param2:Function, param3:int = 0) : void
{
var _loc5_:Boolean = false;
var _loc7_:int = 0;
var _loc4_:Object = null;
var _loc6_:Array = handlers.hasOwnProperty(param1) ? handlers[param1] : (handlers[param1] = []);
if(_loc6_.indexOf(param2) == -1)
{
_loc5_ = false;
param3 = Math.max(0,param3);
if(param3 > 0)
{
_loc7_ = 0;
while(_loc7_ < _loc6_.length)
{
_loc4_ = _loc6_[_loc7_];
if(_loc4_.priority < param3)
{
_loc6_.splice(_loc7_,0,{
"handler":param2,
"priority":param3
});
_loc5_ = true;
break;
}
_loc7_++;
}
}
if(!_loc5_)
{
_loc6_.push({
"handler":param2,
"priority":param3
});
}
}
}
public function removeHandler(param1:String, param2:Function) : void
{
var _loc4_:Array = null;
var _loc5_:int = 0;
var _loc3_:Object = null;
if(handlers.hasOwnProperty(param1))
{
_loc4_ = handlers[param1];
_loc5_ = 0;
while(_loc5_ < _loc4_.length)
{
_loc3_ = _loc4_[_loc5_];
if(_loc3_.handler == param2)
{
_loc4_.splice(_loc5_,1);
break;
}
_loc5_++;
}
}
}
override flash_proxy function callProperty(param1:*, ... rest) : *
{
return invokeHandlers(param1,rest);
}
override flash_proxy function getProperty(param1:*) : *
{
var result:*;
var name:* = param1;
if(handlers.hasOwnProperty(name))
{
result = function():*
{
return invokeHandlers(arguments.callee.name,arguments);
};
result.name = name;
}
return result;
}
override flash_proxy function hasProperty(param1:*) : Boolean
{
return handlers.hasOwnProperty(param1);
}
private function invokeHandlers(param1:String, param2:Array) : *
{
var _loc3_:Array = null;
var _loc5_:Array = null;
if(handlers.hasOwnProperty(param1))
{
_loc3_ = [];
_loc5_ = handlers[param1];
for each(var _loc4_:Object in _loc5_)
{
_loc3_.push(_loc4_.handler.apply(null,param2));
}
}
return _loc3_;
}
}
}
@@ -0,0 +1,24 @@
package org.osmf.net
{
public final class NetConnectionCodes
{
public static const CONNECT_CLOSED:String = "NetConnection.Connect.Closed";
public static const CONNECT_FAILED:String = "NetConnection.Connect.Failed";
public static const CONNECT_SUCCESS:String = "NetConnection.Connect.Success";
public static const CONNECT_REJECTED:String = "NetConnection.Connect.Rejected";
public static const CONNECT_INVALIDAPP:String = "NetConnection.Connect.InvalidApp";
public static const CONNECT_IDLE_TIME_OUT:String = "NetConnection.Connect.IdleTimeOut";
public function NetConnectionCodes()
{
super();
}
}
}
@@ -0,0 +1,298 @@
package org.osmf.net
{
import flash.net.NetConnection;
import flash.utils.Dictionary;
import org.osmf.events.NetConnectionFactoryEvent;
import org.osmf.media.URLResource;
import org.osmf.utils.URL;
public class NetConnectionFactory extends NetConnectionFactoryBase
{
private static const DEFAULT_TIMEOUT:Number = 10000;
private static const DEFAULT_PORTS:String = "1935,443,80";
private static const DEFAULT_PROTOCOLS_FOR_RTMP:String = "rtmp,rtmpt,rtmps";
private static const DEFAULT_PROTOCOLS_FOR_RTMPE:String = "rtmpe,rtmpte";
private static const DEFAULT_CONNECTION_ATTEMPT_INTERVAL:Number = 200;
private static const PROTOCOL_RTMP:String = "rtmp";
private static const PROTOCOL_RTMPS:String = "rtmps";
private static const PROTOCOL_RTMPT:String = "rtmpt";
private static const PROTOCOL_RTMPE:String = "rtmpe";
private static const PROTOCOL_RTMPTE:String = "rtmpte";
private static const PROTOCOL_HTTP:String = "http";
private static const PROTOCOL_HTTPS:String = "https";
private static const PROTOCOL_FILE:String = "file";
private static const PROTOCOL_EMPTY:String = "";
private static const MP3_EXTENSION:String = ".mp3";
private var shareNetConnections:Boolean;
private var negotiator:NetNegotiator;
private var connectionDictionary:Dictionary;
private var keyDictionary:Dictionary;
private var pendingDictionary:Dictionary;
private var _connectionAttemptInterval:Number = 200;
private var _timeout:Number = 10000;
public function NetConnectionFactory(param1:Boolean = true)
{
super();
this.shareNetConnections = param1;
}
public function get timeout() : Number
{
return _timeout;
}
public function set timeout(param1:Number) : void
{
_timeout = param1;
}
public function get connectionAttemptInterval() : Number
{
return _connectionAttemptInterval;
}
public function set connectionAttemptInterval(param1:Number) : void
{
_connectionAttemptInterval = param1;
}
override public function create(param1:URLResource) : void
{
var sharedConnection:SharedConnection;
var connectionsUnderway:Vector.<URLResource>;
var pendingConnections:Vector.<URLResource>;
var urlIncludesFMSApplicationInstance:Boolean;
var netConnectionURLs:Vector.<String>;
var netConnections:Vector.<NetConnection>;
var j:int;
var negotiator:NetNegotiator;
var onConnected:*;
var onConnectionFailed:*;
var resource:URLResource = param1;
var key:String = createNetConnectionKey(resource);
if(connectionDictionary == null)
{
connectionDictionary = new Dictionary();
keyDictionary = new Dictionary();
pendingDictionary = new Dictionary();
}
sharedConnection = connectionDictionary[key] as SharedConnection;
connectionsUnderway = pendingDictionary[key] as Vector.<URLResource>;
if(sharedConnection != null && shareNetConnections)
{
sharedConnection.count++;
dispatchEvent(new NetConnectionFactoryEvent("creationComplete",false,false,sharedConnection.netConnection,resource));
}
else if(connectionsUnderway != null)
{
connectionsUnderway.push(resource);
}
else
{
onConnected = function(param1:NetConnectionFactoryEvent):void
{
var _loc4_:Number = NaN;
var _loc6_:URLResource = null;
var _loc5_:SharedConnection = null;
var _loc3_:SharedConnection = null;
negotiator.removeEventListener("creationComplete",onConnected);
negotiator.removeEventListener("creationError",onConnectionFailed);
var _loc7_:Vector.<NetConnectionFactoryEvent> = new Vector.<NetConnectionFactoryEvent>();
var _loc2_:Vector.<URLResource> = pendingDictionary[key];
_loc4_ = 0;
while(_loc4_ < _loc2_.length)
{
_loc6_ = _loc2_[_loc4_] as URLResource;
if(shareNetConnections)
{
_loc5_ = connectionDictionary[key] as SharedConnection;
if(_loc5_ != null)
{
_loc5_.count++;
}
else
{
_loc3_ = new SharedConnection();
_loc3_.count = 1;
_loc3_.netConnection = param1.netConnection;
connectionDictionary[key] = _loc3_;
keyDictionary[_loc3_.netConnection] = key;
}
}
_loc7_.push(new NetConnectionFactoryEvent("creationComplete",false,false,param1.netConnection,_loc6_));
_loc4_++;
}
delete pendingDictionary[key];
for each(var _loc8_:NetConnectionFactoryEvent in _loc7_)
{
dispatchEvent(_loc8_);
}
};
onConnectionFailed = function(param1:NetConnectionFactoryEvent):void
{
negotiator.removeEventListener("creationComplete",onConnected);
negotiator.removeEventListener("creationError",onConnectionFailed);
var _loc2_:Vector.<URLResource> = pendingDictionary[key];
for each(var _loc3_:URLResource in _loc2_)
{
dispatchEvent(new NetConnectionFactoryEvent("creationError",false,false,null,_loc3_,param1.mediaError));
}
delete pendingDictionary[key];
};
pendingConnections = new Vector.<URLResource>();
pendingConnections.push(resource);
pendingDictionary[key] = pendingConnections;
urlIncludesFMSApplicationInstance = Boolean(resource is StreamingURLResource ? StreamingURLResource(resource).urlIncludesFMSApplicationInstance : false);
netConnectionURLs = createNetConnectionURLs(resource.url,urlIncludesFMSApplicationInstance);
netConnections = new Vector.<NetConnection>();
j = 0;
while(j < netConnectionURLs.length)
{
netConnections.push(createNetConnection());
j = j + 1;
}
negotiator = new NetNegotiator(_connectionAttemptInterval,_timeout);
negotiator.addEventListener("creationComplete",onConnected);
negotiator.addEventListener("creationError",onConnectionFailed);
negotiator.createNetConnection(resource,netConnectionURLs,netConnections);
}
}
override public function closeNetConnection(param1:NetConnection) : void
{
var _loc3_:String = null;
var _loc2_:SharedConnection = null;
if(shareNetConnections)
{
_loc3_ = keyDictionary[param1] as String;
if(_loc3_ != null)
{
_loc2_ = connectionDictionary[_loc3_] as SharedConnection;
_loc2_.count--;
if(_loc2_.count == 0)
{
param1.close();
delete connectionDictionary[_loc3_];
delete keyDictionary[param1];
}
}
}
else
{
super.closeNetConnection(param1);
}
}
protected function createNetConnectionKey(param1:URLResource) : String
{
var _loc2_:FMSURL = new FMSURL(param1.url);
return _loc2_.protocol + _loc2_.host + _loc2_.port + _loc2_.appName + _loc2_.instanceName;
}
protected function createNetConnection() : NetConnection
{
return new NetConnection();
}
protected function createNetConnectionURLs(param1:String, param2:Boolean = false) : Vector.<String>
{
var _loc3_:Vector.<String> = new Vector.<String>();
var _loc5_:Vector.<PortProtocol> = buildPortProtocolSequence(param1);
for each(var _loc4_:PortProtocol in _loc5_)
{
_loc3_.push(buildConnectionAddress(param1,param2,_loc4_));
}
return _loc3_;
}
private function buildPortProtocolSequence(param1:String) : Vector.<PortProtocol>
{
var _loc4_:int = 0;
var _loc5_:int = 0;
var _loc9_:PortProtocol = null;
var _loc6_:Vector.<PortProtocol> = new Vector.<PortProtocol>();
var _loc2_:URL = new URL(param1);
var _loc10_:String = _loc2_.port == "" ? "1935,443,80" : _loc2_.port;
var _loc7_:String = "";
switch(_loc2_.protocol)
{
case "rtmp":
_loc7_ = "rtmp,rtmpt,rtmps";
break;
case "rtmpe":
_loc7_ = "rtmpe,rtmpte";
break;
case "rtmps":
case "rtmpt":
case "rtmpte":
_loc7_ = _loc2_.protocol;
}
var _loc8_:Array = _loc10_.split(",");
var _loc3_:Array = _loc7_.split(",");
_loc4_ = 0;
while(_loc4_ < _loc3_.length)
{
_loc5_ = 0;
while(_loc5_ < _loc8_.length)
{
_loc9_ = new PortProtocol();
_loc9_.protocol = _loc3_[_loc4_];
_loc9_.port = _loc8_[_loc5_];
_loc6_.push(_loc9_);
_loc5_++;
}
_loc4_++;
}
return _loc6_;
}
private function buildConnectionAddress(param1:String, param2:Boolean, param3:PortProtocol) : String
{
var _loc4_:FMSURL = new FMSURL(param1,param2);
var _loc5_:String = param3.protocol + "://" + _loc4_.host + ":" + param3.port + "/" + _loc4_.appName + (_loc4_.useInstance ? "/" + _loc4_.instanceName : "");
if(_loc4_.query != null && _loc4_.query != "")
{
_loc5_ += "?" + _loc4_.query;
}
return _loc5_;
}
}
}
import flash.net.NetConnection;
class SharedConnection
{
public var count:Number;
public var netConnection:NetConnection;
public function SharedConnection()
{
super();
}
}
@@ -0,0 +1,28 @@
package org.osmf.net
{
import flash.errors.IllegalOperationError;
import flash.events.EventDispatcher;
import flash.net.NetConnection;
import org.osmf.media.URLResource;
import org.osmf.utils.OSMFStrings;
public class NetConnectionFactoryBase extends EventDispatcher
{
public function NetConnectionFactoryBase()
{
super();
}
public function create(param1:URLResource) : void
{
throw new IllegalOperationError(OSMFStrings.getString("functionMustBeOverridden"));
}
public function closeNetConnection(param1:NetConnection) : void
{
param1.close();
}
}
}
+519
View File
@@ -0,0 +1,519 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.events.TimerEvent;
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.NetStreamPlayOptions;
import flash.utils.Dictionary;
import flash.utils.Timer;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.events.NetConnectionFactoryEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.MediaTypeUtil;
import org.osmf.media.URLResource;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.OSMFStrings;
import org.osmf.utils.URL;
public class NetLoader extends LoaderBase
{
private static const PROTOCOL_RTMP:String = "rtmp";
private static const PROTOCOL_RTMPS:String = "rtmps";
private static const PROTOCOL_RTMPT:String = "rtmpt";
private static const PROTOCOL_RTMPE:String = "rtmpe";
private static const PROTOCOL_RTMPTE:String = "rtmpte";
private static const PROTOCOL_RTMFP:String = "rtmfp";
private static const PROTOCOL_HTTP:String = "http";
private static const PROTOCOL_HTTPS:String = "https";
private static const PROTOCOL_FILE:String = "file";
private static const PROTOCOL_EMPTY:String = "";
private static const STREAM_RECONNECT_TIMEOUT:Number = 120000;
private static const STREAM_RECONNECT_TIMER_INTERVAL:int = 1000;
private static const MEDIA_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["video"]);
private static const MIME_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["video/x-flv","video/x-f4v","video/mp4","video/mp4v-es","video/x-m4v","video/3gpp","video/3gpp2","video/quicktime"]);
private var netConnectionFactory:NetConnectionFactoryBase;
private var pendingLoads:Dictionary = new Dictionary();
private var oldConnectionURLs:Dictionary = new Dictionary();
private var _reconnectStreams:Boolean = true;
private var _reconnectTimeout:Number;
public function NetLoader(param1:NetConnectionFactoryBase = null)
{
super();
_reconnectTimeout = 120000;
netConnectionFactory = param1 || new NetConnectionFactory();
netConnectionFactory.addEventListener("creationComplete",onCreationComplete);
netConnectionFactory.addEventListener("creationError",onCreationError);
}
public function get reconnectTimeout() : Number
{
return _reconnectTimeout;
}
public function set reconnectTimeout(param1:Number) : void
{
if(param1 < 0)
{
throw new ArgumentError(OSMFStrings.getString("invalidParam"));
}
_reconnectTimeout = param1;
}
protected function setReconnectStreams(param1:Boolean) : void
{
_reconnectStreams = param1;
}
public function get reconnectStreams() : Boolean
{
return _reconnectStreams;
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc3_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,MEDIA_TYPES_SUPPORTED,MIME_TYPES_SUPPORTED);
if(_loc3_ != 2)
{
return _loc3_ == 0;
}
var _loc2_:URLResource = param1 as URLResource;
var _loc4_:RegExp = /.flv$|.f4v$|.mov$|.mp4$|.mp4v$|.m4v$|.3gp$|.3gpp2$|.3g2$/i;
var _loc5_:URL = _loc2_ != null ? new URL(_loc2_.url) : null;
if(_loc5_ == null || _loc5_.rawUrl == null || _loc5_.rawUrl.length <= 0)
{
return false;
}
if(_loc5_.protocol == "")
{
return _loc4_.test(_loc5_.path);
}
if(NetStreamUtils.isRTMPStream(_loc5_.rawUrl))
{
return true;
}
if(_loc5_.protocol.search(/file$|http$|https$/i) != -1)
{
return _loc5_.path == null || _loc5_.path.length <= 0 || _loc5_.path.indexOf(".") == -1 || _loc4_.test(_loc5_.path);
}
return false;
}
protected function createNetStream(param1:NetConnection, param2:URLResource) : NetStream
{
var _loc4_:NetStream = new NetStream(param1);
var _loc3_:StreamingURLResource = param2 as StreamingURLResource;
if(_loc3_ != null && _loc3_.streamType == "live" && _loc4_.bufferTime == 0)
{
_loc4_.bufferTime = 0.1;
}
return _loc4_;
}
protected function createNetStreamSwitchManager(param1:NetConnection, param2:NetStream, param3:DynamicStreamingResource) : NetStreamSwitchManagerBase
{
return null;
}
protected function processFinishLoading(param1:NetStreamLoadTrait) : void
{
updateLoadTrait(param1,"ready");
}
override protected function executeLoad(param1:LoadTrait) : void
{
updateLoadTrait(param1,"loading");
var _loc2_:URL = new URL((param1.resource as URLResource).url);
switch(_loc2_.protocol)
{
case "rtmp":
case "rtmps":
case "rtmpt":
case "rtmpe":
case "rtmpte":
case "rtmfp":
startLoadingRTMP(param1);
break;
case "http":
case "https":
case "file":
case "":
startLoadingHTTP(param1);
break;
default:
updateLoadTrait(param1,"loadError");
param1.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(5)));
}
}
override protected function executeUnload(param1:LoadTrait) : void
{
var _loc2_:NetStreamLoadTrait = param1 as NetStreamLoadTrait;
updateLoadTrait(param1,"unloading");
_loc2_.netStream.close();
if(_loc2_.netConnectionFactory != null)
{
_loc2_.netConnectionFactory.closeNetConnection(_loc2_.connection);
}
else
{
_loc2_.connection.close();
}
delete oldConnectionURLs[param1.resource];
updateLoadTrait(param1,"uninitialized");
}
protected function createReconnectNetConnection() : NetConnection
{
return new NetConnection();
}
protected function reconnect(param1:NetConnection, param2:URLResource) : void
{
var _loc3_:String = oldConnectionURLs[param2] as String;
if(_loc3_ != null && _loc3_.length > 0 && param1 != null)
{
param1.connect(_loc3_);
}
}
protected function reconnectStream(param1:NetStreamLoadTrait) : void
{
var _loc3_:NetStreamPlayOptions = new NetStreamPlayOptions();
param1.netStream.attach(param1.connection);
_loc3_.transition = "resume";
var _loc2_:URLResource = param1.resource as URLResource;
var _loc5_:Boolean = _loc2_ as StreamingURLResource != null ? (_loc2_ as StreamingURLResource).urlIncludesFMSApplicationInstance : false;
var _loc4_:String = NetStreamUtils.getStreamNameFromURL(_loc2_.url,_loc5_);
_loc3_.streamName = _loc4_;
param1.netStream.play2(_loc3_);
}
private function finishLoading(param1:NetConnection, param2:LoadTrait, param3:NetConnectionFactoryBase = null) : void
{
var _loc4_:NetStream = null;
var _loc5_:NetStreamLoadTrait = param2 as NetStreamLoadTrait;
if(_loc5_ != null)
{
_loc5_.connection = param1;
_loc4_ = createNetStream(param1,_loc5_.resource as URLResource);
_loc4_.client = new NetClient();
_loc5_.netStream = _loc4_;
_loc5_.switchManager = createNetStreamSwitchManager(param1,_loc4_,_loc5_.resource as DynamicStreamingResource);
_loc5_.netConnectionFactory = param3;
if(_reconnectStreams && _loc5_.resource is URLResource && supportsStreamReconnect(_loc5_.resource as URLResource))
{
setupStreamReconnect(_loc5_);
}
processFinishLoading(param2 as NetStreamLoadTrait);
}
}
private function supportsStreamReconnect(param1:URLResource) : Boolean
{
var _loc5_:String = null;
var _loc3_:Array = null;
var _loc6_:int = 0;
var _loc7_:int = 0;
var _loc4_:int = 0;
var _loc2_:Boolean = true;
if(NetStreamUtils.isRTMPStream(param1.url))
{
_loc5_ = param1.getMetadataValue("http://www.osmf.org/fmsServerVersion/1.0") as String;
if(_loc5_ != null && _loc5_.length > 0)
{
_loc3_ = _loc5_.split(",");
if(_loc3_.length >= 3)
{
_loc6_ = int(_loc3_[0]);
_loc7_ = int(_loc3_[1]);
_loc4_ = int(_loc3_[2]);
if(_loc6_ < 3 || _loc6_ == 3 && _loc7_ < 5 || _loc6_ == 3 && _loc7_ == 5 && _loc4_ < 3)
{
_loc2_ = false;
}
}
}
}
else
{
_loc2_ = false;
}
return _loc2_;
}
private function setupStreamReconnect(param1:NetStreamLoadTrait) : void
{
var timeoutTimer:Timer;
var streamIsPaused:Boolean;
var bufferIsEmpty:Boolean;
var reconnectHasTimedOut:Boolean;
var fmsIdleTimeoutReached:Boolean;
var loadTrait:NetStreamLoadTrait = param1;
var setupReconnectTimer:* = function(param1:Boolean = true):void
{
if(param1)
{
reconnectTimer.addEventListener("timerComplete",onReconnectTimer);
}
else
{
reconnectTimer.removeEventListener("timerComplete",onReconnectTimer);
reconnectTimer = null;
}
};
var setupTimeoutTimer:* = function(param1:Boolean = true):void
{
if(param1)
{
if(_reconnectTimeout > 0)
{
timeoutTimer = new Timer(_reconnectTimeout,1);
timeoutTimer.addEventListener("timerComplete",onTimeoutTimer);
}
}
else if(timeoutTimer != null)
{
timeoutTimer.removeEventListener("timerComplete",onTimeoutTimer);
timeoutTimer = null;
}
};
var setupNetConnectionListeners:* = function(param1:Boolean = true):void
{
if(param1)
{
netConnection.addEventListener("netStatus",onNetStatus);
}
else
{
netConnection.removeEventListener("netStatus",onNetStatus);
}
};
var setupNetStreamListeners:* = function(param1:Boolean = true):void
{
if(loadTrait.netStream != null)
{
if(param1)
{
loadTrait.netStream.addEventListener("netStatus",onNetStatus);
}
else
{
loadTrait.netStream.removeEventListener("netStatus",onNetStatus);
}
}
};
var onNetStatus:* = function(param1:NetStatusEvent):void
{
var _loc2_:NetConnection = null;
switch(param1.info.code)
{
case "NetConnection.Connect.Success":
_loc2_ = loadTrait.connection;
loadTrait.connection = netConnection;
oldConnectionURLs[loadTrait.resource] = netConnection.uri;
if(timeoutTimer != null)
{
timeoutTimer.stop();
}
reconnectStream(loadTrait);
if(loadTrait.netConnectionFactory != null)
{
loadTrait.netConnectionFactory.closeNetConnection(_loc2_);
}
else
{
_loc2_.close();
}
break;
case "NetConnection.Connect.IdleTimeOut":
fmsIdleTimeoutReached = true;
break;
case "NetConnection.Connect.Closed":
case "NetConnection.Connect.Failed":
if(loadTrait.loadState == "ready" && !reconnectHasTimedOut && !fmsIdleTimeoutReached)
{
reconnectTimer.start();
if(bufferIsEmpty || loadTrait.netStream.bufferLength == 0 || streamIsPaused)
{
if(timeoutTimer != null)
{
timeoutTimer.start();
}
else
{
reconnectHasTimedOut = true;
setupReconnectTimer(false);
setupNetConnectionListeners(false);
setupNetStreamListeners(false);
setupTimeoutTimer(false);
}
}
}
else
{
setupReconnectTimer(false);
setupNetConnectionListeners(false);
setupNetStreamListeners(false);
setupTimeoutTimer(false);
}
break;
case "NetStream.Pause.Notify":
streamIsPaused = true;
break;
case "NetStream.Unpause.Notify":
streamIsPaused = false;
break;
case "NetStream.Buffer.Empty":
if(!netConnection.connected)
{
if(timeoutTimer != null)
{
timeoutTimer.start();
}
else
{
reconnectHasTimedOut = true;
}
}
else
{
bufferIsEmpty = true;
}
break;
case "NetStream.Buffer.Full":
bufferIsEmpty = false;
}
};
var onTimeoutTimer:* = function(param1:TimerEvent):void
{
reconnectHasTimedOut = true;
};
var onReconnectTimer:* = function(param1:TimerEvent):void
{
if(reconnectHasTimedOut)
{
return;
}
if(netConnection === loadTrait.connection)
{
setupNetConnectionListeners(false);
netConnection = createReconnectNetConnection();
netConnection.client = new NetClient();
setupNetConnectionListeners();
}
reconnect(netConnection,loadTrait.resource as URLResource);
};
var netConnection:NetConnection = loadTrait.connection;
var reconnectTimer:Timer = new Timer(1000,1);
oldConnectionURLs[loadTrait.resource] = netConnection.uri;
streamIsPaused = false;
bufferIsEmpty = false;
reconnectHasTimedOut = false;
fmsIdleTimeoutReached = false;
setupNetConnectionListeners();
setupNetStreamListeners();
setupReconnectTimer();
setupTimeoutTimer();
}
private function startLoadingRTMP(param1:LoadTrait) : void
{
addPendingLoad(param1);
netConnectionFactory.create(param1.resource as URLResource);
}
private function onCreationComplete(param1:NetConnectionFactoryEvent) : void
{
processCreationComplete(param1.netConnection,findAndRemovePendingLoad(param1.resource),param1.currentTarget as NetConnectionFactoryBase);
}
protected function processCreationComplete(param1:NetConnection, param2:LoadTrait, param3:NetConnectionFactoryBase = null) : void
{
finishLoading(param1,param2,param3);
}
private function onCreationError(param1:NetConnectionFactoryEvent) : void
{
var _loc2_:LoadTrait = findAndRemovePendingLoad(param1.resource);
if(_loc2_ != null)
{
_loc2_.dispatchEvent(new MediaErrorEvent("mediaError",false,false,param1.mediaError));
updateLoadTrait(_loc2_,"loadError");
}
}
private function startLoadingHTTP(param1:LoadTrait) : void
{
var _loc2_:NetConnection = new NetConnection();
_loc2_.client = new NetClient();
_loc2_.connect(null);
finishLoading(_loc2_,param1);
}
private function addPendingLoad(param1:LoadTrait) : void
{
if(pendingLoads[param1.resource] == null)
{
pendingLoads[param1.resource] = [param1];
}
else
{
pendingLoads[param1.resource].push(param1);
}
}
private function findAndRemovePendingLoad(param1:URLResource) : LoadTrait
{
var _loc3_:int = 0;
var _loc4_:LoadTrait = null;
var _loc2_:Array = pendingLoads[param1];
if(_loc2_ != null)
{
if(_loc2_.length == 1)
{
_loc4_ = _loc2_[0] as LoadTrait;
delete pendingLoads[param1];
}
else
{
_loc3_ = 0;
while(_loc3_ < _loc2_.length)
{
_loc4_ = _loc2_[_loc3_];
if(_loc4_.resource == param1)
{
_loc2_.splice(_loc3_,1);
break;
}
_loc3_++;
}
}
}
return _loc4_;
}
}
}
@@ -0,0 +1,227 @@
package org.osmf.net
{
import flash.errors.IOError;
import flash.events.AsyncErrorEvent;
import flash.events.EventDispatcher;
import flash.events.NetStatusEvent;
import flash.events.SecurityErrorEvent;
import flash.events.TimerEvent;
import flash.net.NetConnection;
import flash.utils.Timer;
import org.osmf.events.MediaError;
import org.osmf.events.NetConnectionFactoryEvent;
import org.osmf.media.URLResource;
internal class NetNegotiator extends EventDispatcher
{
private var resource:URLResource;
private var netConnectionURLs:Vector.<String>;
private var netConnections:Vector.<NetConnection>;
private var netConnectionArguments:Vector.<Object>;
private var failedConnectionCount:int;
private var timeOutTimer:Timer;
private var connectionTimer:Timer;
private var attemptIndex:int;
private var mediaError:MediaError;
private var connectionAttemptInterval:Number;
private var _timeout:Number;
public function NetNegotiator(param1:Number, param2:Number = 10000)
{
super();
this.connectionAttemptInterval = param1;
this._timeout = param2;
}
public function get timeout() : Number
{
return _timeout;
}
public function set timeout(param1:Number) : void
{
_timeout = param1;
}
public function createNetConnection(param1:URLResource, param2:Vector.<String>, param3:Vector.<NetConnection>) : void
{
this.resource = param1;
this.netConnectionURLs = param2;
this.netConnections = param3;
var _loc4_:StreamingURLResource = param1 as StreamingURLResource;
if(_loc4_ != null && _loc4_.connectionArguments != null && _loc4_.connectionArguments.length > 0)
{
this.netConnectionArguments = _loc4_.connectionArguments;
}
initializeConnectionAttempts();
tryToConnect(null);
}
private function initializeConnectionAttempts() : void
{
timeOutTimer = new Timer(_timeout,1);
timeOutTimer.addEventListener("timerComplete",masterTimeout);
timeOutTimer.start();
connectionTimer = new Timer(connectionAttemptInterval);
connectionTimer.addEventListener("timer",tryToConnect);
connectionTimer.start();
failedConnectionCount = 0;
attemptIndex = 0;
}
private function tryToConnect(param1:TimerEvent) : void
{
var _loc3_:MulticastResource = null;
var _loc5_:String = null;
var _loc2_:Array = null;
netConnections[attemptIndex].addEventListener("netStatus",onNetStatus,false,0,true);
netConnections[attemptIndex].addEventListener("securityError",onNetSecurityError,false,0,true);
netConnections[attemptIndex].addEventListener("asyncError",onAsyncError,false,0,true);
netConnections[attemptIndex].client = new NetClient();
try
{
_loc3_ = resource as MulticastResource;
if(_loc3_ != null && _loc3_.groupspec != null && _loc3_.groupspec.length > 0)
{
NetConnection(netConnections[attemptIndex]).connect(_loc3_.url);
}
else
{
_loc5_ = netConnectionURLs[attemptIndex];
_loc2_ = [_loc5_];
if(netConnectionArguments != null)
{
for each(var _loc4_:Object in netConnectionArguments)
{
_loc2_.push(_loc4_);
}
}
NetConnection(netConnections[attemptIndex]).connect.apply(netConnections[attemptIndex],_loc2_);
}
attemptIndex = attemptIndex + 1;
if(attemptIndex >= netConnectionURLs.length)
{
connectionTimer.stop();
}
}
catch(ioError:IOError)
{
handleFailedConnectionSession(new MediaError(1,ioError.message),netConnectionURLs[attemptIndex]);
}
catch(argumentError:ArgumentError)
{
handleFailedConnectionSession(new MediaError(4,argumentError.message),netConnectionURLs[attemptIndex]);
}
catch(securityError:SecurityError)
{
handleFailedConnectionSession(new MediaError(2,securityError.message),netConnectionURLs[attemptIndex]);
}
}
private function onNetStatus(param1:NetStatusEvent) : void
{
var index:int;
var tempTimer:Timer;
var onTempTimer:*;
var event:NetStatusEvent = param1;
switch(event.info.code)
{
case "NetConnection.Connect.InvalidApp":
handleFailedConnectionSession(new MediaError(12,event.info.description),NetConnection(event.target).uri);
break;
case "NetConnection.Connect.Rejected":
if(event.info.hasOwnProperty("ex") && event.info.ex.code == 302)
{
onTempTimer = function(param1:TimerEvent):void
{
tempTimer.removeEventListener("timer",onTempTimer);
tempTimer.stop();
tryToConnect(null);
};
index = netConnections.indexOf(event.target as NetConnection);
netConnectionURLs[index] = event.info.ex.redirect;
attemptIndex = index;
tempTimer = new Timer(100,1);
tempTimer.addEventListener("timer",onTempTimer);
tempTimer.start();
}
else
{
handleFailedConnectionSession(new MediaError(11,event.info.description),NetConnection(event.target).uri);
}
break;
case "NetConnection.Connect.Failed":
failedConnectionCount = failedConnectionCount + 1;
if(failedConnectionCount >= netConnectionURLs.length)
{
handleFailedConnectionSession(new MediaError(13),NetConnection(event.target).uri);
}
break;
case "NetConnection.Connect.Success":
if(event.info.hasOwnProperty("data") && event.info.data.hasOwnProperty("version"))
{
resource.addMetadataValue("http://www.osmf.org/fmsServerVersion/1.0",event.info.data.version);
}
shutDownUnsuccessfulConnections();
dispatchEvent(new NetConnectionFactoryEvent("creationComplete",false,false,event.currentTarget as NetConnection,resource));
break;
case "NetStream.Publish.Start":
}
}
private function shutDownUnsuccessfulConnections() : void
{
var _loc2_:int = 0;
var _loc1_:NetConnection = null;
timeOutTimer.stop();
connectionTimer.stop();
_loc2_ = 0;
while(_loc2_ < netConnections.length)
{
_loc1_ = netConnections[_loc2_];
if(!_loc1_.connected)
{
_loc1_.removeEventListener("netStatus",onNetStatus);
_loc1_.removeEventListener("securityError",onNetSecurityError);
_loc1_.removeEventListener("asyncError",onAsyncError);
_loc1_.close();
delete netConnections[_loc2_];
}
_loc2_++;
}
}
private function handleFailedConnectionSession(param1:MediaError, param2:String) : void
{
shutDownUnsuccessfulConnections();
dispatchEvent(new NetConnectionFactoryEvent("creationError",false,false,null,resource,param1));
}
private function onNetSecurityError(param1:SecurityErrorEvent) : void
{
handleFailedConnectionSession(new MediaError(2,param1.text),NetConnection(param1.target).uri);
}
private function onAsyncError(param1:AsyncErrorEvent) : void
{
handleFailedConnectionSession(new MediaError(3,param1.text),NetConnection(param1.target).uri);
}
private function masterTimeout(param1:TimerEvent) : void
{
handleFailedConnectionSession(new MediaError(14,"" + _timeout),"");
}
}
}
@@ -0,0 +1,40 @@
package org.osmf.net
{
import flash.media.SoundTransform;
import flash.net.NetStream;
import org.osmf.traits.AudioTrait;
public class NetStreamAudioTrait extends AudioTrait
{
private var netStream:NetStream;
public function NetStreamAudioTrait(param1:NetStream)
{
super();
this.netStream = param1;
}
override protected function volumeChangeStart(param1:Number) : void
{
var _loc2_:SoundTransform = netStream.soundTransform;
_loc2_.volume = muted ? 0 : param1;
netStream.soundTransform = _loc2_;
}
override protected function mutedChangeStart(param1:Boolean) : void
{
var _loc2_:SoundTransform = netStream.soundTransform;
_loc2_.volume = param1 ? 0 : volume;
netStream.soundTransform = _loc2_;
}
override protected function panChangeStart(param1:Number) : void
{
var _loc2_:SoundTransform = netStream.soundTransform;
_loc2_.pan = param1;
netStream.soundTransform = _loc2_;
}
}
}
@@ -0,0 +1,62 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.events.TimerEvent;
import flash.net.NetStream;
import flash.utils.Timer;
import org.osmf.traits.BufferTrait;
public class NetStreamBufferTrait extends BufferTrait
{
private var netStream:NetStream;
private var changeBufferLengthTimer:Timer;
public function NetStreamBufferTrait(param1:NetStream)
{
super();
this.netStream = param1;
bufferTime = param1.bufferTime;
param1.addEventListener("netStatus",onNetStatus,false,0,true);
changeBufferLengthTimer = new Timer(250);
changeBufferLengthTimer.addEventListener("timer",onChangeBufferLength,false,0,true);
changeBufferLengthTimer.start();
}
override public function get bufferLength() : Number
{
return netStream.bufferLength;
}
override protected function bufferTimeChangeStart(param1:Number) : void
{
netStream.bufferTime = param1;
}
private function onChangeBufferLength(param1:TimerEvent) : void
{
setBufferLength(netStream.bufferLength);
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Play.Start":
case "NetStream.Buffer.Empty":
bufferTime = netStream.bufferTime;
setBuffering(true);
if(netStream.bufferTime == 0)
{
setBuffering(false);
}
break;
case "NetStream.Buffer.Flush":
case "NetStream.Buffer.Full":
setBuffering(false);
}
}
}
}
@@ -0,0 +1,64 @@
package org.osmf.net
{
public final class NetStreamCodes
{
public static const NETSTREAM_BUFFER_EMPTY:String = "NetStream.Buffer.Empty";
public static const NETSTREAM_BUFFER_FULL:String = "NetStream.Buffer.Full";
public static const NETSTREAM_BUFFER_FLUSH:String = "NetStream.Buffer.Flush";
public static const NETSTREAM_DRM_UPDATE:String = "DRM.UpdateNeeded";
public static const NETSTREAM_FAILED:String = "NetStream.Failed";
public static const NETSTREAM_PLAY_START:String = "NetStream.Play.Start";
public static const NETSTREAM_PLAY_STOP:String = "NetStream.Play.Stop";
public static const NETSTREAM_PLAY_FAILED:String = "NetStream.Play.Failed";
public static const NETSTREAM_PLAY_STREAMNOTFOUND:String = "NetStream.Play.StreamNotFound";
public static const NETSTREAM_PLAY_RESET:String = "NetStream.Play.Reset";
public static const NETSTREAM_PLAY_INSUFFICIENTBW:String = "NetStream.Play.InsufficientBW";
public static const NETSTREAM_PLAY_FILESTRUCTUREINVALID:String = "NetStream.Play.FileStructureInvalid";
public static const NETSTREAM_PLAY_NOSUPPORTEDTRACKFOUND:String = "NetStream.Play.NoSupportedTrackFound";
public static const NETSTREAM_PLAY_TRANSITION:String = "NetStream.Play.Transition";
public static const NETSTREAM_PAUSE_NOTIFY:String = "NetStream.Pause.Notify";
public static const NETSTREAM_PLAY_PUBLISH_NOTIFY:String = "NetStream.Play.PublishNotify";
public static const NETSTREAM_PLAY_UNPUBLISH_NOTIFY:String = "NetStream.Play.UnpublishNotify";
public static const NETSTREAM_UNPAUSE_NOTIFY:String = "NetStream.Unpause.Notify";
public static const NETSTREAM_SEEK_FAILED:String = "NetStream.Seek.Failed";
public static const NETSTREAM_SEEK_INVALIDTIME:String = "NetStream.Seek.InvalidTime";
public static const NETSTREAM_SEEK_NOTIFY:String = "NetStream.Seek.Notify";
public static const NETSTREAM_PLAY_COMPLETE:String = "NetStream.Play.Complete";
public static const NETSTREAM_PLAY_TRANSITION_COMPLETE:String = "NetStream.Play.TransitionComplete";
public static const ON_META_DATA:String = "onMetaData";
public static const ON_CUE_POINT:String = "onCuePoint";
public static const ON_PLAY_STATUS:String = "onPlayStatus";
public function NetStreamCodes()
{
super();
}
}
}
@@ -0,0 +1,62 @@
package org.osmf.net
{
import flash.display.DisplayObject;
import flash.events.Event;
import flash.media.Video;
import flash.net.NetStream;
import org.osmf.traits.DisplayObjectTrait;
public class NetStreamDisplayObjectTrait extends DisplayObjectTrait
{
private var netStream:NetStream;
public function NetStreamDisplayObjectTrait(param1:NetStream, param2:DisplayObject, param3:Number = 0, param4:Number = 0)
{
super(param2,param3,param4);
this.netStream = param1;
NetClient(param1.client).addHandler("onMetaData",onMetaData);
if(param2 is Video)
{
param2.addEventListener("addedToStage",onStage);
}
}
private function onStage(param1:Event) : void
{
displayObject.removeEventListener("addedToStage",onStage);
displayObject.addEventListener("enterFrame",onFrame);
}
private function onFrame(param1:Event) : void
{
if(Video(displayObject).videoWidth != 0 && Video(displayObject).videoHeight != 0)
{
if(Video(displayObject).videoWidth != mediaWidth && Video(displayObject).videoHeight != mediaHeight)
{
newMediaSize(Video(displayObject).videoWidth,Video(displayObject).videoHeight);
}
displayObject.removeEventListener("enterFrame",onFrame);
}
}
private function onMetaData(param1:Object) : void
{
if(!isNaN(param1.width) && !isNaN(param1.height) && (param1.width != mediaWidth || param1.height != mediaHeight))
{
newMediaSize(param1.width,param1.height);
}
}
private function newMediaSize(param1:Number, param2:Number) : void
{
if(displayObject.width == 0 && displayObject.height == 0)
{
displayObject.width = param1;
displayObject.height = param2;
}
setMediaSize(param1,param2);
}
}
}
@@ -0,0 +1,97 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.net.NetStream;
import org.osmf.traits.DynamicStreamTrait;
import org.osmf.utils.OSMFStrings;
public class NetStreamDynamicStreamTrait extends DynamicStreamTrait
{
private var netStream:NetStream;
private var switchManager:NetStreamSwitchManagerBase;
private var inSetSwitching:Boolean;
private var dsResource:DynamicStreamingResource;
private var indexToSwitchTo:int;
public function NetStreamDynamicStreamTrait(param1:NetStream, param2:NetStreamSwitchManagerBase, param3:DynamicStreamingResource)
{
super(param2.autoSwitch,param2.currentIndex,param3.streamItems.length);
this.netStream = param1;
this.switchManager = param2;
this.dsResource = param3;
param1.addEventListener("netStatus",onNetStatus);
NetClient(param1.client).addHandler("onPlayStatus",onPlayStatus);
}
override public function dispose() : void
{
netStream = null;
switchManager = null;
}
override public function getBitrateForIndex(param1:int) : Number
{
if(param1 > numDynamicStreams - 1 || param1 < 0)
{
throw new RangeError(OSMFStrings.getString("streamSwitchInvalidIndex"));
}
return dsResource.streamItems[param1].bitrate;
}
override protected function switchingChangeStart(param1:Boolean, param2:int) : void
{
if(param1 && !inSetSwitching)
{
indexToSwitchTo = param2;
}
}
override protected function switchingChangeEnd(param1:int) : void
{
super.switchingChangeEnd(param1);
if(switching && !inSetSwitching)
{
switchManager.switchTo(indexToSwitchTo);
}
}
override protected function autoSwitchChangeStart(param1:Boolean) : void
{
switchManager.autoSwitch = param1;
}
override protected function maxAllowedIndexChangeStart(param1:int) : void
{
switchManager.maxAllowedIndex = param1;
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Play.Transition":
inSetSwitching = true;
setSwitching(true,dsResource.indexFromName(param1.info.details));
inSetSwitching = false;
break;
case "NetStream.Play.Failed":
setSwitching(false,currentIndex);
}
}
private function onPlayStatus(param1:Object) : void
{
var _loc2_:* = param1.code;
if("NetStream.Play.TransitionComplete" === _loc2_)
{
setSwitching(false,switchManager.currentIndex);
}
}
}
}
@@ -0,0 +1,140 @@
package org.osmf.net
{
import flash.errors.IllegalOperationError;
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import flash.net.NetGroup;
import flash.net.NetStream;
import flash.utils.Dictionary;
import org.osmf.events.LoadEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.traits.MediaTraitBase;
import org.osmf.utils.OSMFStrings;
public class NetStreamLoadTrait extends LoadTrait
{
private var _connection:NetConnection;
private var _switchManager:NetStreamSwitchManagerBase;
private var traits:Dictionary = new Dictionary();
private var _netConnectionFactory:NetConnectionFactoryBase;
private var isStreamingResource:Boolean;
private var _netStream:NetStream;
private var _netGroup:NetGroup;
public function NetStreamLoadTrait(param1:LoaderBase, param2:MediaResourceBase)
{
super(param1,param2);
isStreamingResource = NetStreamUtils.isStreamingResource(param2);
}
public function get connection() : NetConnection
{
return _connection;
}
public function set connection(param1:NetConnection) : void
{
_connection = param1;
}
public function get netStream() : NetStream
{
return _netStream;
}
public function set netStream(param1:NetStream) : void
{
_netStream = param1;
}
public function get netGroup() : NetGroup
{
return _netGroup;
}
public function set netGroup(param1:NetGroup) : void
{
_netGroup = param1;
}
public function get switchManager() : NetStreamSwitchManagerBase
{
return _switchManager;
}
public function set switchManager(param1:NetStreamSwitchManagerBase) : void
{
_switchManager = param1;
}
public function setTrait(param1:MediaTraitBase) : void
{
if(param1 == null)
{
throw new IllegalOperationError(OSMFStrings.getString("nullParam"));
}
traits[param1.traitType] = param1;
}
public function getTrait(param1:String) : MediaTraitBase
{
return traits[param1];
}
public function get netConnectionFactory() : NetConnectionFactoryBase
{
return _netConnectionFactory;
}
public function set netConnectionFactory(param1:NetConnectionFactoryBase) : void
{
_netConnectionFactory = param1;
}
override protected function loadStateChangeStart(param1:String) : void
{
if(param1 == "ready")
{
if(!isStreamingResource && (netStream.bytesTotal <= 0 || netStream.bytesTotal == 4294967295))
{
netStream.addEventListener("netStatus",onNetStatus);
}
}
else if(param1 == "uninitialized")
{
netStream = null;
dispatchEvent(new LoadEvent("bytesLoadedChange",false,false,null,bytesLoaded));
dispatchEvent(new LoadEvent("bytesTotalChange",false,false,null,bytesTotal));
}
}
override public function get bytesLoaded() : Number
{
return isStreamingResource ? NaN : (netStream != null ? netStream.bytesLoaded : NaN);
}
override public function get bytesTotal() : Number
{
return isStreamingResource ? NaN : (netStream != null ? netStream.bytesTotal : NaN);
}
private function onNetStatus(param1:NetStatusEvent) : void
{
if(netStream != null && netStream.bytesTotal > 0)
{
dispatchEvent(new LoadEvent("bytesTotalChange",false,false,null,netStream.bytesTotal));
netStream.removeEventListener("netStatus",onNetStatus);
}
}
}
}
@@ -0,0 +1,178 @@
package org.osmf.net
{
import flash.events.EventDispatcher;
import flash.events.NetStatusEvent;
import flash.events.TimerEvent;
import flash.net.NetStream;
import flash.utils.Timer;
public class NetStreamMetricsBase extends EventDispatcher
{
private static const DEFAULT_UPDATE_INTERVAL:Number = 100;
private static const DEFAULT_AVG_FRAMERATE_SAMPLE_SIZE:Number = 50;
private var _netStream:NetStream;
private var _resource:DynamicStreamingResource;
private var _currentIndex:int;
private var _maxAllowedIndex:int;
private var _timer:Timer;
private var _averageDroppedFPSArray:Array;
private var _averageDroppedFPS:Number;
private var _droppedFPS:Number;
private var _lastFrameDropValue:Number;
private var _lastFrameDropCounter:Number;
private var _maxFPS:Number;
public function NetStreamMetricsBase(param1:NetStream)
{
super();
_netStream = param1;
_droppedFPS = 0;
_lastFrameDropCounter = 0;
_lastFrameDropValue = 0;
_maxFPS = 0;
_averageDroppedFPSArray = [];
_timer = new Timer(100);
_timer.addEventListener("timer",onTimerEvent);
param1.addEventListener("netStatus",onNetStatusEvent);
}
public function get resource() : DynamicStreamingResource
{
return _resource;
}
public function set resource(param1:DynamicStreamingResource) : void
{
_resource = param1;
_maxAllowedIndex = param1 != null ? param1.streamItems.length - 1 : 0;
}
public function get netStream() : NetStream
{
return _netStream;
}
public function get currentIndex() : int
{
return _currentIndex;
}
public function set currentIndex(param1:int) : void
{
_currentIndex = param1;
}
public function get maxAllowedIndex() : int
{
return _maxAllowedIndex;
}
public function set maxAllowedIndex(param1:int) : void
{
_maxAllowedIndex = param1;
}
public function get updateInterval() : Number
{
return _timer.delay;
}
public function set updateInterval(param1:Number) : void
{
_timer.delay = param1;
if(param1 <= 0)
{
_timer.stop();
}
}
public function get maxFPS() : Number
{
return _maxFPS;
}
public function get droppedFPS() : Number
{
return _droppedFPS;
}
public function get averageDroppedFPS() : Number
{
return _averageDroppedFPS;
}
protected function calculateMetrics() : void
{
var _loc1_:Number = NaN;
var _loc2_:* = 0;
try
{
_maxFPS = netStream.currentFPS > _maxFPS ? netStream.currentFPS : _maxFPS;
if(_timer.currentCount - _lastFrameDropCounter > 1000 / _timer.delay)
{
_droppedFPS = (netStream.info.droppedFrames - _lastFrameDropValue) / ((_timer.currentCount - _lastFrameDropCounter) * _timer.delay / 1000);
_lastFrameDropCounter = _timer.currentCount;
_lastFrameDropValue = netStream.info.droppedFrames;
}
_averageDroppedFPSArray.unshift(_droppedFPS);
if(_averageDroppedFPSArray.length > 50)
{
_averageDroppedFPSArray.pop();
}
_loc1_ = 0;
_loc2_ = 0;
while(_loc2_ < _averageDroppedFPSArray.length)
{
_loc1_ += _averageDroppedFPSArray[_loc2_];
_loc2_++;
}
_averageDroppedFPS = _averageDroppedFPSArray.length < 50 ? 0 : _loc1_ / _averageDroppedFPSArray.length;
}
catch(error:Error)
{
throw error;
}
}
private function onNetStatusEvent(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Play.Start":
if(!_timer.running && updateInterval > 0)
{
_timer.start();
}
break;
case "NetStream.Play.Stop":
_timer.stop();
}
}
private function onTimerEvent(param1:TimerEvent) : void
{
if(isNaN(netStream.time))
{
_timer.stop();
}
else
{
calculateMetrics();
}
}
}
}
@@ -0,0 +1,168 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.NetStreamPlayOptions;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.traits.PlayTrait;
import org.osmf.utils.OSMFStrings;
public class NetStreamPlayTrait extends PlayTrait
{
private static const NETCONNECTION_FAILURE_ERROR_CODE:int = 2154;
private var streamStarted:Boolean;
private var netStream:NetStream;
private var netConnection:NetConnection;
private var urlResource:URLResource;
private var multicastResource:MulticastResource;
private var reconnectStreams:Boolean;
public function NetStreamPlayTrait(param1:NetStream, param2:MediaResourceBase, param3:Boolean, param4:NetConnection)
{
super();
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString("nullParam"));
}
this.netStream = param1;
this.netConnection = param4;
this.urlResource = param2 as URLResource;
this.multicastResource = param2 as MulticastResource;
this.reconnectStreams = param3;
param1.addEventListener("netStatus",onNetStatus,false,1,true);
NetClient(param1.client).addHandler("onPlayStatus",onPlayStatus,1);
}
override protected function playStateChangeStart(param1:String) : void
{
var _loc3_:Object = null;
var _loc2_:StreamingURLResource = null;
var _loc9_:Boolean = false;
var _loc8_:String = null;
var _loc6_:Number = NaN;
var _loc4_:Number = NaN;
var _loc5_:DynamicStreamingResource = null;
var _loc7_:NetStreamPlayOptions = null;
if(param1 == "playing")
{
if(streamStarted)
{
if(multicastResource != null)
{
netStream.play(multicastResource.streamName,-1,-1);
}
else
{
netStream.resume();
}
}
else if(urlResource != null)
{
_loc2_ = urlResource as StreamingURLResource;
_loc9_ = _loc2_ ? _loc2_.urlIncludesFMSApplicationInstance : false;
_loc8_ = NetStreamUtils.getStreamNameFromURL(urlResource.url,_loc9_);
_loc3_ = NetStreamUtils.getPlayArgsForResource(urlResource);
_loc6_ = Number(_loc3_.start);
_loc4_ = Number(_loc3_.len);
_loc5_ = urlResource as DynamicStreamingResource;
if(_loc5_ != null)
{
_loc7_ = new NetStreamPlayOptions();
_loc7_.start = _loc6_;
_loc7_.len = _loc4_;
_loc7_.streamName = _loc5_.streamItems[_loc5_.initialIndex].streamName;
_loc7_.transition = "reset";
doPlay2(_loc7_);
}
else if(reconnectStreams && _loc2_ != null && NetStreamUtils.isRTMPStream(_loc2_.url))
{
_loc7_ = new NetStreamPlayOptions();
_loc7_.start = _loc6_;
_loc7_.len = _loc4_;
_loc7_.transition = "reset";
_loc7_.streamName = _loc8_;
doPlay2(_loc7_);
}
else if(multicastResource != null && multicastResource.groupspec != null && multicastResource.groupspec.length > 0)
{
doPlay(multicastResource.streamName,_loc6_,_loc4_);
}
else
{
doPlay(_loc8_,_loc6_,_loc4_);
}
}
}
else if(multicastResource != null)
{
netStream.play(false);
}
else
{
netStream.pause();
}
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Play.Failed":
case "NetStream.Play.FileStructureInvalid":
case "NetStream.Play.StreamNotFound":
case "NetStream.Play.NoSupportedTrackFound":
case "NetStream.Failed":
netStream.pause();
streamStarted = false;
break;
case "NetStream.Play.Stop":
if(urlResource != null && NetStreamUtils.isStreamingResource(urlResource) == false)
{
stop();
}
}
}
private function onPlayStatus(param1:Object) : void
{
var _loc2_:* = param1.code;
if("NetStream.Play.Complete" === _loc2_)
{
stop();
}
}
private function doPlay(... rest) : void
{
try
{
netStream.play.apply(this,rest);
streamStarted = true;
}
catch(error:Error)
{
streamStarted = false;
stop();
dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(15)));
}
}
private function doPlay2(param1:NetStreamPlayOptions) : void
{
netStream.play2(param1);
streamStarted = true;
}
}
}
@@ -0,0 +1,141 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.events.TimerEvent;
import flash.media.Video;
import flash.net.NetStream;
import flash.utils.Timer;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.SeekTrait;
import org.osmf.traits.TimeTrait;
public class NetStreamSeekTrait extends SeekTrait
{
private var video:Video;
private var loadTrait:LoadTrait;
private var audioDelay:Number = 0;
private var seekBugTimer:Timer;
private var netStream:NetStream;
private var expectedTime:Number;
private var previousTime:Number;
private var suppressSeekNotifyEvent:Boolean = false;
public function NetStreamSeekTrait(param1:TimeTrait, param2:LoadTrait, param3:NetStream, param4:Video = null)
{
super(param1);
this.netStream = param3;
this.video = param4;
this.loadTrait = param2;
NetClient(param3.client).addHandler("onMetaData",onMetaData);
param3.addEventListener("netStatus",onNetStatus);
seekBugTimer = new Timer(10,100);
seekBugTimer.addEventListener("timer",onSeekBugTimer,false,0,true);
seekBugTimer.addEventListener("timerComplete",onSeekBugTimerDone,false,0,true);
}
override public function canSeekTo(param1:Number) : Boolean
{
var _loc3_:Number = NaN;
var _loc2_:Boolean = super.canSeekTo(param1);
if(_loc2_ && !isNaN(loadTrait.bytesTotal) && loadTrait.bytesTotal > 0)
{
_loc3_ = timeTrait.duration * (loadTrait.bytesLoaded / loadTrait.bytesTotal);
_loc2_ = param1 <= _loc3_;
}
return _loc2_;
}
override protected function seekingChangeStart(param1:Boolean, param2:Number) : void
{
if(param1)
{
suppressSeekNotifyEvent = false;
previousTime = netStream.time - audioDelay;
expectedTime = param2;
netStream.seek(param2 + audioDelay);
if(previousTime == expectedTime)
{
seekBugTimer.start();
suppressSeekNotifyEvent = true;
}
}
}
override protected function seekingChangeEnd(param1:Number) : void
{
var _loc2_:NetStreamTimeTrait = null;
super.seekingChangeEnd(param1);
if(seeking == true && video != null)
{
_loc2_ = timeTrait as NetStreamTimeTrait;
if(_loc2_ != null && _loc2_.currentTime + _loc2_.audioDelay >= _loc2_.duration)
{
video.clear();
}
}
}
private function onMetaData(param1:Object) : void
{
audioDelay = param1.hasOwnProperty("audiodelay") ? param1.audiodelay : 0;
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Seek.Notify":
runSeekBugTimer();
break;
case "NetStream.Seek.InvalidTime":
case "NetStream.Seek.Failed":
setSeeking(false,previousTime);
break;
case "NetStream.Play.Start":
case "NetStream.Play.Reset":
case "NetStream.Pause.Notify":
case "NetStream.Play.Stop":
case "NetStream.Unpause.Notify":
if(seeking && seekBugTimer.running == false)
{
runSeekBugTimer();
}
}
}
private function runSeekBugTimer() : void
{
if(suppressSeekNotifyEvent == false)
{
seekBugTimer.start();
}
else
{
suppressSeekNotifyEvent = false;
}
}
private function onSeekBugTimer(param1:TimerEvent) : void
{
if(previousTime != netStream.time - audioDelay || previousTime == expectedTime)
{
onSeekBugTimerDone(null);
}
}
private function onSeekBugTimerDone(param1:TimerEvent) : void
{
seekBugTimer.reset();
setSeeking(false,expectedTime);
}
}
}
@@ -0,0 +1,318 @@
package org.osmf.net
{
import flash.errors.IllegalOperationError;
import flash.events.NetStatusEvent;
import flash.events.TimerEvent;
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.NetStreamPlayOptions;
import flash.utils.Dictionary;
import flash.utils.Timer;
import flash.utils.getTimer;
import org.osmf.utils.OSMFStrings;
public class NetStreamSwitchManager extends NetStreamSwitchManagerBase
{
private static const RULE_CHECK_INTERVAL:Number = 500;
private static const DEFAULT_MAX_UP_SWITCHES_PER_STREAM_ITEM:int = 3;
private static const DEFAULT_WAIT_DURATION_AFTER_DOWN_SWITCH:int = 30000;
private static const DEFAULT_CLEAR_FAILED_COUNTS_INTERVAL:Number = 300000;
private var netStream:NetStream;
private var dsResource:DynamicStreamingResource;
private var switchingRules:Vector.<SwitchingRuleBase>;
private var metrics:NetStreamMetricsBase;
private var checkRulesTimer:Timer;
private var clearFailedCountsTimer:Timer;
private var actualIndex:int = -1;
private var oldStreamName:String;
private var switching:Boolean;
private var _currentIndex:int;
private var lastTransitionIndex:int = -1;
private var connection:NetConnection;
private var dsiFailedCounts:Vector.<int>;
private var failedDSI:Dictionary;
private var _bandwidthLimit:Number = 0;
public function NetStreamSwitchManager(param1:NetConnection, param2:NetStream, param3:DynamicStreamingResource, param4:NetStreamMetricsBase, param5:Vector.<SwitchingRuleBase>)
{
super();
this.connection = param1;
this.netStream = param2;
this.dsResource = param3;
this.metrics = param4;
this.switchingRules = param5 || new Vector.<SwitchingRuleBase>();
_currentIndex = Math.max(0,Math.min(maxAllowedIndex,dsResource.initialIndex));
checkRulesTimer = new Timer(500);
checkRulesTimer.addEventListener("timer",checkRules);
failedDSI = new Dictionary();
_bandwidthLimit = 1.4 * param3.streamItems[param3.streamItems.length - 1].bitrate * 1000 / 8;
param2.addEventListener("netStatus",onNetStatus);
NetClient(param2.client).addHandler("onPlayStatus",onPlayStatus,2147483647);
}
override public function set autoSwitch(param1:Boolean) : void
{
super.autoSwitch = param1;
if(autoSwitch)
{
checkRulesTimer.start();
}
else
{
checkRulesTimer.stop();
}
}
override public function get currentIndex() : uint
{
return _currentIndex;
}
override public function get maxAllowedIndex() : int
{
var _loc1_:int = dsResource.streamItems.length - 1;
return _loc1_ < super.maxAllowedIndex ? _loc1_ : super.maxAllowedIndex;
}
override public function set maxAllowedIndex(param1:int) : void
{
if(param1 > dsResource.streamItems.length)
{
throw new RangeError(OSMFStrings.getString("streamSwitchInvalidIndex"));
}
super.maxAllowedIndex = param1;
metrics.maxAllowedIndex = param1;
}
override public function switchTo(param1:int) : void
{
if(!autoSwitch)
{
if(param1 < 0 || param1 > maxAllowedIndex)
{
throw new RangeError(OSMFStrings.getString("streamSwitchInvalidIndex"));
}
if(actualIndex == -1)
{
prepareForSwitching();
}
executeSwitch(param1);
return;
}
throw new IllegalOperationError(OSMFStrings.getString("streamSwitchStreamNotInManualMode"));
}
protected function canAutoSwitchNow(param1:int) : Boolean
{
var _loc2_:int = 0;
if(dsiFailedCounts[param1] >= 1)
{
_loc2_ = getTimer();
if(_loc2_ - failedDSI[param1] < 30000)
{
return false;
}
}
else if(dsiFailedCounts[param1] > 3)
{
return false;
}
return true;
}
final protected function get bandwidthLimit() : Number
{
return _bandwidthLimit;
}
final protected function set bandwidthLimit(param1:Number) : void
{
_bandwidthLimit = param1;
}
private function executeSwitch(param1:int) : void
{
var _loc3_:NetStreamPlayOptions = new NetStreamPlayOptions();
var _loc2_:Object = NetStreamUtils.getPlayArgsForResource(dsResource);
_loc3_.start = _loc2_.start;
_loc3_.len = _loc2_.len;
_loc3_.streamName = dsResource.streamItems[param1].streamName;
var _loc4_:String = oldStreamName;
if(_loc4_ != null && _loc4_.indexOf("?") >= 0)
{
_loc3_.oldStreamName = _loc4_.substr(0,_loc4_.indexOf("?"));
}
else
{
_loc3_.oldStreamName = oldStreamName;
}
_loc3_.transition = "switch";
switching = true;
netStream.play2(_loc3_);
oldStreamName = dsResource.streamItems[param1].streamName;
if(param1 < actualIndex && autoSwitch)
{
incrementDSIFailedCount(actualIndex);
failedDSI[actualIndex] = getTimer();
}
}
private function checkRules(param1:TimerEvent) : void
{
var _loc2_:int = 0;
var _loc4_:int = 0;
if(switchingRules == null || switching)
{
return;
}
var _loc3_:int = 2147483647;
_loc2_ = 0;
while(_loc2_ < switchingRules.length)
{
_loc4_ = switchingRules[_loc2_].getNewIndex();
if(_loc4_ != -1 && _loc4_ < _loc3_)
{
_loc3_ = _loc4_;
}
_loc2_++;
}
if(_loc3_ != -1 && _loc3_ != 2147483647 && _loc3_ != actualIndex)
{
_loc3_ = Math.min(_loc3_,maxAllowedIndex);
}
if(_loc3_ != -1 && _loc3_ != 2147483647 && _loc3_ != actualIndex && !switching && _loc3_ <= maxAllowedIndex && canAutoSwitchNow(_loc3_))
{
executeSwitch(_loc3_);
}
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Play.Start":
if(actualIndex == -1)
{
prepareForSwitching();
}
else if(autoSwitch && checkRulesTimer.running == false)
{
checkRulesTimer.start();
}
break;
case "NetStream.Play.Transition":
switching = false;
actualIndex = dsResource.indexFromName(param1.info.details);
metrics.currentIndex = actualIndex;
lastTransitionIndex = actualIndex;
break;
case "NetStream.Play.Failed":
switching = false;
break;
case "NetStream.Seek.Notify":
switching = false;
if(lastTransitionIndex >= 0)
{
_currentIndex = lastTransitionIndex;
}
break;
case "NetStream.Play.Stop":
checkRulesTimer.stop();
}
}
private function onPlayStatus(param1:Object) : void
{
var _loc2_:* = param1.code;
if("NetStream.Play.TransitionComplete" === _loc2_)
{
if(lastTransitionIndex >= 0)
{
_currentIndex = lastTransitionIndex;
lastTransitionIndex = -1;
}
}
}
private function prepareForSwitching() : void
{
initDSIFailedCounts();
metrics.resource = dsResource;
actualIndex = 0;
lastTransitionIndex = -1;
if(dsResource.initialIndex >= 0 && dsResource.initialIndex < dsResource.streamItems.length)
{
actualIndex = dsResource.initialIndex;
}
if(autoSwitch)
{
checkRulesTimer.start();
}
setThrottleLimits(dsResource.streamItems.length - 1);
metrics.currentIndex = actualIndex;
}
private function initDSIFailedCounts() : void
{
var _loc1_:int = 0;
if(dsiFailedCounts != null)
{
dsiFailedCounts.length = 0;
dsiFailedCounts = null;
}
dsiFailedCounts = new Vector.<int>();
_loc1_ = 0;
while(_loc1_ < dsResource.streamItems.length)
{
dsiFailedCounts.push(0);
_loc1_++;
}
}
private function incrementDSIFailedCount(param1:int) : void
{
dsiFailedCounts[param1]++;
if(dsiFailedCounts[param1] > 3)
{
if(clearFailedCountsTimer == null)
{
clearFailedCountsTimer = new Timer(300000,1);
clearFailedCountsTimer.addEventListener("timer",clearFailedCounts);
}
clearFailedCountsTimer.start();
}
}
private function clearFailedCounts(param1:TimerEvent) : void
{
clearFailedCountsTimer.removeEventListener("timer",clearFailedCounts);
clearFailedCountsTimer = null;
initDSIFailedCounts();
}
private function setThrottleLimits(param1:int) : void
{
connection.call("setBandwidthLimit",null,_bandwidthLimit,_bandwidthLimit);
}
}
}
@@ -0,0 +1,49 @@
package org.osmf.net
{
import flash.events.EventDispatcher;
public class NetStreamSwitchManagerBase extends EventDispatcher
{
private var _autoSwitch:Boolean;
private var _maxAllowedIndex:int;
public function NetStreamSwitchManagerBase()
{
super();
_autoSwitch = true;
_maxAllowedIndex = 2147483647;
}
public function get autoSwitch() : Boolean
{
return _autoSwitch;
}
public function set autoSwitch(param1:Boolean) : void
{
_autoSwitch = param1;
}
public function get currentIndex() : uint
{
return 0;
}
public function get maxAllowedIndex() : int
{
return _maxAllowedIndex;
}
public function set maxAllowedIndex(param1:int) : void
{
_maxAllowedIndex = param1;
}
public function switchTo(param1:int) : void
{
}
}
}
@@ -0,0 +1,106 @@
package org.osmf.net
{
import flash.events.NetStatusEvent;
import flash.net.NetStream;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.TimeTrait;
public class NetStreamTimeTrait extends TimeTrait
{
private var durationOffset:Number = 0;
private var _audioDelay:Number = 0;
private var netStream:NetStream;
private var resource:MediaResourceBase;
private var multicast:Boolean = false;
public function NetStreamTimeTrait(param1:NetStream, param2:MediaResourceBase, param3:Number = NaN)
{
super();
this.netStream = param1;
NetClient(param1.client).addHandler("onMetaData",onMetaData);
NetClient(param1.client).addHandler("onPlayStatus",onPlayStatus);
param1.addEventListener("netStatus",onNetStatus,false,0,true);
this.resource = param2;
if(isNaN(param3) == false)
{
setDuration(param3);
}
var _loc4_:MulticastResource = param2 as MulticastResource;
if(_loc4_ != null && _loc4_.groupspec != null && _loc4_.groupspec.length > 0)
{
multicast = true;
setDuration(1.7976931348623157e+308);
}
}
override public function get currentTime() : Number
{
if(multicast)
{
return 0;
}
if(durationOffset == duration - (netStream.time - _audioDelay))
{
return netStream.time - _audioDelay + durationOffset;
}
return netStream.time - _audioDelay;
}
private function onMetaData(param1:Object) : void
{
var _loc2_:Object = NetStreamUtils.getPlayArgsForResource(resource);
_audioDelay = param1.hasOwnProperty("audiodelay") ? param1.audiodelay : 0;
var _loc3_:Number = Math.max(0,_loc2_.start);
var _loc4_:Number = Number(_loc2_.len);
if(_loc4_ == -1)
{
_loc4_ = 1.7976931348623157e+308;
}
setDuration(Math.min(param1.duration - _audioDelay - _loc3_,_loc4_));
}
private function onPlayStatus(param1:Object) : void
{
var _loc2_:* = param1.code;
if("NetStream.Play.Complete" === _loc2_)
{
signalComplete();
}
}
private function onNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Play.Stop":
if(NetStreamUtils.isStreamingResource(resource) == false)
{
signalComplete();
}
break;
case "NetStream.Play.UnpublishNotify":
signalComplete();
}
}
override protected function signalComplete() : void
{
if(netStream.time - _audioDelay != duration)
{
durationOffset = duration - (netStream.time - _audioDelay);
}
super.signalComplete();
}
internal function get audioDelay() : Number
{
return _audioDelay;
}
}
}
@@ -0,0 +1,132 @@
package org.osmf.net
{
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.utils.URL;
public class NetStreamUtils
{
public static const PLAY_START_ARG_ANY:int = -2;
public static const PLAY_START_ARG_LIVE:int = -1;
public static const PLAY_START_ARG_RECORDED:int = 0;
public static const PLAY_LEN_ARG_ALL:int = -1;
public function NetStreamUtils()
{
super();
}
public static function getStreamNameFromURL(param1:String, param2:Boolean = false) : String
{
var _loc3_:FMSURL = null;
var _loc4_:String = "";
if(param1 != null)
{
if(isRTMPStream(param1))
{
_loc3_ = new FMSURL(param1,param2);
_loc4_ = _loc3_.streamName;
if(_loc3_.query != null && _loc3_.query != "")
{
_loc4_ += "?" + _loc3_.query;
}
}
else
{
_loc4_ = param1;
}
}
return _loc4_;
}
public static function isStreamingResource(param1:MediaResourceBase) : Boolean
{
var _loc3_:URLResource = null;
var _loc2_:Boolean = false;
if(param1 != null)
{
_loc3_ = param1 as URLResource;
if(_loc3_ != null)
{
_loc2_ = Boolean(NetStreamUtils.isRTMPStream(_loc3_.url));
if(_loc2_ == false)
{
_loc2_ = _loc3_.getMetadataValue("http://www.osmf.org/httpstreaming/1.0") != null;
}
}
}
return _loc2_;
}
public static function isRTMPStream(param1:String) : Boolean
{
var _loc4_:URL = null;
var _loc3_:String = null;
var _loc2_:Boolean = false;
if(param1 != null)
{
_loc4_ = new URL(param1);
_loc3_ = _loc4_.protocol;
if(_loc3_ != null && _loc3_.length > 0)
{
_loc2_ = _loc3_.search(/^rtmp$|rtmp[tse]$|rtmpte$/i) != -1;
}
}
return _loc2_;
}
public static function getStreamType(param1:MediaResourceBase) : String
{
var _loc2_:String = "recorded";
var _loc3_:StreamingURLResource = param1 as StreamingURLResource;
if(_loc3_ != null)
{
_loc2_ = _loc3_.streamType;
}
return _loc2_;
}
public static function getPlayArgsForResource(param1:MediaResourceBase) : Object
{
var _loc2_:StreamingURLResource = null;
var _loc3_:Number = -2;
var _loc4_:Number = -1;
switch(getStreamType(param1))
{
case "liveOrRecorded":
_loc3_ = -2;
break;
case "live":
_loc3_ = -1;
break;
case "recorded":
_loc3_ = PLAY_START_ARG_RECORDED;
}
if(_loc3_ != -1 && param1 != null)
{
_loc2_ = param1 as StreamingURLResource;
if(_loc2_ != null && isStreamingResource(_loc2_))
{
if(!isNaN(_loc2_.clipStartTime))
{
_loc3_ = _loc2_.clipStartTime;
}
if(!isNaN(_loc2_.clipEndTime))
{
_loc3_ = Math.max(0,_loc3_);
_loc4_ = Math.max(0,_loc2_.clipEndTime - _loc3_);
}
}
}
return {
"start":_loc3_,
"len":_loc4_
};
}
}
}
@@ -0,0 +1,36 @@
package org.osmf.net
{
public class PortProtocol
{
private var _port:int;
private var _protocol:String;
public function PortProtocol()
{
super();
}
public function get port() : int
{
return _port;
}
public function set port(param1:int) : void
{
_port = param1;
}
public function get protocol() : String
{
return _protocol;
}
public function set protocol(param1:String) : void
{
_protocol = param1;
}
}
}
@@ -0,0 +1,20 @@
package org.osmf.net
{
public final class StreamType
{
public static const LIVE:String = "live";
public static const RECORDED:String = "recorded";
public static const LIVE_OR_RECORDED:String = "liveOrRecorded";
public static const DVR:String = "dvr";
public function StreamType()
{
super();
}
}
}
@@ -0,0 +1,93 @@
package org.osmf.net
{
import flash.utils.ByteArray;
import org.osmf.media.URLResource;
public class StreamingURLResource extends URLResource
{
private var _streamType:String;
private var _clipStartTime:Number;
private var _clipEndTime:Number;
private var _connectionArguments:Vector.<Object>;
private var _drmContentData:ByteArray;
private var _urlIncludesFMSApplicationInstance:Boolean = false;
public function StreamingURLResource(param1:String, param2:String = null, param3:Number = NaN, param4:Number = NaN, param5:Vector.<Object> = null, param6:Boolean = false, param7:ByteArray = null)
{
_streamType = param2 || "recorded";
_clipStartTime = param3;
_clipEndTime = param4;
_urlIncludesFMSApplicationInstance = param6;
_drmContentData = param7;
_connectionArguments = param5;
super(param1);
}
public function get streamType() : String
{
return _streamType;
}
public function set streamType(param1:String) : void
{
_streamType = param1;
}
public function get clipStartTime() : Number
{
return _clipStartTime;
}
public function set clipStartTime(param1:Number) : void
{
_clipStartTime = param1;
}
public function get clipEndTime() : Number
{
return _clipEndTime;
}
public function set clipEndTime(param1:Number) : void
{
_clipEndTime = param1;
}
public function get connectionArguments() : Vector.<Object>
{
return _connectionArguments;
}
public function set connectionArguments(param1:Vector.<Object>) : void
{
_connectionArguments = param1;
}
public function get drmContentData() : ByteArray
{
return _drmContentData;
}
public function set drmContentData(param1:ByteArray) : void
{
_drmContentData = param1;
}
public function get urlIncludesFMSApplicationInstance() : Boolean
{
return _urlIncludesFMSApplicationInstance;
}
public function set urlIncludesFMSApplicationInstance(param1:Boolean) : void
{
_urlIncludesFMSApplicationInstance = param1;
}
}
}
@@ -0,0 +1,25 @@
package org.osmf.net
{
public class SwitchingRuleBase
{
private var _metrics:NetStreamMetricsBase;
public function SwitchingRuleBase(param1:NetStreamMetricsBase)
{
super();
_metrics = param1;
}
public function getNewIndex() : int
{
return -1;
}
protected function get metrics() : NetStreamMetricsBase
{
return _metrics;
}
}
}
@@ -0,0 +1,289 @@
package org.osmf.net.drm
{
import flash.errors.IllegalOperationError;
import flash.events.DRMAuthenticationCompleteEvent;
import flash.events.DRMAuthenticationErrorEvent;
import flash.events.DRMErrorEvent;
import flash.events.DRMStatusEvent;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.net.drm.DRMContentData;
import flash.net.drm.DRMManager;
import flash.net.drm.DRMVoucher;
import flash.system.SystemUpdater;
import flash.utils.ByteArray;
import org.osmf.events.DRMEvent;
import org.osmf.events.MediaError;
import org.osmf.utils.OSMFStrings;
internal class DRMServices extends EventDispatcher
{
private static const DRM_AUTHENTICATION_FAILED:int = 3301;
private static const DRM_NEEDS_AUTHENTICATION:int = 3330;
private static const DRM_CONTENT_NOT_YET_VALID:int = 3331;
private static var updater:SystemUpdater;
private var _drmState:String = "uninitialized";
private var lastToken:ByteArray;
private var drmContentData:DRMContentData;
private var voucher:DRMVoucher;
private var drmManager:DRMManager;
public function DRMServices()
{
super();
drmManager = DRMManager.getDRMManager();
}
public function get drmState() : String
{
return _drmState;
}
public function set drmMetadata(param1:Object) : void
{
var onComplete:*;
var value:Object = param1;
lastToken = null;
if(value is DRMContentData)
{
drmContentData = value as DRMContentData;
retrieveVoucher();
}
else
{
try
{
drmContentData = new DRMContentData(value as ByteArray);
retrieveVoucher();
}
catch(argError:ArgumentError)
{
updateDRMState("authenticationError",new MediaError(argError.errorID,"DRMContentData invalid"));
}
catch(error:IllegalOperationError)
{
onComplete = function(param1:Event):void
{
updater.removeEventListener("complete",onComplete);
drmMetadata = value;
};
update("drm");
updater.addEventListener("complete",onComplete);
}
}
}
public function get drmMetadata() : Object
{
return drmContentData;
}
public function authenticate(param1:String = null, param2:String = null) : void
{
if(drmContentData == null)
{
throw new IllegalOperationError(OSMFStrings.getString("drmMetadataNotSet"));
}
drmManager.addEventListener("authenticationError",authError);
drmManager.addEventListener("authenticationComplete",authComplete);
if(param2 == null && param1 == null)
{
retrieveVoucher();
}
else
{
drmManager.authenticate(drmContentData.serverURL,drmContentData.domain,param1,param2);
}
}
public function authenticateWithToken(param1:Object) : void
{
if(drmContentData == null)
{
throw new IllegalOperationError(OSMFStrings.getString("drmMetadataNotSet"));
}
drmManager.setAuthenticationToken(drmContentData.serverURL,drmContentData.domain,param1 as ByteArray);
retrieveVoucher();
}
public function get startDate() : Date
{
if(voucher != null)
{
return voucher.playbackTimeWindow ? voucher.playbackTimeWindow.startDate : voucher.voucherStartDate;
}
return null;
}
public function get endDate() : Date
{
if(voucher != null)
{
return voucher.playbackTimeWindow ? voucher.playbackTimeWindow.endDate : voucher.voucherEndDate;
}
return null;
}
public function get period() : Number
{
if(voucher != null)
{
return voucher.playbackTimeWindow ? voucher.playbackTimeWindow.period : (voucher.voucherEndDate && voucher.voucherStartDate ? (voucher.voucherEndDate.time - voucher.voucherStartDate.time) / 1000 : 0);
}
return NaN;
}
public function inlineDRMFailed(param1:MediaError) : void
{
updateDRMState("authenticationError",param1);
}
public function inlineOnVoucher(param1:DRMStatusEvent) : void
{
drmContentData = param1.contentData;
onVoucherLoaded(param1);
}
public function update(param1:String) : SystemUpdater
{
updateDRMState("drmSystemUpdating");
if(updater == null)
{
updater = new SystemUpdater();
toggleErrorListeners(updater,true);
updater.update(param1);
}
else
{
toggleErrorListeners(updater,true);
}
return updater;
}
private function retrieveVoucher() : void
{
updateDRMState("authenticating");
drmManager.addEventListener("drmError",onDRMError);
drmManager.addEventListener("drmStatus",onVoucherLoaded);
drmManager.loadVoucher(drmContentData,"allowServer");
}
private function onVoucherLoaded(param1:DRMStatusEvent) : void
{
var _loc2_:Date = null;
if(param1.contentData == drmContentData)
{
_loc2_ = new Date();
if(param1.voucher && ((param1.voucher.voucherEndDate == null || param1.voucher.voucherEndDate.time >= _loc2_.time) && (param1.voucher.voucherStartDate == null || param1.voucher.voucherStartDate.time <= _loc2_.time)))
{
this.voucher = param1.voucher;
removeEventListeners();
if(voucher.playbackTimeWindow == null)
{
updateDRMState("authenticationComplete",null,voucher.voucherStartDate,voucher.voucherEndDate,period,lastToken);
}
else
{
updateDRMState("authenticationComplete",null,voucher.playbackTimeWindow.startDate,voucher.playbackTimeWindow.endDate,voucher.playbackTimeWindow.period,lastToken);
}
}
else
{
forceRefreshVoucher();
}
}
}
private function forceRefreshVoucher() : void
{
drmManager.loadVoucher(drmContentData,"forceRefresh");
}
private function onDRMError(param1:DRMErrorEvent) : void
{
if(param1.contentData == drmContentData)
{
switch(param1.errorID - 3330)
{
case 0:
updateDRMState("authenticationNeeded",null,null,null,0,null,param1.contentData.serverURL);
break;
case 1:
forceRefreshVoucher();
break;
default:
removeEventListeners();
updateDRMState("authenticationError",new MediaError(param1.errorID,param1.text));
}
}
}
private function removeEventListeners() : void
{
drmManager.removeEventListener("drmError",onDRMError);
drmManager.removeEventListener("drmStatus",onVoucherLoaded);
}
private function authComplete(param1:DRMAuthenticationCompleteEvent) : void
{
drmManager.removeEventListener("authenticationError",authError);
drmManager.removeEventListener("authenticationComplete",authComplete);
lastToken = param1.token;
retrieveVoucher();
}
private function authError(param1:DRMAuthenticationErrorEvent) : void
{
drmManager.removeEventListener("authenticationError",authError);
drmManager.removeEventListener("authenticationComplete",authComplete);
updateDRMState("authenticationError",new MediaError(param1.errorID,param1.toString()));
}
private function toggleErrorListeners(param1:SystemUpdater, param2:Boolean) : void
{
if(param2)
{
param1.addEventListener("complete",onUpdateComplete);
param1.addEventListener("cancel",onUpdateComplete);
param1.addEventListener("ioError",onUpdateError);
param1.addEventListener("securityError",onUpdateError);
param1.addEventListener("status",onUpdateError);
}
else
{
param1.removeEventListener("complete",onUpdateComplete);
param1.removeEventListener("cancel",onUpdateComplete);
param1.removeEventListener("ioError",onUpdateError);
param1.removeEventListener("securityError",onUpdateError);
param1.removeEventListener("status",onUpdateError);
}
}
private function onUpdateComplete(param1:Event) : void
{
toggleErrorListeners(updater,false);
}
private function onUpdateError(param1:Event) : void
{
toggleErrorListeners(updater,false);
updateDRMState("authenticationError",new MediaError(19,param1.toString()));
}
private function updateDRMState(param1:String, param2:MediaError = null, param3:Date = null, param4:Date = null, param5:Number = 0, param6:Object = null, param7:String = null) : void
{
_drmState = param1;
dispatchEvent(new DRMEvent("drmStateChange",param1,false,false,param3,param4,param5,param7,param6,param2));
}
}
}
@@ -0,0 +1,68 @@
package org.osmf.net.drm
{
import flash.events.DRMStatusEvent;
import flash.system.SystemUpdater;
import org.osmf.events.DRMEvent;
import org.osmf.events.MediaError;
import org.osmf.traits.DRMTrait;
public class NetStreamDRMTrait extends DRMTrait
{
private var drmServices:DRMServices = new DRMServices();
public function NetStreamDRMTrait()
{
super();
drmServices.addEventListener("drmStateChange",onStateChange);
}
public function set drmMetadata(param1:Object) : void
{
if(param1 != drmServices.drmMetadata)
{
drmServices.drmMetadata = param1;
}
}
public function get drmMetadata() : Object
{
return drmServices.drmMetadata;
}
public function update(param1:String) : SystemUpdater
{
return drmServices.update(param1);
}
override public function authenticate(param1:String = null, param2:String = null) : void
{
drmServices.authenticate(param1,param2);
}
override public function authenticateWithToken(param1:Object) : void
{
drmServices.authenticateWithToken(param1);
}
public function inlineDRMFailed(param1:MediaError) : void
{
drmServices.inlineDRMFailed(param1);
}
public function inlineOnVoucher(param1:DRMStatusEvent) : void
{
drmServices.inlineOnVoucher(param1);
}
private function onStateChange(param1:DRMEvent) : void
{
setPeriod(param1.period);
setStartDate(param1.startDate);
setEndDate(param1.endDate);
setDrmState(param1.drmState);
dispatchEvent(new DRMEvent("drmStateChange",drmState,false,false,startDate,endDate,period,param1.serverURL,param1.token,param1.mediaError));
}
}
}
@@ -0,0 +1,32 @@
package org.osmf.net.dvr
{
public class DVRCastConstants
{
public static const RPC_GET_STREAM_INFO:String = "DVRGetStreamInfo";
public static const RPC_SUBSCRIBE:String = "DVRSubscribe";
public static const RPC_UNSUBSCRIBE:String = "DVRUnsubscribe";
public static const RESULT_GET_STREAM_INFO_SUCCESS:String = "NetStream.DVRStreamInfo.Success";
public static const RESULT_GET_STREAM_INFO_RETRY:String = "NetStream.DVRStreamInfo.Retry";
public static const STREAM_INFO_KEY:String = "http://www.osmf.org/dvrCast/1.0/streamInfo";
public static const RECORDING_INFO_KEY:String = "http://www.osmf.org/dvrCast/1.0/recordingInfo";
public static const STREAM_INFO_UPDATE_DELAY:Number = 3000;
public static const LOCAL_DURATION_UPDATE_INTERVAL:Number = 500;
public static const LIVE_POSITION_SEEK_DELAY:Number = 1.5;
public function DVRCastConstants()
{
super();
}
}
}
@@ -0,0 +1,84 @@
package org.osmf.net.dvr
{
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.TimerEvent;
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.utils.Timer;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.DVRTrait;
import org.osmf.utils.OSMFStrings;
internal class DVRCastDVRTrait extends DVRTrait
{
private var connection:NetConnection;
private var stream:NetStream;
private var streamInfo:DVRCastStreamInfo;
private var recordingInfo:DVRCastRecordingInfo;
private var streamInfoUpdateTimer:Timer;
private var streamInfoRetriever:DVRCastStreamInfoRetriever;
private var offset:Number;
public function DVRCastDVRTrait(param1:NetConnection, param2:NetStream, param3:MediaResourceBase)
{
if(param1 != null && param2 != null)
{
this.stream = param2;
streamInfo = param3.getMetadataValue("http://www.osmf.org/dvrCast/1.0/streamInfo") as DVRCastStreamInfo;
recordingInfo = param3.getMetadataValue("http://www.osmf.org/dvrCast/1.0/recordingInfo") as DVRCastRecordingInfo;
streamInfoRetriever = new DVRCastStreamInfoRetriever(param1,streamInfo.streamName);
streamInfoRetriever.addEventListener("complete",onStreamInfoRetrieverComplete);
streamInfoUpdateTimer = new Timer(3000);
streamInfoUpdateTimer.addEventListener("timer",onStreamInfoUpdateTimer);
streamInfoUpdateTimer.start();
super(streamInfo.isRecording);
updateProperties();
return;
}
throw new IllegalOperationError(OSMFStrings.getString("nullParam"));
}
override protected function isRecordingChangeStart(param1:Boolean) : void
{
if(param1)
{
recordingInfo.startDuration = streamInfo.currentLength;
recordingInfo.startTime = new Date();
}
}
private function updateProperties() : void
{
setIsRecording(streamInfo.isRecording);
}
private function onStreamInfoUpdateTimer(param1:TimerEvent) : void
{
streamInfoRetriever.retrieve();
}
private function onStreamInfoRetrieverComplete(param1:Event) : void
{
if(streamInfoRetriever.streamInfo != null)
{
streamInfo.readFromDVRCastStreamInfo(streamInfoRetriever.streamInfo);
updateProperties();
}
else
{
dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(22)));
}
}
}
}
@@ -0,0 +1,151 @@
package org.osmf.net.dvr
{
import flash.events.Event;
import flash.net.NetConnection;
import flash.net.Responder;
import flash.utils.Dictionary;
import org.osmf.events.MediaError;
import org.osmf.events.NetConnectionFactoryEvent;
import org.osmf.media.URLResource;
import org.osmf.net.DynamicStreamingItem;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.NetConnectionFactory;
import org.osmf.net.NetConnectionFactoryBase;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.StreamingURLResource;
public class DVRCastNetConnectionFactory extends NetConnectionFactoryBase
{
private var innerFactory:NetConnectionFactoryBase;
private var subscribedStreams:Dictionary = new Dictionary();
public function DVRCastNetConnectionFactory(param1:NetConnectionFactoryBase = null)
{
innerFactory = param1 || new NetConnectionFactory();
innerFactory.addEventListener("creationComplete",onCreationComplete);
innerFactory.addEventListener("creationError",onCreationError);
super();
}
override public function create(param1:URLResource) : void
{
innerFactory.create(param1);
}
override public function closeNetConnection(param1:NetConnection) : void
{
var _loc2_:String = subscribedStreams[param1];
if(_loc2_ != null)
{
param1.call("DVRUnsubscribe",null,_loc2_);
delete subscribedStreams[param1];
}
innerFactory.closeNetConnection(param1);
}
private function onCreationComplete(param1:NetConnectionFactoryEvent) : void
{
var streamingResource:StreamingURLResource;
var urlIncludesFMSApplicationInstance:Boolean;
var dynamicResource:DynamicStreamingResource;
var items:Vector.<DynamicStreamingItem>;
var i:int;
var responder:Responder;
var event:NetConnectionFactoryEvent = param1;
var onStreamSubscriptionResult:* = function(param1:Object):void
{
var _loc2_:DVRCastStreamInfoRetriever = null;
totalRpcSubscribeInvocation = totalRpcSubscribeInvocation - 1;
if(totalRpcSubscribeInvocation <= 0)
{
_loc2_ = new DVRCastStreamInfoRetriever(netConnection,streamNames[0]);
_loc2_.addEventListener("complete",onStreamInfoRetrieverComplete);
_loc2_.retrieve();
}
};
var onStreamInfoRetrieverComplete:* = function(param1:Event):void
{
var _loc2_:DVRCastRecordingInfo = null;
var _loc3_:DVRCastStreamInfoRetriever = param1.target as DVRCastStreamInfoRetriever;
removeEventListener("creationComplete",onCreationComplete);
if(_loc3_.streamInfo != null)
{
if(_loc3_.streamInfo.offline == true)
{
dispatchEvent(new NetConnectionFactoryEvent("creationError",false,false,netConnection,urlResource,new MediaError(21)));
i = 0;
while(i < streamNames.length)
{
netConnection.call("DVRUnsubscribe",null,streamNames[i]);
i = i + 1;
}
netConnection = null;
}
else
{
_loc2_ = new DVRCastRecordingInfo();
_loc2_.startDuration = _loc3_.streamInfo.currentLength;
_loc2_.startOffset = calculateOffset(_loc3_.streamInfo);
_loc2_.startTime = new Date();
streamingResource.addMetadataValue("http://www.osmf.org/dvrCast/1.0/streamInfo",_loc3_.streamInfo);
streamingResource.addMetadataValue("http://www.osmf.org/dvrCast/1.0/recordingInfo",_loc2_);
subscribedStreams[netConnection] = streamNames[0];
dispatchEvent(new NetConnectionFactoryEvent("creationComplete",false,false,netConnection,urlResource));
}
}
else
{
onServerCallError(_loc3_.error);
}
};
var onServerCallError:* = function(param1:Object):void
{
dispatchEvent(new NetConnectionFactoryEvent("creationError",false,false,netConnection,urlResource,new MediaError(20,param1 ? param1.message : "")));
};
var urlResource:URLResource = event.resource as URLResource;
var netConnection:NetConnection = event.netConnection;
var streamNames:Vector.<String> = new Vector.<String>();
var totalRpcSubscribeInvocation:int = 0;
event.stopImmediatePropagation();
streamingResource = urlResource as StreamingURLResource;
urlIncludesFMSApplicationInstance = streamingResource ? streamingResource.urlIncludesFMSApplicationInstance : false;
dynamicResource = streamingResource as DynamicStreamingResource;
if(dynamicResource != null)
{
items = dynamicResource.streamItems;
totalRpcSubscribeInvocation = int(items.length);
i = 0;
while(i < items.length)
{
streamNames.push(items[i].streamName);
i = i + 1;
}
}
else
{
totalRpcSubscribeInvocation = 1;
streamNames.push(NetStreamUtils.getStreamNameFromURL(urlResource.url,urlIncludesFMSApplicationInstance));
}
responder = new TestableResponder(onStreamSubscriptionResult,onServerCallError);
i = 0;
while(i < streamNames.length)
{
event.netConnection.call("DVRSubscribe",responder,streamNames[i]);
i = i + 1;
}
}
private function onCreationError(param1:NetConnectionFactoryEvent) : void
{
dispatchEvent(param1.clone());
}
private function calculateOffset(param1:DVRCastStreamInfo) : Number
{
return DVRUtils.calculateOffset(param1.beginOffset,param1.endOffset,param1.currentLength);
}
}
}
@@ -0,0 +1,52 @@
package org.osmf.net.dvr
{
import flash.net.NetConnection;
import flash.net.NetStream;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.net.NetStreamLoadTrait;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.StreamingURLResource;
import org.osmf.net.rtmpstreaming.RTMPDynamicStreamingNetLoader;
public class DVRCastNetLoader extends RTMPDynamicStreamingNetLoader
{
public function DVRCastNetLoader(param1:DVRCastNetConnectionFactory = null)
{
if(param1 == null)
{
param1 = new DVRCastNetConnectionFactory();
}
super(param1);
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc2_:Boolean = false;
var _loc3_:StreamingURLResource = null;
if(super.canHandleResource(param1))
{
_loc3_ = param1 as StreamingURLResource;
if(_loc3_ != null)
{
_loc2_ = _loc3_.streamType == "dvr" && NetStreamUtils.isRTMPStream(_loc3_.url);
}
}
return _loc2_;
}
override protected function createNetStream(param1:NetConnection, param2:URLResource) : NetStream
{
return new DVRCastNetStream(param1,param2);
}
override protected function processFinishLoading(param1:NetStreamLoadTrait) : void
{
param1.setTrait(new DVRCastDVRTrait(param1.connection,param1.netStream,param1.resource));
param1.setTrait(new DVRCastTimeTrait(param1.connection,param1.netStream,param1.resource));
updateLoadTrait(param1,"ready");
}
}
}
@@ -0,0 +1,35 @@
package org.osmf.net.dvr
{
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.NetStreamPlayOptions;
import org.osmf.media.MediaResourceBase;
public class DVRCastNetStream extends NetStream
{
private var recordingInfo:DVRCastRecordingInfo;
public function DVRCastNetStream(param1:NetConnection, param2:MediaResourceBase)
{
super(param1);
recordingInfo = param2.getMetadataValue("http://www.osmf.org/dvrCast/1.0/recordingInfo") as DVRCastRecordingInfo;
}
override public function play(... rest) : void
{
super.play(rest[0],recordingInfo.startOffset,-1);
}
override public function play2(param1:NetStreamPlayOptions) : void
{
if(param1)
{
param1.start = recordingInfo.startOffset;
param1.len = -1;
}
super.play2(param1);
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.net.dvr
{
public class DVRCastRecordingInfo
{
public var startTime:Date = null;
public var startDuration:Number;
public var startOffset:Number;
public function DVRCastRecordingInfo()
{
super();
}
}
}
@@ -0,0 +1,87 @@
package org.osmf.net.dvr
{
import flash.errors.IllegalOperationError;
import org.osmf.utils.OSMFStrings;
public class DVRCastStreamInfo
{
public var callTime:Date;
public var offline:Boolean;
public var beginOffset:Number;
public var endOffset:Number;
public var recordingStart:Date;
public var recordingEnd:Date;
public var isRecording:Boolean;
public var streamName:String;
public var lastUpdate:Date;
public var currentLength:Number;
public var maxLength:Number;
public function DVRCastStreamInfo(param1:Object)
{
super();
readFromDynamicObject(param1);
}
public function readFromDynamicObject(param1:Object) : void
{
try
{
callTime = param1.callTime;
offline = param1.offline;
beginOffset = param1.begOffset;
endOffset = param1.endOffset;
recordingStart = param1.startRec;
recordingEnd = param1.stopRec;
isRecording = param1.isRec;
streamName = param1.streamName;
lastUpdate = param1.lastUpdate;
currentLength = param1.currLen;
maxLength = param1.maxLen;
}
catch(e:Error)
{
throw new IllegalOperationError(OSMFStrings.getString("invalidParam"));
}
}
public function readFromDVRCastStreamInfo(param1:DVRCastStreamInfo) : void
{
try
{
callTime = param1.callTime;
offline = param1.offline;
beginOffset = param1.beginOffset;
endOffset = param1.endOffset;
recordingStart = param1.recordingStart;
recordingEnd = param1.recordingEnd;
isRecording = param1.isRecording;
streamName = param1.streamName;
lastUpdate = param1.lastUpdate;
currentLength = param1.currentLength;
maxLength = param1.maxLength;
}
catch(e:Error)
{
throw new IllegalOperationError(OSMFStrings.getString("invalidParam"));
}
}
public function toString() : String
{
return "callTime: " + callTime + "\noffline: " + offline + "\nbeginOffset: " + beginOffset + "\nendOffset: " + endOffset + "\nrecordingStart: " + recordingStart + "\nrecordingEnd: " + recordingEnd + "\nisRecording: " + isRecording + "\nstreamName: " + streamName + "\nlastUpdate: " + lastUpdate + "\ncurrentLength: " + currentLength + "\nmaxLength: " + maxLength;
}
}
}
@@ -0,0 +1,118 @@
package org.osmf.net.dvr
{
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.TimerEvent;
import flash.net.NetConnection;
import flash.net.Responder;
import flash.utils.Timer;
import org.osmf.utils.OSMFStrings;
internal class DVRCastStreamInfoRetriever extends EventDispatcher
{
private var connection:NetConnection;
private var streamName:String;
private var retries:Number;
private var timer:Timer;
private var _streamInfo:DVRCastStreamInfo;
private var _error:Object;
public function DVRCastStreamInfoRetriever(param1:NetConnection, param2:String)
{
super();
if(param1 == null || param2 == null)
{
throw new IllegalOperationError(OSMFStrings.getString("nullParam"));
}
this.connection = param1;
this.streamName = param2;
}
public function get streamInfo() : DVRCastStreamInfo
{
return _streamInfo;
}
public function get error() : Object
{
return _error;
}
public function retrieve(param1:int = 5, param2:Number = 3) : void
{
if(isNaN(this.retries))
{
if(!param1)
{
param1 = 1;
}
_streamInfo = null;
_error = _error = {"message":OSMFStrings.getString("dvrMaximumRPCAttempts").replace("%i",param1)};
this.retries = param1;
timer = new Timer(param2 * 1000,1);
getStreamInfo();
}
}
private function getStreamInfo() : void
{
var _loc1_:Responder = new TestableResponder(onGetStreamInfoResult,onServerCallError);
retries = retries - 1;
connection.call("DVRGetStreamInfo",_loc1_,streamName);
}
private function onGetStreamInfoResult(param1:Object) : void
{
if(param1 && param1.code == "NetStream.DVRStreamInfo.Success")
{
_error = null;
_streamInfo = new DVRCastStreamInfo(param1.data);
complete();
}
else if(param1 && param1.code == "NetStream.DVRStreamInfo.Retry")
{
if(retries != 0)
{
timer.addEventListener("timerComplete",onTimerComplete);
timer.start();
}
else
{
complete();
}
}
else
{
_error = {"message":OSMFStrings.getString("dvrUnexpectedServerResponse") + param1.code};
complete();
}
}
private function onServerCallError(param1:Object) : void
{
_error = param1;
complete();
}
private function onTimerComplete(param1:TimerEvent) : void
{
timer.removeEventListener("timerComplete",onTimerComplete);
getStreamInfo();
}
private function complete() : void
{
retries = NaN;
timer = null;
dispatchEvent(new Event("complete"));
}
}
}
@@ -0,0 +1,85 @@
package org.osmf.net.dvr
{
import flash.errors.IllegalOperationError;
import flash.events.NetStatusEvent;
import flash.events.TimerEvent;
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.utils.Timer;
import org.osmf.events.TimeEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.TimeTrait;
import org.osmf.utils.OSMFStrings;
internal class DVRCastTimeTrait extends TimeTrait
{
private var durationUpdateTimer:Timer;
private var oldDuration:Number;
private var stream:NetStream;
private var streamInfo:DVRCastStreamInfo;
private var recordingInfo:DVRCastRecordingInfo;
public function DVRCastTimeTrait(param1:NetConnection, param2:NetStream, param3:MediaResourceBase)
{
super(NaN);
if(param1 == null || param2 == null)
{
throw new IllegalOperationError(OSMFStrings.getString("nullParam"));
}
this.stream = param2;
param2.addEventListener("netStatus",onNetStatus);
durationUpdateTimer = new Timer(500);
durationUpdateTimer.addEventListener("timer",onDurationUpdateTimer);
durationUpdateTimer.start();
streamInfo = param3.getMetadataValue("http://www.osmf.org/dvrCast/1.0/streamInfo") as DVRCastStreamInfo;
recordingInfo = param3.getMetadataValue("http://www.osmf.org/dvrCast/1.0/recordingInfo") as DVRCastRecordingInfo;
}
override public function get duration() : Number
{
var _loc1_:Number = NaN;
if(streamInfo.isRecording)
{
_loc1_ = recordingInfo.startDuration - recordingInfo.startOffset + (new Date().time - recordingInfo.startTime.time) / 1000;
}
else
{
_loc1_ = streamInfo.currentLength - recordingInfo.startOffset;
}
return isNaN(_loc1_) ? NaN : Math.max(0,_loc1_);
}
override public function get currentTime() : Number
{
return stream.time;
}
private function onDurationUpdateTimer(param1:TimerEvent) : void
{
var _loc2_:Number = duration;
if(_loc2_ != oldDuration)
{
oldDuration = _loc2_;
dispatchEvent(new TimeEvent("durationChange",false,false,_loc2_));
}
}
private function onNetStatus(param1:NetStatusEvent) : void
{
if(param1.info.code == "NetStream.Play.Stop")
{
if(durationUpdateTimer)
{
durationUpdateTimer.stop();
}
signalComplete();
}
}
}
}
@@ -0,0 +1,33 @@
package org.osmf.net.dvr
{
public class DVRUtils
{
public function DVRUtils()
{
super();
}
public static function calculateOffset(param1:Number, param2:Number, param3:Number) : Number
{
var _loc4_:Number = 0;
if(param2 != 0)
{
if(param3 > param2)
{
_loc4_ = param3 - param2;
}
else
{
_loc4_ = Math.min(param1,param3);
}
}
else if(param1 != 0)
{
_loc4_ = Math.min(param1,param3);
}
return _loc4_;
}
}
}
@@ -0,0 +1,30 @@
package org.osmf.net.dvr
{
import flash.net.Responder;
internal class TestableResponder extends Responder
{
private var _result:Function;
private var _status:Function;
public function TestableResponder(param1:Function, param2:Function = null)
{
_result = param1;
_status = param2;
super(param1,param2);
}
internal function get result() : Function
{
return _result;
}
internal function get status() : Function
{
return _status;
}
}
}
@@ -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_:int = -1;
if(httpMetrics.downloadRatio < 1)
{
if(httpMetrics.currentIndex > 0)
{
_loc2_ = getSwitchRatio(httpMetrics.currentIndex - 1);
if(httpMetrics.downloadRatio < _loc2_)
{
_loc1_ = 0;
}
else
{
_loc1_ = httpMetrics.currentIndex - 1;
}
}
}
else if(httpMetrics.currentIndex < httpMetrics.maxAllowedIndex)
{
_loc2_ = getSwitchRatio(httpMetrics.currentIndex + 1);
if(httpMetrics.downloadRatio >= _loc2_)
{
if(httpMetrics.downloadRatio > 100 || !aggressiveUpswitch)
{
_loc1_ = httpMetrics.currentIndex + 1;
}
else
{
while(++_loc1_ < httpMetrics.maxAllowedIndex + 1)
{
_loc2_ = getSwitchRatio(_loc1_);
if(httpMetrics.downloadRatio < _loc2_)
{
break;
}
}
_loc1_--;
}
}
}
return _loc1_;
}
private function getSwitchRatio(param1:int) : Number
{
return httpMetrics.getBitrateForIndex(param1) / 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);
httpNetStream = param1;
}
public function get downloadRatio() : Number
{
return 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)
{
_urlRequest = new URLRequest(HTTPStreamingUtils.normalizeURL(param1));
}
else
{
_urlRequest = null;
}
_quality = param2;
_truncateAt = param3;
_retryAfter = param4;
_unpublishNotify = param5;
}
public function get urlRequest() : URLRequest
{
return _urlRequest;
}
public function get retryAfter() : Number
{
return _retryAfter;
}
public function get unpublishNotify() : Boolean
{
return _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,93 @@
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.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;
public class HTTPStreamingNetLoader extends NetLoader
{
public function HTTPStreamingNetLoader()
{
super();
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
return param1.getMetadataValue("http://www.osmf.org/httpstreaming/1.0") 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_,getDefaultSwitchingRules(_loc4_));
}
return null;
}
override protected function processFinishLoading(param1:NetStreamLoadTrait) : void
{
var netStream:HTTPNetStream;
var loadTrait:NetStreamLoadTrait = param1;
var onDVRStreamInfo:* = function(param1:DVRStreamInfoEvent):void
{
netStream.removeEventListener("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,"ready");
};
var resource:URLResource = loadTrait.resource as URLResource;
if(!dvrMetadataPresent(resource))
{
updateLoadTrait(loadTrait,"ready");
return;
}
netStream = loadTrait.netStream as HTTPNetStream;
netStream.addEventListener("DVRStreamInfo",onDVRStreamInfo);
netStream.DVRGetStreamInfo(null);
}
private function dvrMetadataPresent(param1:URLResource) : Boolean
{
var _loc2_:Metadata = param1.getMetadataValue("http://www.osmf.org/dvr/1.0") 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,183 @@
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.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("bootstrap",_loc5_);
if(param3 != null && param3.length > 0)
{
_loc4_.addValue("serverBaseUrls",param3);
}
return _loc4_;
}
public static function createF4FIndexInfo(param1:URLResource) : HTTPStreamingF4FIndexInfo
{
var _loc2_:* = undefined;
var _loc6_:* = undefined;
var _loc4_:DVRInfo = null;
var _loc3_:HTTPStreamingF4FIndexInfo = null;
var _loc5_:Metadata = param1.getMetadataValue("http://www.osmf.org/httpstreaming/1.0") as Metadata;
var _loc7_:Metadata = param1.getMetadataValue("http://www.osmf.org/dvr/1.0") as Metadata;
if(_loc5_ != null)
{
_loc2_ = _loc5_.getValue("serverBaseUrls") as Vector.<String>;
_loc6_ = generateStreamInfos(param1);
_loc4_ = generateDVRInfo(_loc7_);
_loc3_ = new HTTPStreamingF4FIndexInfo(_loc2_ != null && _loc2_.length > 0 ? _loc2_[0] : null,_loc6_,_loc4_);
}
return _loc3_;
}
public static function normalizeURL(param1:String) : String
{
var _loc4_:String = null;
var _loc6_: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 _loc7_:Array = _loc4_.split("/");
var _loc5_:int = _loc7_.indexOf("..");
while(_loc5_ >= 0)
{
_loc7_.splice(_loc5_ - 1,2);
_loc5_ = _loc7_.indexOf("..");
}
_loc2_ = _loc3_;
if(_loc7_.length > 0)
{
_loc6_ = 0;
while(_loc6_ < _loc7_.length)
{
if(_loc6_ != 0)
{
_loc2_ += "/";
}
_loc2_ += _loc7_[_loc6_] as String;
_loc6_++;
}
}
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("dvrId") != null)
{
_loc2_.id = param1.getValue("dvrId") as String;
}
if(param1.getValue("beginOffset") != null)
{
_loc2_.beginOffset = param1.getValue("beginOffset") as uint;
}
if(param1.getValue("endOffset") != null)
{
_loc2_.endOffset = param1.getValue("endOffset") as uint;
}
if(param1.getValue("dvrOffline") != null)
{
_loc2_.offline = param1.getValue("dvrOffline") as Boolean;
}
return _loc2_;
}
private static function generateStreamInfos(param1:URLResource) : Vector.<HTTPStreamingF4FStreamInfo>
{
var _loc5_:Object = null;
var _loc8_:ByteArray = null;
var _loc11_:String = null;
var _loc10_:Vector.<HTTPStreamingF4FStreamInfo> = new Vector.<HTTPStreamingF4FStreamInfo>();
var _loc6_:Metadata = param1.getMetadataValue("http://www.osmf.org/drm/1.0") as Metadata;
var _loc9_:Metadata = param1.getMetadataValue("http://www.osmf.org/httpstreaming/1.0") as Metadata;
var _loc2_:ByteArray = null;
var _loc7_:BootstrapInfo = null;
var _loc4_:DynamicStreamingResource = param1 as DynamicStreamingResource;
if(_loc4_ != null)
{
for each(var _loc3_:DynamicStreamingItem in _loc4_.streamItems)
{
_loc2_ = null;
_loc7_ = null;
_loc5_ = null;
_loc8_ = null;
if(_loc6_ != null)
{
_loc2_ = _loc6_.getValue("DRMAdditionalHeader" + _loc3_.streamName) as ByteArray;
}
if(_loc9_ != null)
{
_loc7_ = _loc9_.getValue("bootstrap" + _loc3_.streamName) as BootstrapInfo;
_loc5_ = _loc9_.getValue("streamMetadata" + _loc3_.streamName);
_loc8_ = _loc9_.getValue("xmpMetadata" + _loc3_.streamName) as ByteArray;
}
_loc10_.push(new HTTPStreamingF4FStreamInfo(_loc7_,_loc3_.streamName,_loc3_.bitrate,_loc2_,_loc5_,_loc8_));
}
}
else
{
if(_loc6_ != null)
{
_loc2_ = _loc6_.getValue("DRMAdditionalHeader") as ByteArray;
}
if(_loc9_ != null)
{
_loc7_ = _loc9_.getValue("bootstrap") as BootstrapInfo;
_loc5_ = _loc9_.getValue("streamMetadata");
_loc8_ = _loc9_.getValue("xmpMetadata") as ByteArray;
}
_loc11_ = param1.url;
_loc10_.push(new HTTPStreamingF4FStreamInfo(_loc7_,_loc11_,NaN,_loc2_,_loc5_,_loc8_));
}
return _loc10_;
}
}
}
@@ -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)
{
_connection = param1;
_stream = param2;
_dvrInfo = param3;
_stream.addEventListener("DVRStreamInfo",onDVRStreamInfo);
super(param3.isRecording);
}
private function onDVRStreamInfo(param1:DVRStreamInfoEvent) : void
{
_dvrInfo = param1.info as DVRInfo;
setIsRecording(_dvrInfo == null ? false : _dvrInfo.isRecording);
}
}
}
@@ -0,0 +1,58 @@
package org.osmf.net.httpstreaming.dvr
{
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import org.osmf.events.DVRStreamInfoEvent;
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);
_connection = param1;
_stream = param2;
_dvrInfo = param3;
_stream.addEventListener("DVRStreamInfo",onDVRStreamInfo);
_stream.addEventListener("netStatus",onNetStatus);
}
override public function get duration() : Number
{
if(_dvrInfo == null)
{
return NaN;
}
return _dvrInfo.curLength;
}
override public function get currentTime() : Number
{
return _stream.time;
}
private function onDVRStreamInfo(param1:DVRStreamInfoEvent) : void
{
_dvrInfo = param1.info as DVRInfo;
setDuration(_dvrInfo.curLength);
}
private function onNetStatus(param1:NetStatusEvent) : void
{
var _loc2_:* = param1.info.code;
if("NetStream.Play.UnpublishNotify" === _loc2_)
{
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 _bootstrapVersion;
}
public function set bootstrapVersion(param1:uint) : void
{
_bootstrapVersion = param1;
}
public function get profile() : uint
{
return _profile;
}
public function set profile(param1:uint) : void
{
_profile = param1;
}
public function get live() : Boolean
{
return _live;
}
public function set live(param1:Boolean) : void
{
_live = param1;
}
public function get update() : Boolean
{
return _update;
}
public function set update(param1:Boolean) : void
{
_update = param1;
}
public function get timeScale() : uint
{
return _timeScale;
}
public function set timeScale(param1:uint) : void
{
_timeScale = param1;
}
public function get currentMediaTime() : Number
{
return _currentMediaTime;
}
public function set currentMediaTime(param1:Number) : void
{
_currentMediaTime = param1;
}
public function get smpteTimeCodeOffset() : Number
{
return _smpteTimeCodeOffset;
}
public function set smpteTimeCodeOffset(param1:Number) : void
{
_smpteTimeCodeOffset = param1;
}
public function get movieIdentifier() : String
{
return _movieIdentifier;
}
public function set movieIdentifier(param1:String) : void
{
_movieIdentifier = param1;
}
public function get serverBaseURLs() : Vector.<String>
{
return _serverBaseURLs;
}
public function set serverBaseURLs(param1:Vector.<String>) : void
{
_serverBaseURLs = param1;
}
public function get qualitySegmentURLModifiers() : Vector.<String>
{
return _qualitySegmentURLModifiers;
}
public function set qualitySegmentURLModifiers(param1:Vector.<String>) : void
{
_qualitySegmentURLModifiers = param1;
}
public function get drmData() : String
{
return _drmData;
}
public function set drmData(param1:String) : void
{
_drmData = param1;
}
public function get metadata() : String
{
return _metadata;
}
public function set metadata(param1:String) : void
{
_metadata = param1;
}
public function get segmentRunTables() : Vector.<AdobeSegmentRunTable>
{
return _segmentRunTables;
}
public function set segmentRunTables(param1:Vector.<AdobeSegmentRunTable>) : void
{
_segmentRunTables = param1;
}
public function get fragmentRunTables() : Vector.<AdobeFragmentRunTable>
{
return _fragmentRunTables;
}
public function set fragmentRunTables(param1:Vector.<AdobeFragmentRunTable>) : void
{
var _loc2_:AdobeFragmentRunTable = null;
_fragmentRunTables = param1;
if(param1 != null && param1.length > 0)
{
_loc2_ = param1[param1.length - 1];
_loc2_.adjustEndEntryDurationAccrued(_currentMediaTime);
}
}
public function findSegmentId(param1:uint) : uint
{
return _segmentRunTables[0].findSegmentIdByFragmentId(param1);
}
public function get totalFragments() : uint
{
var _loc4_:AdobeFragmentRunTable = _fragmentRunTables[_fragmentRunTables.length - 1];
var _loc5_:Vector.<FragmentDurationPair> = _loc4_.fragmentDurationPairs;
var _loc1_:FragmentDurationPair = _loc5_[_loc5_.length - 1];
if(_loc1_.duration == 0)
{
_loc1_ = _loc5_[_loc5_.length - 2];
}
var _loc3_:Number = _currentMediaTime - _loc1_.durationAccrued;
var _loc2_:uint = _loc3_ <= 0 ? 0 : _loc3_ / _loc1_.duration;
return _loc1_.firstFragment + _loc2_ - 1;
}
public function get totalDuration() : uint
{
if(_fragmentRunTables == null || _fragmentRunTables.length < 1)
{
return 0;
}
var _loc1_:AdobeFragmentRunTable = _fragmentRunTables[0];
return _currentMediaTime - _loc1_.fragmentDurationPairs[0].durationAccrued;
}
public function contentComplete() : Boolean
{
var _loc1_:AdobeFragmentRunTable = _fragmentRunTables[_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 _timeScale;
}
public function set timeScale(param1:uint) : void
{
_timeScale = param1;
}
public function get localRandomAccessEntries() : Vector.<LocalRandomAccessEntry>
{
return _localRandomAccessEntries;
}
public function set localRandomAccessEntries(param1:Vector.<LocalRandomAccessEntry>) : void
{
_localRandomAccessEntries = param1;
}
public function get globalRandomAccessEntries() : Vector.<GlobalRandomAccessEntry>
{
return _globalRandomAccessEntries;
}
public function set globalRandomAccessEntries(param1:Vector.<GlobalRandomAccessEntry>) : void
{
_globalRandomAccessEntries = param1;
}
public function findNearestKeyFrameOffset(param1:Number) : LocalRandomAccessEntry
{
var _loc2_:LocalRandomAccessEntry = null;
var _loc3_:int = _localRandomAccessEntries.length - 1;
while(_loc3_ >= 0)
{
_loc2_ = _localRandomAccessEntries[_loc3_];
if(_loc2_.time <= param1)
{
return _loc2_;
}
_loc3_--;
}
return null;
}
}
}
@@ -0,0 +1,248 @@
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();
_fragmentDurationPairs = new Vector.<FragmentDurationPair>();
}
public function get timeScale() : uint
{
return _timeScale;
}
public function set timeScale(param1:uint) : void
{
_timeScale = param1;
}
public function get qualitySegmentURLModifiers() : Vector.<String>
{
return _qualitySegmentURLModifiers;
}
public function set qualitySegmentURLModifiers(param1:Vector.<String>) : void
{
_qualitySegmentURLModifiers = param1;
}
public function get fragmentDurationPairs() : Vector.<FragmentDurationPair>
{
return _fragmentDurationPairs;
}
public function addFragmentDurationPair(param1:FragmentDurationPair) : void
{
_fragmentDurationPairs.push(param1);
}
public function findFragmentIdByTime(param1:Number, param2:Number, param3:Boolean = false) : FragmentAccessInformation
{
var _loc5_:* = 0;
if(_fragmentDurationPairs.length <= 0)
{
return null;
}
var _loc4_:FragmentDurationPair = null;
_loc5_ = 1;
while(_loc5_ < _fragmentDurationPairs.length)
{
_loc4_ = _fragmentDurationPairs[_loc5_];
if(_loc4_.durationAccrued >= param1)
{
return validateFragment(calculateFragmentId(_fragmentDurationPairs[_loc5_ - 1],param1),param2,param3);
}
_loc5_++;
}
return validateFragment(calculateFragmentId(_fragmentDurationPairs[_fragmentDurationPairs.length - 1],param1),param2,param3);
}
public function validateFragment(param1:uint, param2:Number, param3:Boolean = false) : FragmentAccessInformation
{
var _loc9_:* = 0;
var _loc7_:FragmentDurationPair = null;
var _loc8_:FragmentDurationPair = null;
var _loc6_:Number = NaN;
var _loc12_:Number = NaN;
var _loc4_:Number = NaN;
var _loc10_:FragmentDurationPair = null;
var _loc5_:uint = _fragmentDurationPairs.length - 1;
var _loc11_:FragmentAccessInformation = null;
_loc9_ = 0;
while(_loc9_ < _loc5_)
{
_loc7_ = _fragmentDurationPairs[_loc9_];
_loc8_ = _fragmentDurationPairs[_loc9_ + 1];
if(_loc7_.firstFragment <= param1 && param1 < _loc8_.firstFragment)
{
if(_loc7_.duration <= 0)
{
_loc11_ = getNextValidFragment(_loc9_ + 1,param2);
}
else
{
_loc11_ = new FragmentAccessInformation();
_loc11_.fragId = param1;
_loc11_.fragDuration = _loc7_.duration;
_loc11_.fragmentEndTime = _loc7_.durationAccrued + _loc7_.duration * (param1 - _loc7_.firstFragment + 1);
}
break;
}
if(_loc7_.firstFragment <= param1 && endOfStreamEntry(_loc8_))
{
if(_loc7_.duration > 0)
{
_loc6_ = param2 - _loc7_.durationAccrued;
_loc12_ = (param1 - _loc7_.firstFragment + 1) * _loc7_.duration;
_loc4_ = (param1 - _loc7_.firstFragment) * _loc7_.duration;
if(_loc6_ > _loc4_)
{
if(!param3 || _loc4_ + _loc7_.duration + _loc7_.durationAccrued <= param2)
{
_loc11_ = new FragmentAccessInformation();
_loc11_.fragId = param1;
_loc11_.fragDuration = _loc7_.duration;
if(_loc6_ >= _loc12_)
{
_loc11_.fragmentEndTime = _loc7_.durationAccrued + _loc12_;
}
else
{
_loc11_.fragmentEndTime = _loc7_.durationAccrued + _loc6_;
}
break;
}
}
}
}
_loc9_++;
}
if(_loc11_ == null)
{
_loc10_ = _fragmentDurationPairs[_loc5_];
if(_loc10_.duration > 0 && param1 >= _loc10_.firstFragment)
{
_loc6_ = param2 - _loc10_.durationAccrued;
_loc12_ = (param1 - _loc10_.firstFragment + 1) * _loc10_.duration;
_loc4_ = (param1 - _loc10_.firstFragment) * _loc10_.duration;
if(_loc6_ > _loc4_)
{
if(!param3 || _loc4_ + _loc10_.duration + _loc10_.durationAccrued <= param2)
{
_loc11_ = new FragmentAccessInformation();
_loc11_.fragId = param1;
_loc11_.fragDuration = _loc10_.duration;
if(_loc6_ >= _loc12_)
{
_loc11_.fragmentEndTime = _loc10_.durationAccrued + _loc12_;
}
else
{
_loc11_.fragmentEndTime = _loc10_.durationAccrued + _loc6_;
}
}
}
}
}
return _loc11_;
}
private function getNextValidFragment(param1:uint, param2:Number) : FragmentAccessInformation
{
var _loc4_:* = 0;
var _loc3_:FragmentDurationPair = null;
var _loc5_:FragmentAccessInformation = null;
_loc4_ = param1;
while(_loc4_ < _fragmentDurationPairs.length)
{
_loc3_ = _fragmentDurationPairs[_loc4_];
if(_loc3_.duration > 0)
{
_loc5_ = new FragmentAccessInformation();
_loc5_.fragId = _loc3_.firstFragment;
_loc5_.fragDuration = _loc3_.duration;
_loc5_.fragmentEndTime = _loc3_.durationAccrued + _loc3_.duration;
break;
}
_loc4_++;
}
return _loc5_;
}
private function endOfStreamEntry(param1:FragmentDurationPair) : Boolean
{
return param1.duration == 0 && param1.discontinuityIndicator == 0;
}
public function fragmentsLeft(param1:uint, param2:Number) : uint
{
if(_fragmentDurationPairs == null || _fragmentDurationPairs.length == 0)
{
return 0;
}
var _loc3_:FragmentDurationPair = _fragmentDurationPairs[fragmentDurationPairs.length - 1] as FragmentDurationPair;
return uint((param2 - _loc3_.durationAccrued) / _loc3_.duration + _loc3_.firstFragment - param1 - 1);
}
public function tableComplete() : Boolean
{
if(_fragmentDurationPairs == null || _fragmentDurationPairs.length <= 0)
{
return false;
}
var _loc1_:FragmentDurationPair = _fragmentDurationPairs[fragmentDurationPairs.length - 1] as FragmentDurationPair;
return _loc1_.duration == 0 && _loc1_.discontinuityIndicator == 0;
}
public function adjustEndEntryDurationAccrued(param1:Number) : void
{
var _loc2_:FragmentDurationPair = _fragmentDurationPairs[_fragmentDurationPairs.length - 1];
if(_loc2_.duration == 0)
{
_loc2_.durationAccrued = param1;
}
}
private function findValidFragmentDurationPair(param1:uint) : FragmentDurationPair
{
var _loc3_:* = 0;
var _loc2_:FragmentDurationPair = null;
_loc3_ = param1;
while(param1 < _fragmentDurationPairs.length)
{
_loc2_ = _fragmentDurationPairs[_loc3_];
if(_loc2_.duration > 0)
{
return _loc2_;
}
_loc3_++;
}
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 ? _loc3_ / param1.duration : 1;
if(_loc3_ % param1.duration > 0)
{
_loc4_++;
}
return param1.firstFragment + _loc4_ - 1;
}
}
}
@@ -0,0 +1,75 @@
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();
_segmentFragmentPairs = new Vector.<SegmentFragmentPair>();
}
public function get qualitySegmentURLModifiers() : Vector.<String>
{
return _qualitySegmentURLModifiers;
}
public function set qualitySegmentURLModifiers(param1:Vector.<String>) : void
{
_qualitySegmentURLModifiers = param1;
}
public function get segmentFragmentPairs() : Vector.<SegmentFragmentPair>
{
return _segmentFragmentPairs;
}
public function addSegmentFragmentPair(param1:SegmentFragmentPair) : void
{
var _loc2_:SegmentFragmentPair = _segmentFragmentPairs.length <= 0 ? null : _segmentFragmentPairs[_segmentFragmentPairs.length - 1];
var _loc3_:uint = 0;
if(_loc2_ != null)
{
_loc3_ = _loc2_.fragmentsAccrued + (param1.firstSegment - _loc2_.firstSegment) * _loc2_.fragmentsPerSegment;
}
param1.fragmentsAccrued = _loc3_;
_segmentFragmentPairs.push(param1);
}
public function findSegmentIdByFragmentId(param1:uint) : uint
{
var _loc2_:SegmentFragmentPair = null;
var _loc3_:* = 0;
if(param1 < 1)
{
return 0;
}
_loc3_ = 1;
while(_loc3_ < _segmentFragmentPairs.length)
{
_loc2_ = _segmentFragmentPairs[_loc3_];
if(_loc2_.fragmentsAccrued >= param1)
{
return calculateSegmentId(_segmentFragmentPairs[_loc3_ - 1],param1);
}
_loc3_++;
}
return calculateSegmentId(_segmentFragmentPairs[_segmentFragmentPairs.length - 1],param1);
}
public function get totalFragments() : uint
{
return _segmentFragmentPairs[_segmentFragmentPairs.length - 1].fragmentsPerSegment + _segmentFragmentPairs[_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 _size;
}
public function set size(param1:Number) : void
{
_size = param1;
}
public function get type() : String
{
return _type;
}
public function set type(param1:String) : void
{
_type = param1;
}
public function get boxLength() : uint
{
return _boxLength;
}
public function set boxLength(param1:uint) : void
{
_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();
_size = param1;
_type = param2;
}
public function get size() : Number
{
return _size;
}
public function set size(param1:Number) : void
{
_size = param1;
}
public function get type() : String
{
return _type;
}
}
}
@@ -0,0 +1,417 @@
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();
_ba = null;
}
public function init(param1:ByteArray) : void
{
_ba = param1;
_ba.position = 0;
}
public function getNextBoxInfo() : BoxInfo
{
if(_ba == null || _ba.bytesAvailable < 4 + 4)
{
return null;
}
var _loc1_:Number = _ba.readUnsignedInt();
var _loc2_:String = _ba.readUTFBytes(4);
return new BoxInfo(_loc1_,_loc2_);
}
public function getBoxes() : Vector.<Box>
{
var _loc5_:AdobeBootstrapBox = null;
var _loc3_:AdobeFragmentRandomAccessBox = null;
var _loc4_:MediaDataBox = null;
var _loc1_:Vector.<Box> = new Vector.<Box>();
var _loc2_:BoxInfo = getNextBoxInfo();
while(_loc2_ != null)
{
if(_loc2_.type == "abst")
{
_loc5_ = new AdobeBootstrapBox();
parseAdobeBootstrapBox(_loc2_,_loc5_);
_loc1_.push(_loc5_);
}
else if(_loc2_.type == "afra")
{
_loc3_ = new AdobeFragmentRandomAccessBox();
parseAdobeFragmentRandomAccessBox(_loc2_,_loc3_);
_loc1_.push(_loc3_);
}
else if(_loc2_.type == "mdat")
{
_loc4_ = new MediaDataBox();
parseMediaDataBox(_loc2_,_loc4_);
_loc1_.push(_loc4_);
}
else
{
_ba.position = _ba.position + _loc2_.size - (4 + 4);
}
_loc2_ = getNextBoxInfo();
if(_loc2_ != null && _loc2_.size <= 0)
{
break;
}
}
return _loc1_;
}
public function readFragmentRandomAccessBox(param1:BoxInfo) : AdobeFragmentRandomAccessBox
{
var _loc2_:AdobeFragmentRandomAccessBox = new AdobeFragmentRandomAccessBox();
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(_ba == null || _ba.bytesAvailable < 8)
{
throw new IllegalOperationError("not enough length for readLongUIntToNumer");
}
var _loc1_:Number = _ba.readUnsignedInt();
_loc1_ *= 4294967296;
return _loc1_ + _ba.readUnsignedInt();
}
private function readUnsignedInt() : uint
{
if(_ba == null || _ba.bytesAvailable < 4)
{
throw new IllegalOperationError("not enough length for readUnsignedInt");
}
return _ba.readUnsignedInt();
}
private function readBytes(param1:ByteArray, param2:uint = 0, param3:uint = 0) : void
{
if(_ba == null || _ba.bytesAvailable < param3)
{
throw new IllegalOperationError("not enough length for readBytes: " + param3);
}
return _ba.readBytes(param1,param2,param3);
}
private function readUnsignedByte() : uint
{
if(_ba == null || _ba.bytesAvailable < 1)
{
throw new IllegalOperationError("not enough length for readUnsingedByte");
}
return _ba.readUnsignedByte();
}
private function readBytesToUint(param1:uint) : uint
{
var _loc4_:* = 0;
var _loc3_:* = 0;
if(_ba == null || _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;
_loc4_ = 0;
while(_loc4_ < param1)
{
_loc2_ <<= 8;
_loc3_ = _ba.readUnsignedByte();
_loc2_ += _loc3_;
_loc4_++;
}
return _loc2_;
}
private function readString() : String
{
var _loc1_:* = 0;
var _loc2_:uint = _ba.position;
while(_ba.position < _ba.length)
{
_loc1_ = uint(_ba.readByte());
if(_loc1_ == 0)
{
break;
}
}
var _loc3_:uint = _ba.position - _loc2_;
_ba.position = _loc2_;
return _ba.readUTFBytes(_loc3_);
}
private function parseBox(param1:BoxInfo, param2:Box) : void
{
var _loc5_:ByteArray = null;
var _loc4_:Number = param1.size;
var _loc3_:uint = 8;
if(param1.size == 1)
{
_loc4_ = readLongUIntToNumber();
_loc3_ += 8;
}
if(param1.type == "uuid")
{
_loc5_ = new ByteArray();
readBytes(_loc5_,0,16);
_loc3_ += 16;
}
param2.size = _loc4_;
param2.type = param1.type;
param2.boxLength = _loc3_;
}
private function parseFullBox(param1:BoxInfo, param2:FullBox) : void
{
parseBox(param1,param2);
param2.version = readUnsignedByte();
param2.flags = readBytesToUint(3);
}
private function parseAdobeBootstrapBox(param1:BoxInfo, param2:AdobeBootstrapBox) : void
{
var _loc5_:int = 0;
var _loc14_:AdobeSegmentRunTable = null;
var _loc6_:AdobeFragmentRunTable = null;
parseFullBox(param1,param2);
param2.bootstrapVersion = readUnsignedInt();
var _loc3_:uint = readUnsignedByte();
param2.profile = _loc3_ >> 6;
param2.live = (_loc3_ & 0x20) == 32;
param2.update = (_loc3_ & 1) == 1;
param2.timeScale = readUnsignedInt();
param2.currentMediaTime = readLongUIntToNumber();
param2.smpteTimeCodeOffset = readLongUIntToNumber();
param2.movieIdentifier = readString();
var _loc8_:uint = readUnsignedByte();
var _loc10_:Vector.<String> = new Vector.<String>();
_loc5_ = 0;
while(_loc5_ < _loc8_)
{
_loc10_.push(readString());
_loc5_++;
}
param2.serverBaseURLs = _loc10_;
var _loc12_:uint = readUnsignedByte();
var _loc13_:Vector.<String> = new Vector.<String>();
_loc5_ = 0;
while(_loc5_ < _loc12_)
{
_loc13_.push(readString());
_loc5_++;
}
param2.qualitySegmentURLModifiers = _loc13_;
param2.drmData = readString();
param2.metadata = readString();
var _loc11_:uint = readUnsignedByte();
var _loc4_:Vector.<AdobeSegmentRunTable> = new Vector.<AdobeSegmentRunTable>();
_loc5_ = 0;
while(_loc5_ < _loc11_)
{
param1 = getNextBoxInfo();
if(param1.type != "asrt")
{
throw new IllegalOperationError("Unexpected data structure: " + param1.type);
}
_loc14_ = new AdobeSegmentRunTable();
parseAdobeSegmentRunTable(param1,_loc14_);
_loc4_.push(_loc14_);
_loc5_++;
}
param2.segmentRunTables = _loc4_;
var _loc9_:uint = readUnsignedByte();
var _loc7_:Vector.<AdobeFragmentRunTable> = new Vector.<AdobeFragmentRunTable>();
_loc5_ = 0;
while(_loc5_ < _loc9_)
{
param1 = getNextBoxInfo();
if(param1.type != "afrt")
{
throw new IllegalOperationError("Unexpected data structure: " + param1.type);
}
_loc6_ = new AdobeFragmentRunTable();
parseAdobeFragmentRunTable(param1,_loc6_);
_loc7_.push(_loc6_);
_loc5_++;
}
param2.fragmentRunTables = _loc7_;
}
private function parseAdobeSegmentRunTable(param1:BoxInfo, param2:AdobeSegmentRunTable) : void
{
var _loc6_:* = 0;
parseFullBox(param1,param2);
var _loc3_:uint = readUnsignedByte();
var _loc5_:Vector.<String> = new Vector.<String>();
_loc6_ = 0;
while(_loc6_ < _loc3_)
{
_loc5_.push(readString());
_loc6_++;
}
param2.qualitySegmentURLModifiers = _loc5_;
var _loc4_:uint = readUnsignedInt();
_loc6_ = 0;
while(_loc6_ < _loc4_)
{
param2.addSegmentFragmentPair(new SegmentFragmentPair(readUnsignedInt(),readUnsignedInt()));
_loc6_++;
}
}
private function parseAdobeFragmentRunTable(param1:BoxInfo, param2:AdobeFragmentRunTable) : void
{
var _loc7_:* = 0;
var _loc5_:FragmentDurationPair = null;
parseFullBox(param1,param2);
param2.timeScale = readUnsignedInt();
var _loc3_:uint = readUnsignedByte();
var _loc6_:Vector.<String> = new Vector.<String>();
_loc7_ = 0;
while(_loc7_ < _loc3_)
{
_loc6_.push(readString());
_loc7_++;
}
param2.qualitySegmentURLModifiers = _loc6_;
var _loc4_:uint = readUnsignedInt();
_loc7_ = 0;
while(_loc7_ < _loc4_)
{
_loc5_ = new FragmentDurationPair();
parseFragmentDurationPair(_loc5_);
param2.addFragmentDurationPair(_loc5_);
_loc7_++;
}
}
private function parseFragmentDurationPair(param1:FragmentDurationPair) : void
{
param1.firstFragment = readUnsignedInt();
param1.durationAccrued = readLongUIntToNumber();
param1.duration = readUnsignedInt();
if(param1.duration == 0)
{
param1.discontinuityIndicator = readUnsignedByte();
}
}
private function parseAdobeFragmentRandomAccessBox(param1:BoxInfo, param2:AdobeFragmentRandomAccessBox) : void
{
var _loc8_:* = 0;
var _loc7_:LocalRandomAccessEntry = null;
var _loc12_:GlobalRandomAccessEntry = null;
parseFullBox(param1,param2);
var _loc5_:uint = readBytesToUint(1);
var _loc3_:Boolean = (_loc5_ & 0x80) > 0;
var _loc11_:Boolean = (_loc5_ & 0x40) > 0;
var _loc6_:Boolean = (_loc5_ & 0x20) > 0;
param2.timeScale = readUnsignedInt();
var _loc4_:uint = readUnsignedInt();
var _loc10_:Vector.<LocalRandomAccessEntry> = new Vector.<LocalRandomAccessEntry>();
_loc8_ = 0;
while(_loc8_ < _loc4_)
{
_loc7_ = new LocalRandomAccessEntry();
parseLocalRandomAccessEntry(_loc7_,_loc11_);
_loc10_.push(_loc7_);
_loc8_++;
}
param2.localRandomAccessEntries = _loc10_;
var _loc9_:Vector.<GlobalRandomAccessEntry> = new Vector.<GlobalRandomAccessEntry>();
if(_loc6_)
{
_loc4_ = readUnsignedInt();
_loc8_ = 0;
while(_loc8_ < _loc4_)
{
_loc12_ = new GlobalRandomAccessEntry();
parseGlobalRandomAccessEntry(_loc12_,_loc3_,_loc11_);
_loc9_.push(_loc12_);
_loc8_++;
}
}
param2.globalRandomAccessEntries = _loc9_;
}
private function parseLocalRandomAccessEntry(param1:LocalRandomAccessEntry, param2:Boolean) : void
{
param1.time = readLongUIntToNumber();
if(param2)
{
param1.offset = readLongUIntToNumber();
}
else
{
param1.offset = readUnsignedInt();
}
}
private function parseGlobalRandomAccessEntry(param1:GlobalRandomAccessEntry, param2:Boolean, param3:Boolean) : void
{
param1.time = readLongUIntToNumber();
if(param2)
{
param1.segment = readUnsignedInt();
param1.fragment = readUnsignedInt();
}
else
{
param1.segment = readBytesToUint(2);
param1.fragment = readBytesToUint(2);
}
if(param3)
{
param1.afraOffset = readLongUIntToNumber();
param1.offsetFromAfra = readLongUIntToNumber();
}
else
{
param1.afraOffset = readUnsignedInt();
param1.offsetFromAfra = readUnsignedInt();
}
}
private function parseMediaDataBox(param1:BoxInfo, param2:MediaDataBox) : void
{
parseBox(param1,param2);
var _loc3_:ByteArray = new ByteArray();
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 _firstFragment;
}
public function set firstFragment(param1:uint) : void
{
_firstFragment = param1;
}
public function get duration() : uint
{
return _duration;
}
public function set duration(param1:uint) : void
{
_duration = param1;
}
public function get durationAccrued() : Number
{
return _durationAccrued;
}
public function set durationAccrued(param1:Number) : void
{
_durationAccrued = param1;
}
public function get discontinuityIndicator() : uint
{
return _discontinuityIndicator;
}
public function set discontinuityIndicator(param1:uint) : void
{
_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 _version;
}
public function set version(param1:uint) : void
{
_version = param1;
}
public function get flags() : uint
{
return _flags;
}
public function set flags(param1:uint) : void
{
_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 _time;
}
public function set time(param1:Number) : void
{
_time = param1;
}
public function get segment() : uint
{
return _segment;
}
public function set segment(param1:uint) : void
{
_segment = param1;
}
public function get fragment() : uint
{
return _fragment;
}
public function set fragment(param1:uint) : void
{
_fragment = param1;
}
public function get afraOffset() : Number
{
return _afraOffset;
}
public function set afraOffset(param1:Number) : void
{
_afraOffset = param1;
}
public function get offsetFromAfra() : Number
{
return _offsetFromAfra;
}
public function set offsetFromAfra(param1:Number) : void
{
_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 = 5120;
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
{
_processRequestWasSeek = param1;
_seekToTime = param1 ? param2 : 0;
_bytesNeeded = 4 + 4 + 8 + 16;
_bytesReadSinceAfraStart = 0;
_countingReadBytes = false;
_boxInfoPending = true;
_nextBox = null;
}
override public function get inputBytesNeeded() : Number
{
return _bytesNeeded;
}
override public function processFileSegment(param1:IDataInput) : ByteArray
{
var _loc3_:* = 0;
var _loc5_:AdobeBootstrapBox = null;
if(param1.bytesAvailable < _bytesNeeded)
{
return null;
}
var _loc2_:ByteArray = null;
var _loc4_:Number = 8;
if(_boxInfoPending)
{
_ba = new ByteArray();
param1.readBytes(_ba,0,_loc4_);
if(_countingReadBytes)
{
_bytesReadSinceAfraStart += _loc4_;
}
_parser.init(_ba);
_nextBox = _parser.getNextBoxInfo();
if(_nextBox.size == 1)
{
_loc4_ += 8;
_ba.position = 0;
param1.readBytes(_ba,0,8);
if(_countingReadBytes)
{
_bytesReadSinceAfraStart += 8;
}
_nextBox.size = _parser.readLongUIntToNumber();
}
_boxInfoPending = false;
if(_nextBox.type == "mdat")
{
_bytesNeeded = 0;
_mdatBytesPending = _nextBox.size - _loc4_;
}
else
{
_bytesNeeded = _nextBox.size - _loc4_;
_mdatBytesPending = 0;
if(_nextBox.type == "afra")
{
_bytesReadSinceAfraStart = _loc4_;
_countingReadBytes = true;
}
}
}
else if(_bytesNeeded > 0)
{
_loc3_ = _ba.position;
param1.readBytes(_ba,_ba.length,_nextBox.size - _loc4_);
if(_countingReadBytes)
{
_bytesReadSinceAfraStart += _nextBox.size - _loc4_;
}
_ba.position = _loc3_;
if(_nextBox.type == "abst")
{
_loc5_ = _parser.readAdobeBootstrapBox(_nextBox);
if(_loc5_ != null)
{
dispatchEvent(new HTTPStreamingFileHandlerEvent("notifyBootstrapBox",false,false,0,null,false,false,_loc5_));
}
}
else if(_nextBox.type == "afra")
{
_afra = _parser.readFragmentRandomAccessBox(_nextBox);
processSeekToTime();
}
else if(_nextBox.type == "moof")
{
}
_bytesNeeded = 4 + 4 + 8 + 16;
_boxInfoPending = true;
_nextBox = null;
}
else
{
_loc2_ = getMDATBytes(param1,false);
}
return _loc2_;
}
override public function endProcessFile(param1:IDataInput) : ByteArray
{
if(this._bytesNeeded > 0)
{
dispatchEvent(new HTTPStreamingFileHandlerEvent("notifyError",false,false,0,null,false,false,null,true));
}
return getMDATBytes(param1,true);
}
override public function flushFileSegment(param1:IDataInput) : ByteArray
{
return null;
}
private function getMDATBytes(param1:IDataInput, param2:Boolean) : ByteArray
{
var _loc4_:ByteArray = null;
var _loc3_:* = 0;
if(param1 == null)
{
return null;
}
skipSeekBytes(param1);
if(_mdatBytesPending > 0)
{
_loc3_ = _mdatBytesPending < param1.bytesAvailable ? _mdatBytesPending : param1.bytesAvailable;
if(!param2 && _loc3_ > 5120)
{
_loc3_ = 5120;
}
_loc4_ = new ByteArray();
_mdatBytesPending -= _loc3_;
param1.readBytes(_loc4_,0,_loc3_);
}
return _loc4_;
}
private function skipSeekBytes(param1:IDataInput) : void
{
var _loc2_:* = 0;
var _loc3_:ByteArray = null;
if(_bytesReadSinceAfraStart < _mdatBytesOffset)
{
_loc2_ = uint(_mdatBytesOffset - _bytesReadSinceAfraStart);
if(param1.bytesAvailable < _loc2_)
{
_loc2_ = param1.bytesAvailable;
}
_loc3_ = new ByteArray();
param1.readBytes(_loc3_,0,_loc2_);
_bytesReadSinceAfraStart += _loc2_;
_mdatBytesPending -= _loc2_;
}
}
private function processSeekToTime() : void
{
var _loc2_:Number = 0;
var _loc1_:LocalRandomAccessEntry = null;
if(_seekToTime <= 0)
{
_mdatBytesOffset = 0;
}
else
{
_loc1_ = getMDATBytesOffset(_seekToTime);
if(_loc1_ != null)
{
_mdatBytesOffset = _loc1_.offset;
_loc2_ = _loc1_.time;
}
else
{
_mdatBytesOffset = 0;
}
}
}
private function getMDATBytesOffset(param1:Number) : LocalRandomAccessEntry
{
return !isNaN(param1) ? _afra.findNearestKeyFrameOffset(param1 * _afra.timeScale) : null;
}
}
}
@@ -0,0 +1,495 @@
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();
currentQuality = -1;
currentFAI = null;
fragmentRunTablesUpdating = false;
this.fileHandler = param1;
this.fragmentsThreshold = param2;
dvrGetStreamInfoCall = false;
param1.addEventListener("notifyBootstrapBox",onNewBootstrapBox);
}
public function get bootstrapInfo() : AdobeBootstrapBox
{
return currentQuality < 0 ? null : bootstrapBoxes[currentQuality];
}
override public function dvrGetStreamInfo(param1:Object) : void
{
dvrGetStreamInfoCall = true;
playInProgress = false;
initialize(param1);
}
override public function initialize(param1:Object) : void
{
var _loc4_:AdobeBootstrapBox = null;
var _loc2_:int = 0;
var _loc3_:BootstrapInfo = null;
f4fIndexInfo = param1 as HTTPStreamingF4FIndexInfo;
if(f4fIndexInfo == null || f4fIndexInfo.streamInfos == null || f4fIndexInfo.streamInfos.length <= 0)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyError"));
return;
}
bootstrapBoxes = new Vector.<AdobeBootstrapBox>(f4fIndexInfo.streamInfos.length);
fragmentRunTablesUpdating = false;
playInProgress = false;
pendingIndexLoads = 0;
pureLiveOffset = NaN;
serverBaseURL = f4fIndexInfo.serverBaseURL;
streamInfos = f4fIndexInfo.streamInfos;
_loc2_ = 0;
while(_loc2_ < streamInfos.length)
{
_loc3_ = streamInfos[_loc2_].bootstrapInfo;
if(_loc3_ == null || _loc3_.url == null && _loc3_.data == null)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyError"));
return;
}
if(_loc3_.data != null)
{
_loc4_ = processBootstrapData(_loc3_.data,null);
if(_loc4_ == null)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyError"));
return;
}
bootstrapBoxes[_loc2_] = _loc4_;
}
else
{
pendingIndexLoads = pendingIndexLoads + 1;
dispatchEvent(new HTTPStreamingIndexHandlerEvent("requestLoadIndex",false,false,false,NaN,null,null,new URLRequest(HTTPStreamingUtils.normalizeURL(_loc3_.url)),_loc2_,true));
}
_loc2_++;
}
if(pendingIndexLoads == 0)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyRates",false,false,false,NaN,getStreamNames(streamInfos),getQualityRates(streamInfos)));
notifyIndexReady(0);
}
}
override public function processIndexData(param1:*, param2:Object) : void
{
var _loc3_:int = param2 as int;
var _loc4_:AdobeBootstrapBox = processBootstrapData(param1,_loc3_);
if(_loc4_ == null)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyError"));
return;
}
if(!fragmentRunTablesUpdating)
{
pendingIndexLoads = pendingIndexLoads - 1;
}
else
{
pendingIndexUpdates = pendingIndexUpdates - 1;
if(pendingIndexUpdates == 0)
{
fragmentRunTablesUpdating = false;
dispatchDVRStreamInfo(_loc4_);
}
}
if(bootstrapBoxes[_loc3_] == null || bootstrapBoxes[_loc3_].bootstrapVersion < _loc4_.bootstrapVersion || bootstrapBoxes[_loc3_].currentMediaTime < _loc4_.currentMediaTime)
{
delay = 0.05;
bootstrapBoxes[_loc3_] = _loc4_;
}
if(pendingIndexLoads == 0 && !fragmentRunTablesUpdating)
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyRates",false,false,false,NaN,getStreamNames(streamInfos),getQualityRates(streamInfos)));
notifyIndexReady(_loc3_);
}
}
override public function getFileForTime(param1:Number, param2:int) : HTTPStreamRequest
{
var _loc3_:FragmentDurationPair = null;
var _loc4_:* = 0;
var _loc5_:String = null;
var _loc8_:AdobeBootstrapBox = bootstrapBoxes[param2];
var _loc7_:HTTPStreamRequest = null;
if(!playInProgress && stopPlaying(_loc8_))
{
return null;
}
checkMetadata(param2,_loc8_);
var _loc6_:AdobeFragmentRunTable = getFragmentRunTable(_loc8_);
if(param1 >= 0 && param1 * _loc8_.timeScale <= _loc8_.currentMediaTime && param2 >= 0 && param2 < streamInfos.length)
{
currentFAI = _loc6_.findFragmentIdByTime(param1 * _loc8_.timeScale,_loc8_.currentMediaTime,_loc8_.contentComplete() ? false : _loc8_.live);
if(currentFAI == null || fragmentOverflow(_loc8_,currentFAI.fragId))
{
if(_loc8_.contentComplete())
{
if(_loc8_.live)
{
return new HTTPStreamRequest(null,param2,-1,-1,true);
}
return null;
}
adjustDelay();
refreshBootstrapInfo(param2);
return new HTTPStreamRequest(null,param2,0,delay);
}
playInProgress = true;
_loc3_ = _loc6_.fragmentDurationPairs[0];
_loc4_ = _loc8_.findSegmentId(currentFAI.fragId - _loc3_.firstFragment + 1);
_loc5_ = "";
if((streamInfos[param2].streamName as String).indexOf("http") != 0)
{
_loc5_ = serverBaseURL + "/" + streamInfos[param2].streamName + "Seg" + _loc4_ + "-Frag" + currentFAI.fragId;
}
else
{
_loc5_ = streamInfos[param2].streamName + "Seg" + _loc4_ + "-Frag" + currentFAI.fragId;
}
_loc7_ = new HTTPStreamRequest(_loc5_);
checkQuality(param2);
notifyFragmentDuration(currentFAI.fragDuration / _loc8_.timeScale);
}
return _loc7_;
}
override public function getNextFile(param1:int) : HTTPStreamRequest
{
var _loc5_:AdobeFragmentRunTable = null;
var _loc6_:FragmentAccessInformation = null;
var _loc2_:FragmentDurationPair = null;
var _loc3_:* = 0;
var _loc4_:String = null;
var _loc8_:AdobeBootstrapBox = bootstrapBoxes[param1];
var _loc7_:HTTPStreamRequest = null;
if(!playInProgress && stopPlaying(_loc8_))
{
return null;
}
checkMetadata(param1,_loc8_);
if(param1 >= 0 && param1 < streamInfos.length)
{
_loc5_ = getFragmentRunTable(_loc8_);
_loc6_ = currentFAI;
currentFAI = _loc5_.validateFragment(currentFAI.fragId + 1,_loc8_.currentMediaTime,_loc8_.contentComplete() ? false : _loc8_.live);
if(currentFAI == null || fragmentOverflow(_loc8_,currentFAI.fragId))
{
if(!_loc8_.live || _loc8_.contentComplete())
{
if(_loc8_.live)
{
return new HTTPStreamRequest(null,param1,-1,-1,true);
}
return null;
}
adjustDelay();
currentFAI = _loc6_;
refreshBootstrapInfo(param1);
return new HTTPStreamRequest(null,param1,0,delay);
}
playInProgress = true;
_loc2_ = _loc5_.fragmentDurationPairs[0];
_loc3_ = _loc8_.findSegmentId(currentFAI.fragId - _loc2_.firstFragment + 1);
_loc4_ = "";
if((streamInfos[param1].streamName as String).indexOf("http") != 0)
{
_loc4_ = serverBaseURL + "/" + streamInfos[param1].streamName + "Seg" + _loc3_ + "-Frag" + currentFAI.fragId;
}
else
{
_loc4_ = streamInfos[param1].streamName + "Seg" + _loc3_ + "-Frag" + currentFAI.fragId;
}
_loc7_ = new HTTPStreamRequest(_loc4_);
checkQuality(param1);
notifyFragmentDuration(currentFAI.fragDuration / _loc8_.timeScale);
}
return _loc7_;
}
internal function calculateSegmentDuration(param1:AdobeBootstrapBox, param2:Number) : Number
{
var _loc3_:FragmentDurationPair = null;
var _loc4_:Number = NaN;
var _loc8_:Number = NaN;
var _loc5_:Vector.<FragmentDurationPair> = param1.fragmentRunTables[0].fragmentDurationPairs;
var _loc6_:uint = currentFAI.fragId;
var _loc7_:int = _loc5_.length - 1;
while(_loc7_ >= 0)
{
_loc3_ = _loc5_[_loc7_];
if(_loc3_.firstFragment <= _loc6_)
{
_loc4_ = _loc3_.duration;
_loc8_ = _loc3_.durationAccrued;
_loc8_ = _loc8_ + (_loc6_ - _loc3_.firstFragment) * _loc3_.duration;
if(param2 > 0)
{
_loc4_ -= param2 - _loc8_;
}
return _loc4_;
}
_loc7_--;
}
return 0;
}
private function checkQuality(param1:int) : void
{
var _loc3_:ByteArray = null;
var _loc2_:ByteArray = null;
var _loc4_:FLVTagScriptDataObject = null;
if(currentQuality != param1)
{
_loc3_ = currentQuality < 0 ? null : streamInfos[currentQuality].additionalHeader;
currentQuality = param1;
_loc2_ = streamInfos[currentQuality].additionalHeader;
if(_loc2_ != _loc3_ && _loc2_ != null)
{
_loc4_ = new FLVTagScriptDataObject();
_loc4_.data = _loc2_;
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyScriptData",false,false,false,NaN,null,null,null,null,true,0,_loc4_,true,false));
}
}
}
private function checkMetadata(param1:int, param2:AdobeBootstrapBox) : void
{
if(currentQuality != param1)
{
notifyTotalDuration(param2.totalDuration / param2.timeScale,param1);
}
}
private function refreshBootstrapInfo(param1:uint) : void
{
pendingIndexUpdates = pendingIndexUpdates + 1;
fragmentRunTablesUpdating = true;
dispatchEvent(new HTTPStreamingIndexHandlerEvent("requestLoadIndex",false,false,false,NaN,null,null,new URLRequest(HTTPStreamingUtils.normalizeURL((streamInfos[param1] as HTTPStreamingF4FStreamInfo).bootstrapInfo.url)),param1,true));
}
private function processBootstrapData(param1:*, param2:Object) : AdobeBootstrapBox
{
var _loc3_:* = undefined;
var _loc5_:AdobeBootstrapBox = null;
var _loc4_:BoxParser = new BoxParser();
param1.position = 0;
_loc4_.init(param1);
try
{
_loc3_ = _loc4_.getBoxes();
}
catch(e:Error)
{
_loc3_ = null;
}
if(_loc3_ == null || _loc3_.length < 1)
{
return null;
}
_loc5_ = _loc3_[0] as AdobeBootstrapBox;
if(_loc5_ == null)
{
return null;
}
if(serverBaseURL == null || serverBaseURL.length <= 0)
{
if(_loc5_.serverBaseURLs == null || _loc5_.serverBaseURLs.length <= 0)
{
return null;
}
}
return _loc5_;
}
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 _loc4_:FLVTagScriptDataObject = new FLVTagScriptDataObject();
var _loc3_:Object = this.f4fIndexInfo.streamInfos[param2].streamMetadata;
if(_loc3_ == null)
{
_loc3_ = {};
}
_loc3_.duration = param1;
_loc4_.objects = ["onMetaData",_loc3_];
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyScriptData",false,false,false,NaN,null,null,null,null,false,0,_loc4_,false,true));
}
private function notifyFragmentDuration(param1:Number) : void
{
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifySegmentDuration",false,false,false,NaN,null,null,null,null,true,param1));
}
private function notifyIndexReady(param1:int) : void
{
var _loc3_:AdobeBootstrapBox = bootstrapBoxes[param1];
var _loc2_:AdobeFragmentRunTable = getFragmentRunTable(_loc3_);
dispatchDVRStreamInfo(_loc3_);
if(!dvrGetStreamInfoCall)
{
if(_loc3_.live && f4fIndexInfo.dvrInfo == null && isNaN(pureLiveOffset))
{
pureLiveOffset = _loc3_.currentMediaTime - offsetFromCurrent * _loc3_.timeScale > 0 ? _loc3_.currentMediaTime / _loc3_.timeScale - offsetFromCurrent : NaN;
}
dispatchEvent(new HTTPStreamingIndexHandlerEvent("notifyIndexReady",false,false,_loc3_.live,pureLiveOffset));
}
dvrGetStreamInfoCall = false;
}
private function stopPlaying(param1:AdobeBootstrapBox) : Boolean
{
var _loc2_:AdobeFragmentRunTable = getFragmentRunTable(param1);
if(f4fIndexInfo.dvrInfo == null && param1.live && _loc2_.tableComplete() || f4fIndexInfo.dvrInfo != null && f4fIndexInfo.dvrInfo.offline)
{
return true;
}
return false;
}
private function onNewBootstrapBox(param1:HTTPStreamingFileHandlerEvent) : void
{
var _loc2_:AdobeBootstrapBox = bootstrapBoxes[currentQuality];
if(_loc2_.bootstrapVersion < param1.bootstrapBox.bootstrapVersion || _loc2_.currentMediaTime < param1.bootstrapBox.currentMediaTime)
{
bootstrapBoxes[currentQuality] = param1.bootstrapBox;
dispatchDVRStreamInfo(param1.bootstrapBox);
}
}
private function dispatchDVRStreamInfo(param1:AdobeBootstrapBox) : void
{
var _loc2_:AdobeFragmentRunTable = getFragmentRunTable(param1);
if(f4fIndexInfo.dvrInfo != null)
{
f4fIndexInfo.dvrInfo.isRecording = !_loc2_.tableComplete();
if(isNaN(f4fIndexInfo.dvrInfo.startTime))
{
f4fIndexInfo.dvrInfo.startTime = _loc2_.tableComplete() ? 0 : DVRUtils.calculateOffset(f4fIndexInfo.dvrInfo.beginOffset < 0 || isNaN(f4fIndexInfo.dvrInfo.beginOffset) ? 0 : f4fIndexInfo.dvrInfo.beginOffset,f4fIndexInfo.dvrInfo.endOffset < 0 || isNaN(f4fIndexInfo.dvrInfo.endOffset) ? 0 : f4fIndexInfo.dvrInfo.endOffset,param1.totalDuration / param1.timeScale);
f4fIndexInfo.dvrInfo.startTime += _loc2_.fragmentDurationPairs[0].durationAccrued / param1.timeScale;
if(f4fIndexInfo.dvrInfo.startTime > param1.currentMediaTime)
{
f4fIndexInfo.dvrInfo.startTime = param1.currentMediaTime;
}
}
f4fIndexInfo.dvrInfo.curLength = param1.currentMediaTime / param1.timeScale - f4fIndexInfo.dvrInfo.startTime;
dispatchEvent(new DVRStreamInfoEvent("DVRStreamInfo",false,false,f4fIndexInfo.dvrInfo));
}
}
private function fragmentOverflow(param1:AdobeBootstrapBox, param2:uint) : Boolean
{
var _loc5_:AdobeFragmentRunTable = param1.fragmentRunTables[0];
var _loc3_:FragmentDurationPair = _loc5_.fragmentDurationPairs[0];
var _loc4_:AdobeSegmentRunTable = param1.segmentRunTables[0];
return _loc4_ == null || _loc4_.totalFragments + _loc3_.firstFragment - 1 < param2;
}
private function adjustDelay() : void
{
if(delay < 1)
{
delay *= 2;
if(delay > 1)
{
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();
_serverBaseURL = param1;
_streamInfos = param2;
_dvrInfo = param3;
}
public function get serverBaseURL() : String
{
return _serverBaseURL;
}
public function get streamInfos() : Vector.<HTTPStreamingF4FStreamInfo>
{
return _streamInfos;
}
public function get dvrInfo() : DVRInfo
{
return _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();
_streamName = param2;
_bitrate = param3;
_additionalHeader = param4;
_bootstrap = param1;
_streamMetadata = param5;
_xmpMetadata = param6;
}
public function get streamName() : String
{
return _streamName;
}
public function get bitrate() : Number
{
return _bitrate;
}
public function get additionalHeader() : ByteArray
{
return _additionalHeader;
}
public function get bootstrapInfo() : BootstrapInfo
{
return _bootstrap;
}
public function get streamMetadata() : Object
{
return _streamMetadata;
}
public function get xmpMetadata() : ByteArray
{
return _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 _time;
}
public function set time(param1:Number) : void
{
_time = param1;
}
public function get offset() : Number
{
return _offset;
}
public function set offset(param1:Number) : void
{
_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 _data;
}
public function set data(param1:ByteArray) : void
{
_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();
_firstSegment = param1;
_fragmentsPerSegment = param2;
}
public function get firstSegment() : uint
{
return _firstSegment;
}
public function get fragmentsPerSegment() : uint
{
return _fragmentsPerSegment;
}
public function set fragmentsAccrued(param1:uint) : void
{
_fragmentsAccrued = param1;
}
public function get fragmentsAccrued() : uint
{
return _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)
{
readHeader(param1);
readRest(param1);
}
}
public function get hasAudioTags() : Boolean
{
return _hasAudioTags;
}
public function set hasAudioTags(param1:Boolean) : void
{
_hasAudioTags = param1;
}
public function get hasVideoTags() : Boolean
{
return _hasVideoTags;
}
public function set hasVideoTags(param1:Boolean) : void
{
_hasVideoTags = param1;
}
public function write(param1:IDataOutput) : void
{
param1.writeByte(70);
param1.writeByte(76);
param1.writeByte(86);
param1.writeByte(1);
var _loc3_:uint = 0;
if(_hasAudioTags)
{
_loc3_ |= 4;
}
if(_hasVideoTags)
{
_loc3_ |= 1;
}
param1.writeByte(_loc3_);
var _loc2_:uint = 9;
param1.writeUnsignedInt(_loc2_);
var _loc4_:uint = 0;
param1.writeUnsignedInt(_loc4_);
}
internal function readHeader(param1:IDataInput) : void
{
if(param1.bytesAvailable < 9)
{
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();
_hasAudioTags = _loc2_ & 4 ? true : false;
_hasVideoTags = _loc2_ & 1 ? true : false;
offset = param1.readUnsignedInt();
if(offset < 9)
{
throw new Error("FLVHeader() offset smaller than minimum");
}
}
internal function readRest(param1:IDataInput) : void
{
var _loc2_:ByteArray = null;
if(offset > 9)
{
if(offset - 9 < param1.bytesAvailable - 4)
{
throw new Error("FLVHeader() input too short for nonstandard offset");
}
_loc2_ = new ByteArray();
param1.readBytes(_loc2_,0,offset - 9);
}
if(param1.bytesAvailable < 4)
{
throw new Error("FLVHeader() input too short for previousTagSize0");
}
param1.readUnsignedInt();
}
internal function get restBytesNeeded() : int
{
return 4 + (offset - 9);
}
}
}
@@ -0,0 +1,174 @@
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();
savedBytes = new ByteArray();
if(param1)
{
state = "fileHeader";
}
else
{
state = "type";
}
}
public function flush(param1:IDataOutput) : void
{
param1.writeBytes(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(state)
{
case "fileHeader":
_loc5_ = byteSource(param1,9);
if(_loc5_ != null)
{
flvHeader = new FLVHeader();
flvHeader.readHeader(_loc5_);
state = "fileHeaderRest";
}
else
{
_loc4_ = false;
}
break;
case "fileHeaderRest":
_loc5_ = byteSource(param1,flvHeader.restBytesNeeded);
if(_loc5_ != null)
{
flvHeader.readRest(_loc5_);
state = "type";
}
else
{
_loc4_ = false;
}
break;
case "type":
_loc5_ = byteSource(param1,1);
if(_loc5_ != null)
{
switch(_loc6_ = _loc5_.readByte())
{
case 8:
case 40:
currentTag = new FLVTagAudio(_loc6_);
break;
case 9:
case 41:
currentTag = new FLVTagVideo(_loc6_);
break;
case 18:
case 50:
currentTag = new FLVTagScriptDataObject(_loc6_);
break;
default:
currentTag = new FLVTag(_loc6_);
}
state = "header";
}
else
{
_loc4_ = false;
}
break;
case "header":
_loc5_ = byteSource(param1,11 - 1);
if(_loc5_ != null)
{
currentTag.readRemainingHeader(_loc5_);
if(currentTag.dataSize)
{
state = "data";
}
else
{
state = "prevTag";
}
}
else
{
_loc4_ = false;
}
break;
case "data":
_loc5_ = byteSource(param1,currentTag.dataSize);
if(_loc5_ != null)
{
currentTag.readData(_loc5_);
state = "prevTag";
}
else
{
_loc4_ = false;
}
break;
case "prevTag":
_loc5_ = byteSource(param1,4);
if(_loc5_ != null)
{
currentTag.readPrevTag(_loc5_);
state = "type";
_loc4_ = param3(currentTag);
}
else
{
_loc4_ = false;
}
break;
default:
throw new Error("FLVParser state machine in unknown state");
}
}
if(param2)
{
param1.readBytes(savedBytes,savedBytes.length);
}
}
private function byteSource(param1:IDataInput, param2:int) : IDataInput
{
var _loc3_:int = 0;
if(savedBytes.bytesAvailable + param1.bytesAvailable < param2)
{
return null;
}
if(savedBytes.bytesAvailable)
{
_loc3_ = param2 - savedBytes.bytesAvailable;
if(_loc3_ > 0)
{
param1.readBytes(savedBytes,savedBytes.length,_loc3_);
}
return savedBytes;
}
savedBytes.length = 0;
return param1;
}
}
}
@@ -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 = 40;
public static const TAG_TYPE_ENCRYPTED_VIDEO:int = 41;
public static const TAG_TYPE_ENCRYPTED_SCRIPTDATAOBJECT:int = 50;
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();
bytes = new ByteArray();
bytes.length = 11;
bytes[0] = param1;
}
public function read(param1:IDataInput) : void
{
readType(param1);
readRemainingHeader(param1);
readData(param1);
readPrevTag(param1);
}
public function readType(param1:IDataInput) : void
{
if(param1.bytesAvailable < 1)
{
throw new Error("FLVTag.readType() input too short");
}
param1.readBytes(bytes,0,1);
}
public function readRemaining(param1:IDataInput) : void
{
readRemainingHeader(param1);
readData(param1);
readPrevTag(param1);
}
public function readRemainingHeader(param1:IDataInput) : void
{
if(param1.bytesAvailable < 10)
{
throw new Error("FLVTag.readHeader() input too short");
}
param1.readBytes(bytes,1,11 - 1);
}
public function readData(param1:IDataInput) : void
{
if(dataSize > 0)
{
if(param1.bytesAvailable < dataSize)
{
throw new Error("FLVTag().readData input shorter than dataSize");
}
param1.readBytes(bytes,11,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(bytes,0,11 + dataSize);
param1.writeUnsignedInt(11 + dataSize);
}
public function get tagType() : uint
{
return bytes[0];
}
public function set tagType(param1:uint) : void
{
bytes[0] = param1;
}
public function get isEncrpted() : Boolean
{
return bytes[0] & 0x20 ? true : false;
}
public function get dataSize() : uint
{
return bytes[1] << 16 | bytes[2] << 8 | bytes[3];
}
public function set dataSize(param1:uint) : void
{
bytes[1] = param1 >> 16 & 0xFF;
bytes[2] = param1 >> 8 & 0xFF;
bytes[3] = param1 & 0xFF;
bytes.length = 11 + param1;
}
public function get timestamp() : uint
{
return bytes[7] << 24 | bytes[4] << 16 | bytes[5] << 8 | bytes[6];
}
public function set timestamp(param1:uint) : void
{
bytes[7] = param1 >> 24 & 0xFF;
bytes[4] = param1 >> 16 & 0xFF;
bytes[5] = param1 >> 8 & 0xFF;
bytes[6] = param1 & 0xFF;
}
public function get data() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
_loc1_.writeBytes(bytes,11,dataSize);
return _loc1_;
}
public function set data(param1:ByteArray) : void
{
bytes.length = 11 + param1.length;
bytes.position = 11;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length;
}
}
}
@@ -0,0 +1,258 @@
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[11 + 0];
}
public function set soundFormatByte(param1:int) : void
{
bytes[11 + 0] = param1;
}
public function get soundFormat() : int
{
return bytes[11 + 0] >> 4 & 0x0F;
}
public function set soundFormat(param1:int) : void
{
var _loc2_:Number = 11 + 0;
var _loc3_:int = bytes[_loc2_] & 0x0F;
bytes[_loc2_] = _loc3_;
bytes[11 + 0] |= param1 << 4 & 0xF0;
if(param1 == 10)
{
soundRate = 44100;
soundChannels = 2;
isAACSequenceHeader = false;
}
}
public function get soundRate() : Number
{
switch(bytes[11 + 0] >> 2 & 3)
{
case 0:
return 5512.5;
case 1:
return 11025;
case 2:
return 22050;
case 3:
return 44100;
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 5512.5:
_loc2_ = 0;
break;
case 11025:
_loc2_ = 1;
break;
case 22050:
_loc2_ = 2;
break;
case 44100:
_loc2_ = 3;
break;
default:
throw new Error("set soundRate valid values 5512.5, 11025, 22050, 44100");
}
var _loc3_:Number = 11 + 0;
var _loc4_:int = bytes[_loc3_] & 0xF3;
bytes[_loc3_] = _loc4_;
bytes[11 + 0] |= _loc2_ << 2;
}
public function get soundSize() : int
{
if(bytes[11 + 0] >> 1 & 1)
{
return 16;
}
return 8;
}
public function set soundSize(param1:int) : void
{
switch(param1 - 8)
{
case 0:
var _loc2_:* = 11 + 0;
var _loc3_:* = bytes[_loc2_] & 0xFD;
bytes[_loc2_] = _loc3_;
break;
case 8:
_loc3_ = 11 + 0;
_loc2_ = bytes[_loc3_] | 2;
bytes[_loc3_] = _loc2_;
break;
default:
throw new Error("set soundSize valid values 8, 16");
}
}
public function get soundChannels() : int
{
if(bytes[11 + 0] & 1)
{
return 2;
}
return 1;
}
public function set soundChannels(param1:int) : void
{
switch(param1 - 1)
{
case 0:
var _loc2_:* = 11 + 0;
var _loc3_:* = bytes[_loc2_] & 0xFE;
bytes[_loc2_] = _loc3_;
break;
case 1:
_loc3_ = 11 + 0;
_loc2_ = bytes[_loc3_] | 1;
bytes[_loc3_] = _loc2_;
break;
default:
throw new Error("set soundChannels valid values 1, 2");
}
}
public function get isAACSequenceHeader() : Boolean
{
if(soundFormat != 10)
{
throw new Error("get isAACSequenceHeader not valid if soundFormat != SOUND_FORMAT_AAC");
}
if(bytes[11 + 1] == 0)
{
return true;
}
return false;
}
public function set isAACSequenceHeader(param1:Boolean) : void
{
if(soundFormat != 10)
{
throw new Error("set isAACSequenceHeader not valid if soundFormat != SOUND_FORMAT_AAC");
}
if(param1)
{
bytes[11 + 1] = 0;
}
else
{
bytes[11 + 1] = 1;
}
}
public function get isCodecConfiguration() : Boolean
{
switch(soundFormat - 10)
{
case 0:
if(isAACSequenceHeader)
{
return true;
}
}
return false;
}
override public function get data() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
if(soundFormat == 10)
{
_loc1_.writeBytes(bytes,11 + 2,dataSize - 2);
}
else
{
_loc1_.writeBytes(bytes,11 + 1,dataSize - 1);
}
return _loc1_;
}
override public function set data(param1:ByteArray) : void
{
if(soundFormat == 10)
{
bytes.length = 11 + param1.length + 2;
bytes.position = 11 + 2;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 2;
}
else
{
bytes.length = 11 + param1.length + 1;
bytes.position = 11 + 1;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 1;
}
}
}
}
@@ -0,0 +1,35 @@
package org.osmf.net.httpstreaming.flv
{
public class FLVTagScriptDataObject extends FLVTag
{
public function FLVTagScriptDataObject(param1:int = 18)
{
super(param1);
}
public function get objects() : Array
{
var _loc1_:Array = [];
bytes.position = 11;
while(bytes.bytesAvailable)
{
_loc1_.push(bytes.readObject());
}
return _loc1_;
}
public function set objects(param1:Array) : void
{
bytes.objectEncoding = 0;
bytes.length = 11;
bytes.position = 11;
for each(var _loc2_:Object in param1)
{
bytes.writeObject(_loc2_);
}
dataSize = bytes.length - 11;
}
}
}
@@ -0,0 +1,179 @@
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[11 + 0] >> 4 & 0x0F;
}
public function set frameType(param1:int) : void
{
var _loc2_:Number = 11 + 0;
var _loc3_:int = bytes[_loc2_] & 0x0F;
bytes[_loc2_] = _loc3_;
bytes[11 + 0] |= (param1 & 0x0F) << 4;
}
public function get codecID() : int
{
return bytes[11 + 0] & 0x0F;
}
public function set codecID(param1:int) : void
{
var _loc2_:Number = 11 + 0;
var _loc3_:int = bytes[_loc2_] & 0xF0;
bytes[_loc2_] = _loc3_;
bytes[11 + 0] |= param1 & 0x0F;
}
public function get infoPacketValue() : int
{
if(frameType != 5)
{
throw new Error("get infoPacketValue() not permitted unless frameType is FRAME_TYPE_INFO");
}
return bytes[11 + 1];
}
public function set infoPacketValue(param1:int) : void
{
if(frameType != 5)
{
throw new Error("get infoPacketValue() not permitted unless frameType is FRAME_TYPE_INFO");
}
bytes[11 + 1] = param1;
bytes.length = 11 + 2;
dataSize = 2;
}
public function get avcPacketType() : int
{
if(codecID != 7)
{
throw new Error("get avcPacketType() not permitted unless codecID is CODEC_ID_AVC");
}
return bytes[11 + 1];
}
public function set avcPacketType(param1:int) : void
{
if(codecID != 7)
{
throw new Error("set avcPacketType() not permitted unless codecID is CODEC_ID_AVC");
}
bytes[11 + 1] = param1;
if(avcPacketType != 1)
{
bytes[11 + 2] = 0;
bytes[11 + 3] = 0;
bytes[11 + 4] = 0;
bytes.length = 11 + 5;
dataSize = 5;
}
}
public function get avcCompositionTimeOffset() : int
{
if(codecID != 7 || avcPacketType != 1)
{
throw new Error("get avcCompositionTimeOffset() not permitted unless codecID is CODEC_ID_AVC and avcPacketType is AVC NALU");
}
var _loc1_:int = bytes[11 + 2] << 16;
_loc1_ |= bytes[11 + 3] << 8;
_loc1_ |= bytes[11 + 4];
if(_loc1_ & 0x800000)
{
_loc1_ |= 4278190080;
}
return _loc1_;
}
public function set avcCompositionTimeOffset(param1:int) : void
{
if(codecID != 7 || avcPacketType != 1)
{
throw new Error("set avcCompositionTimeOffset() not permitted unless codecID is CODEC_ID_AVC and avcPacketType is AVC NALU");
}
bytes[11 + 2] = param1 >> 16 & 0xFF;
bytes[11 + 3] = param1 >> 8 & 0xFF;
bytes[11 + 4] = param1 & 0xFF;
}
override public function get data() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
if(codecID == 7)
{
_loc1_.writeBytes(bytes,11 + 5,dataSize - 5);
}
else
{
_loc1_.writeBytes(bytes,11 + 1,dataSize - 1);
}
return _loc1_;
}
override public function set data(param1:ByteArray) : void
{
if(codecID == 7)
{
bytes.length = 11 + param1.length + 5;
bytes.position = 11 + 5;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 5;
}
else
{
bytes.length = 11 + param1.length + 1;
bytes.position = 11 + 1;
bytes.writeBytes(param1,0,param1.length);
dataSize = param1.length + 1;
}
}
}
}
@@ -0,0 +1,77 @@
package org.osmf.net.rtmpstreaming
{
import flash.utils.getTimer;
import org.osmf.net.NetStreamMetricsBase;
import org.osmf.net.SwitchingRuleBase;
public class DroppedFramesRule extends SwitchingRuleBase
{
private static const LOCK_INTERVAL:Number = 30000;
private var downSwitchByOne:int;
private var downSwitchByTwo:int;
private var downSwitchToZero:int;
private var lockLevel:Number;
private var lastLockTime:Number;
public function DroppedFramesRule(param1:NetStreamMetricsBase, param2:int = 10, param3:int = 20, param4:int = 24)
{
super(param1);
this.downSwitchByOne = param2;
this.downSwitchByTwo = param3;
this.downSwitchToZero = param4;
lastLockTime = 0;
lockLevel = 2147483647;
}
override public function getNewIndex() : int
{
var _loc2_:String = null;
var _loc1_:int = -1;
if(metrics.averageDroppedFPS > downSwitchToZero)
{
_loc1_ = 0;
_loc2_ = "Average droppedFPS of " + Math.round(metrics.averageDroppedFPS) + " > " + downSwitchToZero;
}
else if(metrics.averageDroppedFPS > downSwitchByTwo)
{
_loc1_ = metrics.currentIndex - 2 < 0 ? 0 : metrics.currentIndex - 2;
_loc2_ = "Average droppedFPS of " + Math.round(metrics.averageDroppedFPS) + " > " + downSwitchByTwo;
}
else if(metrics.averageDroppedFPS > downSwitchByOne)
{
_loc1_ = metrics.currentIndex - 1 < 0 ? 0 : metrics.currentIndex - 1;
_loc2_ = "Average droppedFPS of " + Math.round(metrics.averageDroppedFPS) + " > " + downSwitchByOne;
}
if(_loc1_ != -1 && _loc1_ < metrics.currentIndex)
{
lockIndex(_loc1_);
}
if(_loc1_ == -1 && isLocked(metrics.currentIndex))
{
_loc1_ = metrics.currentIndex;
}
return _loc1_;
}
private function lockIndex(param1:int) : void
{
if(!isLocked(param1))
{
lockLevel = param1;
lastLockTime = getTimer();
}
}
private function isLocked(param1:int) : Boolean
{
return param1 >= lockLevel && getTimer() - lastLockTime < 30000;
}
}
}
@@ -0,0 +1,44 @@
package org.osmf.net.rtmpstreaming
{
import org.osmf.net.SwitchingRuleBase;
public class InsufficientBandwidthRule extends SwitchingRuleBase
{
private var bitrateMultiplier:Number;
public function InsufficientBandwidthRule(param1:RTMPNetStreamMetrics, param2:Number = 1.15)
{
super(param1);
this.bitrateMultiplier = param2;
}
override public function getNewIndex() : int
{
var _loc3_:* = null;
var _loc1_:int = 0;
var _loc2_:* = -1;
if(rtmpMetrics.averageMaxBytesPerSecond != 0)
{
_loc1_ = rtmpMetrics.currentIndex;
while(_loc1_ >= 0)
{
if(rtmpMetrics.averageMaxBytesPerSecond * 8 / 1024 > rtmpMetrics.resource.streamItems[_loc1_].bitrate * bitrateMultiplier)
{
_loc2_ = _loc1_;
break;
}
_loc1_--;
}
_loc2_ = int(_loc2_ == rtmpMetrics.currentIndex ? -1 : _loc2_);
}
return _loc2_;
}
private function get rtmpMetrics() : RTMPNetStreamMetrics
{
return metrics as RTMPNetStreamMetrics;
}
}
}
@@ -0,0 +1,59 @@
package org.osmf.net.rtmpstreaming
{
import flash.events.NetStatusEvent;
import org.osmf.net.SwitchingRuleBase;
public class InsufficientBufferRule extends SwitchingRuleBase
{
private var _panic:Boolean;
private var _moreDetail:String;
private var minBufferLength:Number;
public function InsufficientBufferRule(param1:RTMPNetStreamMetrics, param2:Number = 2)
{
super(param1);
_panic = false;
this.minBufferLength = param2;
param1.netStream.addEventListener("netStatus",monitorNetStatus,false,0,true);
}
override public function getNewIndex() : int
{
var _loc1_:int = -1;
if(_panic || rtmpMetrics.netStream.bufferLength < minBufferLength && rtmpMetrics.netStream.bufferLength > rtmpMetrics.netStream.bufferTime)
{
_loc1_ = 0;
}
return _loc1_;
}
private function monitorNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case "NetStream.Buffer.Full":
_panic = false;
break;
case "NetStream.Buffer.Empty":
if(Math.round(rtmpMetrics.netStream.time) != 0)
{
_panic = true;
_moreDetail = "Buffer was empty";
}
break;
case "NetStream.Play.InsufficientBW":
_panic = true;
_moreDetail = "Stream had insufficient bandwidth";
}
}
private function get rtmpMetrics() : RTMPNetStreamMetrics
{
return metrics as RTMPNetStreamMetrics;
}
}
}
@@ -0,0 +1,75 @@
package org.osmf.net.rtmpstreaming
{
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.NetStreamPlayOptions;
import org.osmf.media.MediaResourceBase;
import org.osmf.net.DynamicStreamingItem;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.NetConnectionFactoryBase;
import org.osmf.net.NetLoader;
import org.osmf.net.NetStreamLoadTrait;
import org.osmf.net.NetStreamSwitchManager;
import org.osmf.net.NetStreamSwitchManagerBase;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.SwitchingRuleBase;
public class RTMPDynamicStreamingNetLoader extends NetLoader
{
public function RTMPDynamicStreamingNetLoader(param1:NetConnectionFactoryBase = null)
{
super(param1);
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc2_:DynamicStreamingResource = param1 as DynamicStreamingResource;
return _loc2_ != null && NetStreamUtils.isRTMPStream(_loc2_.host) || Boolean(super.canHandleResource(param1));
}
override protected function createNetStreamSwitchManager(param1:NetConnection, param2:NetStream, param3:DynamicStreamingResource) : NetStreamSwitchManagerBase
{
var _loc4_:RTMPNetStreamMetrics = null;
if(param3 != null)
{
_loc4_ = new RTMPNetStreamMetrics(param2);
return new NetStreamSwitchManager(param1,param2,param3,_loc4_,getDefaultSwitchingRules(_loc4_));
}
return null;
}
override protected function reconnectStream(param1:NetStreamLoadTrait) : void
{
var _loc3_:NetStreamPlayOptions = null;
var _loc5_:DynamicStreamingItem = null;
var _loc4_:String = null;
var _loc2_:DynamicStreamingResource = param1.resource as DynamicStreamingResource;
if(_loc2_ == null)
{
super.reconnectStream(param1);
}
else
{
_loc3_ = new NetStreamPlayOptions();
param1.netStream.attach(param1.connection);
_loc3_.transition = "resume";
_loc5_ = _loc2_.streamItems[param1.switchManager.currentIndex];
_loc4_ = _loc5_.streamName;
_loc3_.streamName = _loc4_;
param1.netStream.play2(_loc3_);
}
}
private function getDefaultSwitchingRules(param1:RTMPNetStreamMetrics) : Vector.<SwitchingRuleBase>
{
var _loc2_:Vector.<SwitchingRuleBase> = new Vector.<SwitchingRuleBase>();
_loc2_.push(new SufficientBandwidthRule(param1));
_loc2_.push(new InsufficientBandwidthRule(param1));
_loc2_.push(new DroppedFramesRule(param1));
_loc2_.push(new InsufficientBufferRule(param1));
return _loc2_;
}
}
}
@@ -0,0 +1,64 @@
package org.osmf.net.rtmpstreaming
{
import flash.net.NetStream;
import org.osmf.net.NetStreamMetricsBase;
public class RTMPNetStreamMetrics extends NetStreamMetricsBase
{
private static const DEFAULT_AVG_MAX_BYTES_SAMPLE_SIZE:Number = 50;
private var _averageMaxBytesPerSecondArray:Array;
private var _averageMaxBytesPerSecond:Number;
public function RTMPNetStreamMetrics(param1:NetStream)
{
super(param1);
_averageMaxBytesPerSecondArray = [];
}
public function get averageMaxBytesPerSecond() : Number
{
return _averageMaxBytesPerSecond;
}
override protected function calculateMetrics() : void
{
var _loc4_:Number = NaN;
var _loc1_:Number = NaN;
var _loc3_:Number = NaN;
var _loc2_:* = 0;
super.calculateMetrics();
try
{
_loc4_ = netStream.info.maxBytesPerSecond;
_averageMaxBytesPerSecondArray.unshift(_loc4_);
if(_averageMaxBytesPerSecondArray.length > 50)
{
_averageMaxBytesPerSecondArray.pop();
}
_loc1_ = 0;
_loc3_ = 0;
_loc2_ = 0;
while(_loc2_ < _averageMaxBytesPerSecondArray.length)
{
_loc1_ += _averageMaxBytesPerSecondArray[_loc2_];
_loc3_ = Number(_averageMaxBytesPerSecondArray[_loc2_] > _loc3_ ? _averageMaxBytesPerSecondArray[_loc2_] : _loc3_);
_loc2_++;
}
_averageMaxBytesPerSecond = _averageMaxBytesPerSecondArray.length < 50 ? 0 : (isLive ? _loc3_ : _loc1_ / _averageMaxBytesPerSecondArray.length);
}
catch(error:Error)
{
throw error;
}
}
private function get isLive() : Boolean
{
return resource && resource.streamType == "live";
}
}
}
@@ -0,0 +1,52 @@
package org.osmf.net.rtmpstreaming
{
import org.osmf.net.SwitchingRuleBase;
public class SufficientBandwidthRule extends SwitchingRuleBase
{
private static const BANDWIDTH_SAFETY_MULTIPLE:Number = 1.15;
private static const MIN_DROPPED_FPS:int = 2;
public function SufficientBandwidthRule(param1:RTMPNetStreamMetrics)
{
super(param1);
}
override public function getNewIndex() : int
{
var _loc3_:* = null;
var _loc1_:int = 0;
var _loc2_:* = -1;
if(rtmpMetrics.averageMaxBytesPerSecond != 0)
{
_loc1_ = rtmpMetrics.resource.streamItems.length - 1;
while(_loc1_ >= 0)
{
if(rtmpMetrics.averageMaxBytesPerSecond * 8 / 1024 > rtmpMetrics.resource.streamItems[_loc1_].bitrate * 1.15)
{
_loc2_ = _loc1_;
break;
}
_loc1_--;
}
if(_loc2_ > rtmpMetrics.currentIndex)
{
_loc2_ = int(rtmpMetrics.droppedFPS < 2 && rtmpMetrics.netStream.bufferLength > rtmpMetrics.netStream.bufferTime ? _loc2_ : -1);
}
else
{
_loc2_ = -1;
}
}
return _loc2_;
}
private function get rtmpMetrics() : RTMPNetStreamMetrics
{
return metrics as RTMPNetStreamMetrics;
}
}
}