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,181 @@
package org.osmf.elements
{
import flash.events.NetStatusEvent;
import flash.net.NetStream;
import org.osmf.elements.audioClasses.AudioAudioTrait;
import org.osmf.elements.audioClasses.AudioPlayTrait;
import org.osmf.elements.audioClasses.AudioSeekTrait;
import org.osmf.elements.audioClasses.AudioTimeTrait;
import org.osmf.elements.audioClasses.SoundAdapter;
import org.osmf.elements.audioClasses.SoundLoadTrait;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.DefaultTraitResolver;
import org.osmf.media.LoadableElementBase;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.net.*;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.traits.TimeTrait;
import org.osmf.utils.OSMFStrings;
public class AudioElement extends LoadableElementBase
{
private var soundAdapter:SoundAdapter;
private var stream:NetStream;
private var defaultTimeTrait:ModifiableTimeTrait;
private var _alternateLoaders:Vector.<LoaderBase>;
public function AudioElement(param1:URLResource = null, param2:LoaderBase = null)
{
super(param1,param2);
if(!(param2 == null || param2 is NetLoader || param2 is SoundLoader))
{
throw new ArgumentError(OSMFStrings.getString("invalidParam"));
}
}
public function get defaultDuration() : Number
{
return defaultTimeTrait ? defaultTimeTrait.duration : NaN;
}
public function set defaultDuration(param1:Number) : void
{
if(isNaN(param1) || param1 < 0)
{
if(defaultTimeTrait != null)
{
removeTraitResolver("time");
defaultTimeTrait = null;
}
}
else
{
if(defaultTimeTrait == null)
{
defaultTimeTrait = new ModifiableTimeTrait();
addTraitResolver("time",new DefaultTraitResolver("time",defaultTimeTrait));
}
defaultTimeTrait.duration = param1;
}
}
override public function set resource(param1:MediaResourceBase) : void
{
loader = getLoaderForResource(param1,alternateLoaders);
super.resource = param1;
}
override protected function createLoadTrait(param1:MediaResourceBase, param2:LoaderBase) : LoadTrait
{
return param2 is NetLoader ? new NetStreamLoadTrait(param2,param1) : new SoundLoadTrait(param2,param1);
}
override protected function processReadyState() : void
{
var _loc1_:TimeTrait = null;
var _loc2_:Boolean = false;
var _loc3_:SoundLoadTrait = null;
var _loc5_:LoadTrait = getTrait("load") as LoadTrait;
soundAdapter = null;
stream = null;
var _loc4_:NetStreamLoadTrait = _loc5_ as NetStreamLoadTrait;
if(_loc4_)
{
stream = _loc4_.netStream;
stream.addEventListener("netStatus",onNetStatusEvent);
_loc4_.connection.addEventListener("netStatus",onNetStatusEvent,false,0,true);
_loc2_ = false;
if(loader is NetLoader)
{
_loc2_ = (loader as NetLoader).reconnectStreams;
}
addTrait("play",new NetStreamPlayTrait(stream,resource,_loc2_,_loc4_.connection));
_loc1_ = new NetStreamTimeTrait(stream,resource,defaultDuration);
addTrait("time",_loc1_);
addTrait("seek",new NetStreamSeekTrait(_loc1_,_loc5_,stream));
addTrait("audio",new NetStreamAudioTrait(stream));
addTrait("buffer",new NetStreamBufferTrait(stream));
}
else
{
_loc3_ = _loc5_ as SoundLoadTrait;
soundAdapter = new SoundAdapter(this,_loc3_.sound);
addTrait("play",new AudioPlayTrait(soundAdapter));
_loc1_ = new AudioTimeTrait(soundAdapter);
addTrait("time",_loc1_);
addTrait("seek",new AudioSeekTrait(_loc1_,soundAdapter));
addTrait("audio",new AudioAudioTrait(soundAdapter));
}
}
override protected function processUnloadingState() : void
{
if(stream != null)
{
stream.removeEventListener("netStatus",onNetStatusEvent);
}
var _loc1_:NetStreamLoadTrait = getTrait("load") as NetStreamLoadTrait;
if(_loc1_ != null)
{
_loc1_.connection.removeEventListener("netStatus",onNetStatusEvent);
}
removeTrait("play");
removeTrait("seek");
removeTrait("time");
removeTrait("audio");
removeTrait("buffer");
if(soundAdapter != null)
{
soundAdapter.pause();
}
soundAdapter = null;
stream = null;
}
private function onNetStatusEvent(param1:NetStatusEvent) : void
{
var _loc2_:MediaError = null;
switch(param1.info.code)
{
case "NetStream.Play.Failed":
case "NetStream.Failed":
_loc2_ = new MediaError(15,param1.info.description);
break;
case "NetStream.Play.StreamNotFound":
_loc2_ = new MediaError(16,param1.info.description);
break;
case "NetStream.Play.FileStructureInvalid":
_loc2_ = new MediaError(17,param1.info.description);
break;
case "NetStream.Play.NoSupportedTrackFound":
_loc2_ = new MediaError(18,param1.info.description);
break;
case "NetConnection.Connect.IdleTimeOut":
_loc2_ = new MediaError(14,param1.info.description);
}
if(_loc2_ != null)
{
dispatchEvent(new MediaErrorEvent("mediaError",false,false,_loc2_));
}
}
private function get alternateLoaders() : Vector.<LoaderBase>
{
if(_alternateLoaders == null)
{
_alternateLoaders = new Vector.<LoaderBase>();
_alternateLoaders.push(new SoundLoader());
_alternateLoaders.push(new NetLoader());
}
return _alternateLoaders;
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.elements
{
import org.osmf.media.URLResource;
public class F4MElement extends LoadFromDocumentElement
{
public function F4MElement(param1:URLResource = null, param2:F4MLoader = null)
{
if(param2 == null)
{
param2 = new F4MLoader();
}
super(param1,param2);
}
}
}
@@ -0,0 +1,187 @@
package org.osmf.elements
{
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.net.URLLoader;
import flash.net.URLRequest;
import org.osmf.elements.f4mClasses.DRMAdditionalHeader;
import org.osmf.elements.f4mClasses.Manifest;
import org.osmf.elements.f4mClasses.ManifestParser;
import org.osmf.elements.proxyClasses.LoadFromDocumentLoadTrait;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.DefaultMediaFactory;
import org.osmf.media.MediaElement;
import org.osmf.media.MediaFactory;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.MediaTypeUtil;
import org.osmf.media.URLResource;
import org.osmf.net.httpstreaming.HTTPStreamingUtils;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.URL;
public class F4MLoader extends LoaderBase
{
public static const F4M_MIME_TYPE:String = "application/f4m+xml";
private static const F4M_EXTENSION:String = "f4m";
private var supportedMimeTypes:Vector.<String> = new Vector.<String>();
private var factory:MediaFactory;
private var parser:ManifestParser;
public function F4MLoader(param1:MediaFactory = null)
{
super();
supportedMimeTypes.push("application/f4m+xml");
if(param1 == null)
{
param1 = new DefaultMediaFactory();
}
this.parser = new ManifestParser();
this.factory = param1;
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc2_:URLResource = null;
var _loc3_:String = null;
var _loc4_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,new Vector.<String>(),supportedMimeTypes);
if(_loc4_ == 0)
{
return true;
}
if(param1 is URLResource)
{
_loc2_ = URLResource(param1);
_loc3_ = new URL(_loc2_.url).extension;
return _loc3_ == "f4m";
}
return false;
}
override protected function executeLoad(param1:LoadTrait) : void
{
var manifest:Manifest;
var manifestLoader:URLLoader;
var loadTrait:LoadTrait = param1;
var onError:* = function(param1:ErrorEvent):void
{
manifestLoader.removeEventListener("complete",onComplete);
manifestLoader.removeEventListener("ioError",onError);
manifestLoader.removeEventListener("securityError",onError);
updateLoadTrait(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(0,param1.text)));
};
var onComplete:* = function(param1:Event):void
{
var unfinishedLoads:Number;
var item:DRMAdditionalHeader;
var completionCallback:*;
var event:Event = param1;
manifestLoader.removeEventListener("complete",onComplete);
manifestLoader.removeEventListener("ioError",onError);
manifestLoader.removeEventListener("securityError",onError);
try
{
manifest = parser.parse(event.target.data,getRootUrl(URLResource(loadTrait.resource).url));
}
catch(parseError:Error)
{
updateLoadTrait(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(parseError.errorID,parseError.message)));
}
if(manifest != null)
{
unfinishedLoads = 0;
for each(item in manifest.drmAdditionalHeaders)
{
if(item.url != null)
{
completionCallback = function(param1:Boolean):void
{
if(param1)
{
unfinishedLoads = unfinishedLoads - 1;
}
if(unfinishedLoads == 0)
{
finishLoad();
}
};
unfinishedLoads = unfinishedLoads + 1;
loadAdditionalHeader(item,completionCallback,onError);
}
}
if(unfinishedLoads == 0)
{
finishLoad();
}
}
};
var finishLoad:* = function():void
{
var _loc3_:MediaResourceBase = null;
var _loc1_:MediaElement = null;
var _loc2_:* = null;
try
{
_loc3_ = parser.createResource(manifest,URLResource(loadTrait.resource));
_loc1_ = factory.createMediaElement(_loc3_);
if(_loc1_.hasOwnProperty("defaultDuration") && !isNaN(manifest.duration))
{
_loc1_["defaultDuration"] = manifest.duration;
}
LoadFromDocumentLoadTrait(loadTrait).mediaElement = _loc1_;
updateLoadTrait(loadTrait,"ready");
}
catch(error:Error)
{
updateLoadTrait(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(23,error.message)));
}
};
updateLoadTrait(loadTrait,"loading");
manifestLoader = new URLLoader(new URLRequest(URLResource(loadTrait.resource).url));
manifestLoader.addEventListener("complete",onComplete);
manifestLoader.addEventListener("ioError",onError);
manifestLoader.addEventListener("securityError",onError);
}
override protected function executeUnload(param1:LoadTrait) : void
{
updateLoadTrait(param1,"uninitialized");
}
private function loadAdditionalHeader(param1:DRMAdditionalHeader, param2:Function, param3:Function) : void
{
var item:DRMAdditionalHeader = param1;
var completionCallback:Function = param2;
var onError:Function = param3;
var onDRMLoadComplete:* = function(param1:Event):void
{
param1.target.removeEventListener("complete",onDRMLoadComplete);
param1.target.removeEventListener("ioError",onError);
param1.target.removeEventListener("securityError",onError);
item.data = URLLoader(param1.target).data;
completionCallback(true);
};
var drmLoader:URLLoader = new URLLoader();
drmLoader.dataFormat = "binary";
drmLoader.addEventListener("complete",onDRMLoadComplete);
drmLoader.addEventListener("ioError",onError);
drmLoader.addEventListener("securityError",onError);
drmLoader.load(new URLRequest(HTTPStreamingUtils.normalizeURL(item.url)));
}
private function getRootUrl(param1:String) : String
{
return param1.substr(0,param1.lastIndexOf("/"));
}
}
}
@@ -0,0 +1,85 @@
package org.osmf.elements
{
import flash.display.Bitmap;
import flash.display.Loader;
import org.osmf.elements.loaderClasses.LoaderLoadTrait;
import org.osmf.elements.loaderClasses.LoaderUtils;
import org.osmf.media.LoadableElementBase;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.traits.DisplayObjectTrait;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class ImageElement extends LoadableElementBase
{
private var _smoothing:Boolean;
public function ImageElement(param1:URLResource = null, param2:ImageLoader = null)
{
if(param2 == null)
{
param2 = new ImageLoader();
}
super(param1,param2);
}
public function get smoothing() : Boolean
{
return _smoothing;
}
public function set smoothing(param1:Boolean) : void
{
if(_smoothing != param1)
{
_smoothing = param1;
applySmoothingSetting();
}
}
override protected function createLoadTrait(param1:MediaResourceBase, param2:LoaderBase) : LoadTrait
{
return new LoaderLoadTrait(param2,param1);
}
override protected function processReadyState() : void
{
var _loc1_:LoaderLoadTrait = getTrait("load") as LoaderLoadTrait;
addTrait("displayObject",LoaderUtils.createDisplayObjectTrait(_loc1_.loader,this));
applySmoothingSetting();
}
override protected function processUnloadingState() : void
{
removeTrait("displayObject");
}
private function applySmoothingSetting() : void
{
var _loc2_:Loader = null;
var _loc3_:Bitmap = null;
var _loc1_:DisplayObjectTrait = getTrait("displayObject") as DisplayObjectTrait;
if(_loc1_)
{
_loc2_ = _loc1_.displayObject as Loader;
if(_loc2_ != null)
{
try
{
_loc3_ = _loc2_.content as Bitmap;
if(_loc3_ != null)
{
_loc3_.smoothing = _smoothing;
}
}
catch(error:SecurityError)
{
}
}
}
}
}
}
@@ -0,0 +1,54 @@
package org.osmf.elements
{
import org.osmf.elements.loaderClasses.LoaderUtils;
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.URL;
public class ImageLoader extends LoaderBase
{
private static const MIME_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["image/png","image/gif","image/jpeg"]);
private static const MEDIA_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["image"]);
private var checkPolicyFile:Boolean;
public function ImageLoader(param1:Boolean = true)
{
super();
this.checkPolicyFile = param1;
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc4_:URL = null;
var _loc2_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,MEDIA_TYPES_SUPPORTED,MIME_TYPES_SUPPORTED);
if(_loc2_ != 2)
{
return _loc2_ == 0;
}
var _loc3_:URLResource = param1 as URLResource;
if(_loc3_ != null && _loc3_.url != null)
{
_loc4_ = new URL(_loc3_.url);
return _loc4_.path.search(/\.gif$|\.jpg$|\.png$/i) != -1;
}
return false;
}
override protected function executeLoad(param1:LoadTrait) : void
{
LoaderUtils.loadLoadTrait(param1,updateLoadTrait,false,checkPolicyFile);
}
override protected function executeUnload(param1:LoadTrait) : void
{
LoaderUtils.unloadLoadTrait(param1,updateLoadTrait);
}
}
}
@@ -0,0 +1,425 @@
package org.osmf.elements
{
import flash.events.DRMErrorEvent;
import flash.events.DRMStatusEvent;
import flash.events.Event;
import flash.events.NetStatusEvent;
import flash.events.StatusEvent;
import flash.media.Video;
import flash.net.NetStream;
import flash.system.SystemUpdater;
import flash.utils.ByteArray;
import org.osmf.events.DRMEvent;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.events.TimeEvent;
import org.osmf.media.DefaultTraitResolver;
import org.osmf.media.LoadableElementBase;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.metadata.CuePoint;
import org.osmf.metadata.TimelineMetadata;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.ModifiableTimeTrait;
import org.osmf.net.NetClient;
import org.osmf.net.NetLoader;
import org.osmf.net.NetStreamAudioTrait;
import org.osmf.net.NetStreamBufferTrait;
import org.osmf.net.NetStreamDisplayObjectTrait;
import org.osmf.net.NetStreamDynamicStreamTrait;
import org.osmf.net.NetStreamLoadTrait;
import org.osmf.net.NetStreamPlayTrait;
import org.osmf.net.NetStreamSeekTrait;
import org.osmf.net.NetStreamTimeTrait;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.StreamingURLResource;
import org.osmf.net.drm.NetStreamDRMTrait;
import org.osmf.traits.DisplayObjectTrait;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.traits.MediaTraitBase;
import org.osmf.traits.TimeTrait;
import org.osmf.utils.OSMFStrings;
public class LightweightVideoElement extends LoadableElementBase
{
private static const DRM_STATUS_CODE:String = "DRM.encryptedFLV";
private static const DRM_NEEDS_AUTHENTICATION:int = 3330;
private var displayObjectTrait:DisplayObjectTrait;
private var defaultTimeTrait:ModifiableTimeTrait;
private var stream:NetStream;
private var video:Video;
private var embeddedCuePoints:TimelineMetadata;
private var _smoothing:Boolean;
private var _deblocking:int;
private var drmTrait:NetStreamDRMTrait;
public function LightweightVideoElement(param1:MediaResourceBase = null, param2:NetLoader = null)
{
if(param2 == null)
{
param2 = new NetLoader();
}
super(param1,param2);
if(!(param1 == null || param1 is URLResource))
{
throw new ArgumentError(OSMFStrings.getString("invalidParam"));
}
}
public function get client() : NetClient
{
return stream != null ? stream.client as NetClient : null;
}
public function get defaultDuration() : Number
{
return defaultTimeTrait ? defaultTimeTrait.duration : NaN;
}
public function set defaultDuration(param1:Number) : void
{
if(isNaN(param1) || param1 < 0)
{
if(defaultTimeTrait != null)
{
removeTraitResolver("time");
defaultTimeTrait = null;
}
}
else
{
if(defaultTimeTrait == null)
{
defaultTimeTrait = new ModifiableTimeTrait();
addTraitResolver("time",new DefaultTraitResolver("time",defaultTimeTrait));
}
defaultTimeTrait.duration = param1;
}
}
public function get smoothing() : Boolean
{
return _smoothing;
}
public function set smoothing(param1:Boolean) : void
{
_smoothing = param1;
if(video != null)
{
video.smoothing = param1;
}
}
public function get deblocking() : int
{
return _deblocking;
}
public function set deblocking(param1:int) : void
{
_deblocking = param1;
if(video != null)
{
video.deblocking = param1;
}
}
public function get currentFPS() : Number
{
return stream != null ? stream.currentFPS : 0;
}
override protected function createLoadTrait(param1:MediaResourceBase, param2:LoaderBase) : LoadTrait
{
return new NetStreamLoadTrait(param2,param1);
}
protected function createVideo() : Video
{
return new Video();
}
override protected function processReadyState() : void
{
var _loc2_:ByteArray = null;
var _loc3_:NetStreamLoadTrait = getTrait("load") as NetStreamLoadTrait;
stream = _loc3_.netStream;
video = createVideo();
video.smoothing = _smoothing;
video.deblocking = _deblocking;
video.width = video.height = 0;
video.attachNetStream(stream);
NetClient(stream.client).addHandler("onMetaData",onMetaData);
NetClient(stream.client).addHandler("onCuePoint",onCuePoint);
stream.addEventListener("netStatus",onNetStatusEvent);
_loc3_.connection.addEventListener("netStatus",onNetStatusEvent,false,0,true);
stream.addEventListener("drmError",onDRMErrorEvent);
var _loc1_:StreamingURLResource = resource as StreamingURLResource;
if(_loc1_ != null && _loc1_.drmContentData)
{
_loc2_ = _loc1_.drmContentData;
setupDRMTrait(_loc2_);
}
else
{
stream.addEventListener("status",onStatus);
stream.addEventListener("drmStatus",onDRMStatus);
}
finishLoad();
}
private function onStatus(param1:StatusEvent) : void
{
if(param1.code == "DRM.encryptedFLV" && getTrait("drm") == null)
{
createDRMTrait();
}
}
private function onDRMStatus(param1:DRMStatusEvent) : void
{
drmTrait.inlineOnVoucher(param1);
}
private function reloadAfterAuth(param1:DRMEvent) : void
{
var _loc2_:NetStreamLoadTrait = null;
if(drmTrait.drmState == "authenticationComplete")
{
_loc2_ = getTrait("load") as NetStreamLoadTrait;
if(_loc2_.loadState == "ready")
{
_loc2_.unload();
}
_loc2_.load();
}
}
private function createDRMTrait() : void
{
drmTrait = new NetStreamDRMTrait();
addTrait("drm",drmTrait);
}
private function setupDRMTrait(param1:ByteArray) : void
{
createDRMTrait();
drmTrait.drmMetadata = param1;
}
private function onDRMErrorEvent(param1:DRMErrorEvent) : void
{
if(param1.errorID == 3330)
{
drmTrait.addEventListener("drmStateChange",reloadAfterAuth);
drmTrait.drmMetadata = param1.contentData;
}
else if(param1.drmUpdateNeeded)
{
update("drm");
}
else if(param1.systemUpdateNeeded)
{
update("system");
}
else
{
drmTrait.inlineDRMFailed(new MediaError(param1.errorID));
}
}
private function update(param1:String) : void
{
if(drmTrait == null)
{
createDRMTrait();
}
var _loc2_:SystemUpdater = drmTrait.update(param1);
_loc2_.addEventListener("complete",onUpdateComplete);
}
private function finishLoad() : void
{
var timeTrait:TimeTrait;
var reconnectStreams:Boolean;
var onDurationChange:*;
var dsResource:DynamicStreamingResource;
var dsTrait:MediaTraitBase;
var loadTrait:NetStreamLoadTrait = getTrait("load") as NetStreamLoadTrait;
var trait:MediaTraitBase = loadTrait.getTrait("dvr");
if(trait != null)
{
addTrait("dvr",trait);
}
trait = loadTrait.getTrait("audio");
addTrait("audio",trait || new NetStreamAudioTrait(stream));
trait = loadTrait.getTrait("buffer");
addTrait("buffer",trait || new NetStreamBufferTrait(stream));
timeTrait = (trait = loadTrait.getTrait("time")) as TimeTrait;
if(timeTrait == null)
{
timeTrait = new NetStreamTimeTrait(stream,loadTrait.resource,defaultDuration);
}
addTrait("time",timeTrait);
trait = loadTrait.getTrait("displayObject");
addTrait("displayObject",trait || new NetStreamDisplayObjectTrait(stream,video,NaN,NaN));
trait = loadTrait.getTrait("play");
reconnectStreams = false;
reconnectStreams = (loader as NetLoader).reconnectStreams;
addTrait("play",trait || new NetStreamPlayTrait(stream,resource,reconnectStreams,loadTrait.connection));
trait = loadTrait.getTrait("seek");
if(trait == null && NetStreamUtils.getStreamType(resource) != "live")
{
trait = new NetStreamSeekTrait(timeTrait,loadTrait,stream,video);
}
if(trait != null)
{
if(isNaN(timeTrait.duration) || timeTrait.duration == 0)
{
onDurationChange = function(param1:TimeEvent):void
{
timeTrait.removeEventListener("durationChange",onDurationChange);
addTrait("seek",trait);
};
timeTrait.addEventListener("durationChange",onDurationChange);
}
else
{
addTrait("seek",trait);
}
}
dsResource = resource as DynamicStreamingResource;
if(dsResource != null && loadTrait.switchManager != null)
{
dsTrait = loadTrait.getTrait("dynamicStream");
addTrait("dynamicStream",dsTrait || new NetStreamDynamicStreamTrait(stream,loadTrait.switchManager,dsResource));
}
}
override protected function processUnloadingState() : void
{
var _loc1_:NetStreamLoadTrait = getTrait("load") as NetStreamLoadTrait;
NetClient(stream.client).removeHandler("onMetaData",onMetaData);
stream.removeEventListener("netStatus",onNetStatusEvent);
_loc1_.connection.removeEventListener("netStatus",onNetStatusEvent);
removeTrait("audio");
removeTrait("buffer");
removeTrait("play");
removeTrait("time");
removeTrait("displayObject");
removeTrait("seek");
removeTrait("dynamicStream");
removeTrait("dvr");
stream.removeEventListener("drmError",onDRMErrorEvent);
stream.removeEventListener("drmStatus",onDRMStatus);
stream.removeEventListener("status",onStatus);
if(drmTrait != null)
{
drmTrait.removeEventListener("drmStateChange",reloadAfterAuth);
removeTrait("drm");
drmTrait = null;
}
video.attachNetStream(null);
stream = null;
video = null;
displayObjectTrait = null;
}
private function onMetaData(param1:Object) : void
{
var _loc3_:TimelineMetadata = null;
var _loc4_:int = 0;
var _loc5_:CuePoint = null;
var _loc2_:Array = param1.cuePoints;
if(_loc2_ != null && _loc2_.length > 0)
{
_loc3_ = getMetadata("http://www.osmf.org/timeline/dynamicCuePoints/1.0") as TimelineMetadata;
if(_loc3_ == null)
{
_loc3_ = new TimelineMetadata(this);
addMetadata("http://www.osmf.org/timeline/dynamicCuePoints/1.0",_loc3_);
}
_loc4_ = 0;
while(_loc4_ < _loc2_.length)
{
_loc5_ = new CuePoint(_loc2_[_loc4_].type,_loc2_[_loc4_].time,_loc2_[_loc4_].name,_loc2_[_loc4_].parameters);
try
{
_loc3_.addMarker(_loc5_);
}
catch(error:ArgumentError)
{
}
_loc4_++;
}
}
}
private function onCuePoint(param1:Object) : void
{
if(embeddedCuePoints == null)
{
embeddedCuePoints = new TimelineMetadata(this);
addMetadata("http://www.osmf.org/timeline/embeddedCuePoints/1.0",embeddedCuePoints);
}
var _loc2_:CuePoint = new CuePoint(param1.type,param1.time,param1.name,param1.parameters);
try
{
embeddedCuePoints.addMarker(_loc2_);
}
catch(error:ArgumentError)
{
}
}
private function onUpdateComplete(param1:Event) : void
{
(getTrait("load") as LoadTrait).unload();
(getTrait("load") as LoadTrait).load();
}
private function onNetStatusEvent(param1:NetStatusEvent) : void
{
var _loc2_:MediaError = null;
switch(param1.info.code)
{
case "NetStream.Play.Failed":
case "NetStream.Failed":
_loc2_ = new MediaError(15,param1.info.description);
break;
case "NetStream.Play.StreamNotFound":
_loc2_ = new MediaError(16,param1.info.description);
break;
case "NetStream.Play.FileStructureInvalid":
_loc2_ = new MediaError(17,param1.info.description);
break;
case "NetStream.Play.NoSupportedTrackFound":
_loc2_ = new MediaError(18,param1.info.description);
break;
case "NetConnection.Connect.IdleTimeOut":
_loc2_ = new MediaError(14,param1.info.description);
}
if(param1.info.code == "DRM.UpdateNeeded")
{
update("drm");
}
if(_loc2_ != null)
{
dispatchEvent(new MediaErrorEvent("mediaError",false,false,_loc2_));
}
}
}
}
@@ -0,0 +1,88 @@
package org.osmf.elements
{
import flash.events.Event;
import org.osmf.elements.proxyClasses.LoadFromDocumentLoadTrait;
import org.osmf.events.LoadEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.OSMFStrings;
public class LoadFromDocumentElement extends ProxyElement
{
private var _resource:MediaResourceBase;
private var loadTrait:LoadFromDocumentLoadTrait;
private var loader:LoaderBase;
public function LoadFromDocumentElement(param1:MediaResourceBase = null, param2:LoaderBase = null)
{
super(null);
this.loader = param2;
this.resource = param1;
if(param2 == null)
{
throw new ArgumentError(OSMFStrings.getString("nullParam"));
}
}
override public function set resource(param1:MediaResourceBase) : void
{
if(_resource != param1 && param1 != null)
{
_resource = param1;
loadTrait = new LoadFromDocumentLoadTrait(loader,resource);
loadTrait.addEventListener("loadStateChange",onLoadStateChange,false,2147483647);
if(super.getTrait("load") != null)
{
super.removeTrait("load");
}
super.addTrait("load",loadTrait);
}
}
override public function get resource() : MediaResourceBase
{
return _resource;
}
private function onLoaderStateChange(param1:Event) : void
{
removeTrait("load");
proxiedElement = loadTrait.mediaElement;
}
private function onLoadStateChange(param1:LoadEvent) : void
{
var proxiedLoadTrait:LoadTrait;
var onProxiedElementLoadStateChange:*;
var event:LoadEvent = param1;
if(event.loadState == "ready")
{
onProxiedElementLoadStateChange = function(param1:LoadEvent):void
{
if(param1.loadState == "loading")
{
param1.stopImmediatePropagation();
}
else
{
proxiedLoadTrait.removeEventListener("loadStateChange",onProxiedElementLoadStateChange);
}
};
event.stopImmediatePropagation();
removeTrait("load");
proxiedLoadTrait = loadTrait.mediaElement.getTrait("load") as LoadTrait;
proxiedLoadTrait.addEventListener("loadStateChange",onProxiedElementLoadStateChange,false,2147483647);
proxiedElement = loadTrait.mediaElement;
if(proxiedLoadTrait.loadState == "uninitialized")
{
proxiedLoadTrait.load();
}
}
}
}
}
@@ -0,0 +1,282 @@
package org.osmf.elements
{
import org.osmf.elements.proxyClasses.ProxyMetadata;
import org.osmf.events.ContainerChangeEvent;
import org.osmf.events.MediaElementEvent;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaElement;
import org.osmf.media.MediaResourceBase;
import org.osmf.metadata.Metadata;
import org.osmf.traits.MediaTraitBase;
import org.osmf.traits.MediaTraitType;
import org.osmf.utils.OSMFStrings;
public class ProxyElement extends MediaElement
{
private var _proxiedMetadata:ProxyMetadata;
private var _proxiedElement:MediaElement;
private var _blockedTraits:Vector.<String>;
public function ProxyElement(param1:MediaElement = null)
{
super();
this.addEventListener("traitAdd",onProxyTraitAdd,false,2147483647);
this.addEventListener("traitRemove",onProxyTraitRemove,false,2147483647);
this.addEventListener("containerChange",onProxyContainerChange);
this.proxiedElement = param1;
}
public function get proxiedElement() : MediaElement
{
return _proxiedElement;
}
public function set proxiedElement(param1:MediaElement) : void
{
var _loc2_:* = null;
if(param1 != _proxiedElement)
{
if(_proxiedElement != null)
{
toggleMediaElementListeners(_proxiedElement,false);
for each(_loc2_ in _proxiedElement.traitTypes)
{
if(super.hasTrait(_loc2_) == false && (_blockedTraits == null || _blockedTraits.indexOf(_loc2_) == -1))
{
super.dispatchEvent(new MediaElementEvent("traitRemove",false,false,_loc2_));
}
}
}
_proxiedElement = param1;
if(_proxiedElement != null)
{
ProxyMetadata(metadata).metadata = _proxiedElement.metadata;
_proxiedElement.dispatchEvent(new ContainerChangeEvent("containerChange",false,false,_proxiedElement.container,container));
toggleMediaElementListeners(_proxiedElement,true);
for each(_loc2_ in _proxiedElement.traitTypes)
{
if(super.hasTrait(_loc2_) == false && (_blockedTraits == null || _blockedTraits.indexOf(_loc2_) == -1))
{
super.dispatchEvent(new MediaElementEvent("traitAdd",false,false,_loc2_));
}
}
}
}
}
override public function get traitTypes() : Vector.<String>
{
var _loc2_:Vector.<String> = new Vector.<String>();
for each(var _loc1_:String in MediaTraitType.ALL_TYPES)
{
if(hasTrait(_loc1_))
{
_loc2_.push(_loc1_);
}
}
return _loc2_;
}
override public function hasTrait(param1:String) : Boolean
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString("invalidParam"));
}
return getTrait(param1) != null;
}
override public function getTrait(param1:String) : MediaTraitBase
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString("invalidParam"));
}
var _loc2_:MediaTraitBase = null;
if(blocksTrait(param1) == false)
{
_loc2_ = super.getTrait(param1) || (proxiedElement != null ? proxiedElement.getTrait(param1) : null);
}
return _loc2_;
}
override public function get resource() : MediaResourceBase
{
return proxiedElement ? proxiedElement.resource : null;
}
override public function set resource(param1:MediaResourceBase) : void
{
if(proxiedElement != null)
{
proxiedElement.resource = param1;
}
}
override protected function addTrait(param1:String, param2:MediaTraitBase) : void
{
if(blocksTrait(param1) == false && proxiedElement != null && proxiedElement.hasTrait(param1) == true)
{
super.dispatchEvent(new MediaElementEvent("traitRemove",false,false,param1));
}
super.addTrait(param1,param2);
}
override protected function removeTrait(param1:String) : MediaTraitBase
{
var _loc2_:MediaTraitBase = super.removeTrait(param1);
if(blocksTrait(param1) == false && proxiedElement != null && proxiedElement.hasTrait(param1) == true)
{
super.dispatchEvent(new MediaElementEvent("traitAdd",false,false,param1));
}
return _loc2_;
}
override protected function createMetadata() : Metadata
{
return new ProxyMetadata();
}
final protected function get blockedTraits() : Vector.<String>
{
if(_blockedTraits == null)
{
_blockedTraits = new Vector.<String>();
}
return _blockedTraits;
}
final protected function set blockedTraits(param1:Vector.<String>) : void
{
var _loc4_:* = null;
if(param1 == _blockedTraits)
{
return;
}
var _loc3_:Array = [];
var _loc2_:Array = [];
if(_proxiedElement != null)
{
for each(_loc4_ in MediaTraitType.ALL_TYPES)
{
if(param1.indexOf(_loc4_) != -1)
{
if(_blockedTraits == null || _blockedTraits.indexOf(_loc4_) == -1)
{
_loc3_.push(_loc4_);
}
}
else if(_blockedTraits != null && _blockedTraits.indexOf(_loc4_) != -1)
{
_loc2_.push(_loc4_);
}
}
}
if(_proxiedElement != null)
{
for each(_loc4_ in _loc3_)
{
if(proxiedElement.hasTrait(_loc4_) || Boolean(super.hasTrait(_loc4_)))
{
dispatchEvent(new MediaElementEvent("traitRemove",false,false,_loc4_));
}
}
_blockedTraits = param1;
for each(_loc4_ in _loc2_)
{
if(proxiedElement.hasTrait(_loc4_) || Boolean(super.hasTrait(_loc4_)))
{
dispatchEvent(new MediaElementEvent("traitAdd",false,false,_loc4_));
}
}
}
else
{
_blockedTraits = param1;
}
}
private function toggleMediaElementListeners(param1:MediaElement, param2:Boolean) : void
{
if(param2)
{
_proxiedElement.addEventListener("mediaError",onMediaError);
_proxiedElement.addEventListener("traitAdd",onTraitAdd);
_proxiedElement.addEventListener("traitRemove",onTraitRemove);
_proxiedElement.addEventListener("metadataAdd",onMetadataEvent);
_proxiedElement.addEventListener("metadataRemove",onMetadataEvent);
}
else
{
_proxiedElement.removeEventListener("mediaError",onMediaError);
_proxiedElement.removeEventListener("traitAdd",onTraitAdd);
_proxiedElement.removeEventListener("traitRemove",onTraitRemove);
_proxiedElement.removeEventListener("metadataAdd",onMetadataEvent);
_proxiedElement.removeEventListener("metadataRemove",onMetadataEvent);
}
}
private function onMediaError(param1:MediaErrorEvent) : void
{
dispatchEvent(param1.clone());
}
private function onTraitAdd(param1:MediaElementEvent) : void
{
processTraitsChangeEvent(param1);
}
private function onTraitRemove(param1:MediaElementEvent) : void
{
processTraitsChangeEvent(param1);
}
private function onMetadataEvent(param1:MediaElementEvent) : void
{
dispatchEvent(param1.clone());
}
private function onProxyContainerChange(param1:ContainerChangeEvent) : void
{
if(proxiedElement != null)
{
proxiedElement.dispatchEvent(param1.clone());
}
}
private function onProxyTraitAdd(param1:MediaElementEvent) : void
{
processProxyTraitsChangeEvent(param1);
}
private function onProxyTraitRemove(param1:MediaElementEvent) : void
{
processProxyTraitsChangeEvent(param1);
}
private function processTraitsChangeEvent(param1:MediaElementEvent) : void
{
if(blocksTrait(param1.traitType) == false && super.hasTrait(param1.traitType) == false)
{
super.dispatchEvent(param1.clone());
}
}
private function processProxyTraitsChangeEvent(param1:MediaElementEvent) : void
{
if(blocksTrait(param1.traitType) == true)
{
param1.stopImmediatePropagation();
}
}
private function blocksTrait(param1:String) : Boolean
{
return _blockedTraits && _blockedTraits.indexOf(param1) != -1;
}
}
}
@@ -0,0 +1,40 @@
package org.osmf.elements
{
import org.osmf.elements.loaderClasses.LoaderLoadTrait;
import org.osmf.elements.loaderClasses.LoaderUtils;
import org.osmf.media.LoadableElementBase;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class SWFElement extends LoadableElementBase
{
public function SWFElement(param1:URLResource = null, param2:SWFLoader = null)
{
if(param2 == null)
{
param2 = new SWFLoader();
}
super(param1,param2);
}
override protected function createLoadTrait(param1:MediaResourceBase, param2:LoaderBase) : LoadTrait
{
return new LoaderLoadTrait(param2,param1);
}
override protected function processReadyState() : void
{
var _loc1_:LoaderLoadTrait = getTrait("load") as LoaderLoadTrait;
addTrait("displayObject",LoaderUtils.createDisplayObjectTrait(_loc1_.loader,this));
}
override protected function processUnloadingState() : void
{
removeTrait("displayObject");
}
}
}
@@ -0,0 +1,68 @@
package org.osmf.elements
{
import org.osmf.elements.loaderClasses.LoaderUtils;
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.URL;
public class SWFLoader extends LoaderBase
{
public static var allowValidationOfLoadedContent:Boolean = true;
private static const MIME_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["application/x-shockwave-flash"]);
private static const MEDIA_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["swf"]);
private var useCurrentSecurityDomain:Boolean = false;
private var _validateLoadedContentFunction:Function = null;
public function SWFLoader(param1:Boolean = false)
{
super();
this.useCurrentSecurityDomain = param1;
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc4_:URL = null;
var _loc2_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,MEDIA_TYPES_SUPPORTED,MIME_TYPES_SUPPORTED);
if(_loc2_ != 2)
{
return _loc2_ == 0;
}
var _loc3_:URLResource = param1 as URLResource;
if(_loc3_ != null && _loc3_.url != null)
{
_loc4_ = new URL(_loc3_.url);
return _loc4_.path.search(/\.swf$/i) != -1;
}
return false;
}
override protected function executeLoad(param1:LoadTrait) : void
{
LoaderUtils.loadLoadTrait(param1,updateLoadTrait,useCurrentSecurityDomain,false,validateLoadedContentFunction);
}
override protected function executeUnload(param1:LoadTrait) : void
{
LoaderUtils.unloadLoadTrait(param1,updateLoadTrait);
}
public function get validateLoadedContentFunction() : Function
{
return allowValidationOfLoadedContent ? _validateLoadedContentFunction : null;
}
public function set validateLoadedContentFunction(param1:Function) : void
{
_validateLoadedContentFunction = param1;
}
}
}
@@ -0,0 +1,138 @@
package org.osmf.elements
{
import flash.errors.IOError;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.media.Sound;
import flash.media.SoundLoaderContext;
import flash.net.URLRequest;
import org.osmf.elements.audioClasses.SoundLoadTrait;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
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.URL;
public class SoundLoader extends LoaderBase
{
private static const MIN_BYTES_TO_RECEIVE:int = 16;
private static const MIME_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["audio/mpeg"]);
private static const MEDIA_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["audio"]);
private var checkPolicyFile:Boolean;
public function SoundLoader(param1:Boolean = false)
{
super();
this.checkPolicyFile = param1;
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc2_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,MEDIA_TYPES_SUPPORTED,MIME_TYPES_SUPPORTED);
if(_loc2_ != 2)
{
return _loc2_ == 0;
}
var _loc3_:URLResource = param1 as URLResource;
if(_loc3_ == null || _loc3_.url == null || _loc3_.url.length <= 0)
{
return false;
}
var _loc4_:URL = new URL(_loc3_.url);
if(_loc4_.protocol == "")
{
return _loc4_.path.search(/\.mp3$|\.m4a$/i) != -1;
}
if(_loc4_.protocol.search(/file$|http$|https$/i) != -1)
{
return _loc4_.path == null || _loc4_.path.length <= 0 || _loc4_.path.indexOf(".") == -1 || _loc4_.path.search(/\.mp3$|\.m4a$/i) != -1;
}
return false;
}
override protected function executeLoad(param1:LoadTrait) : void
{
var sound:Sound;
var urlRequest:URLRequest;
var context:SoundLoaderContext;
var loadTrait:LoadTrait = param1;
var toggleSoundListeners:* = function(param1:Sound, param2:Boolean):void
{
if(param2)
{
param1.addEventListener("progress",onProgress);
param1.addEventListener("ioError",onIOError);
}
else
{
param1.removeEventListener("progress",onProgress);
param1.removeEventListener("ioError",onIOError);
}
};
var onProgress:* = function(param1:ProgressEvent):void
{
if(param1.bytesTotal >= 16 && soundLoadTrait.loadState == "loading")
{
toggleSoundListeners(sound,false);
soundLoadTrait.sound = sound;
updateLoadTrait(soundLoadTrait,"ready");
}
};
var onIOError:* = function(param1:IOErrorEvent, param2:String = null):void
{
toggleSoundListeners(sound,false);
updateLoadTrait(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(1,param1 ? param1.text : param2)));
};
var handleSecurityError:* = function(param1:String):void
{
toggleSoundListeners(sound,false);
updateLoadTrait(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(2,param1)));
};
var soundLoadTrait:SoundLoadTrait = loadTrait as SoundLoadTrait;
updateLoadTrait(soundLoadTrait,"loading");
sound = new Sound();
toggleSoundListeners(sound,true);
urlRequest = new URLRequest((soundLoadTrait.resource as URLResource).url.toString());
context = new SoundLoaderContext(1000,checkPolicyFile);
try
{
sound.load(urlRequest,context);
}
catch(ioError:IOError)
{
onIOError(null,ioError.message);
}
catch(securityError:SecurityError)
{
handleSecurityError(securityError.message);
}
}
override protected function executeUnload(param1:LoadTrait) : void
{
var _loc2_:SoundLoadTrait = param1 as SoundLoadTrait;
updateLoadTrait(_loc2_,"unloading");
try
{
if(_loc2_.sound != null)
{
_loc2_.sound.close();
}
}
catch(error:IOError)
{
}
updateLoadTrait(_loc2_,"uninitialized");
}
}
}
@@ -0,0 +1,40 @@
package org.osmf.elements
{
import org.osmf.media.MediaResourceBase;
import org.osmf.net.NetLoader;
import org.osmf.net.httpstreaming.HTTPStreamingNetLoader;
import org.osmf.net.rtmpstreaming.RTMPDynamicStreamingNetLoader;
import org.osmf.traits.LoaderBase;
public class VideoElement extends LightweightVideoElement
{
private var _alternateLoaders:Vector.<LoaderBase>;
public function VideoElement(param1:MediaResourceBase = null, param2:NetLoader = null)
{
super(null,null);
super.loader = param2;
this.resource = param1;
}
override public function set resource(param1:MediaResourceBase) : void
{
loader = getLoaderForResource(param1,alternateLoaders);
super.resource = param1;
}
private function get alternateLoaders() : Vector.<LoaderBase>
{
if(_alternateLoaders == null)
{
_alternateLoaders = new Vector.<LoaderBase>();
_alternateLoaders.push(new HTTPStreamingNetLoader());
_alternateLoaders.push(new RTMPDynamicStreamingNetLoader());
_alternateLoaders.push(new NetLoader());
}
return _alternateLoaders;
}
}
}
@@ -0,0 +1,41 @@
package org.osmf.elements.audioClasses
{
import flash.media.SoundTransform;
import org.osmf.traits.AudioTrait;
public class AudioAudioTrait extends AudioTrait
{
private var soundAdapter:SoundAdapter;
public function AudioAudioTrait(param1:SoundAdapter)
{
super();
this.soundAdapter = param1;
param1.soundTransform.volume = volume;
param1.soundTransform.pan = pan;
}
override protected function volumeChangeStart(param1:Number) : void
{
var _loc2_:SoundTransform = soundAdapter.soundTransform;
_loc2_.volume = muted ? 0 : param1;
soundAdapter.soundTransform = _loc2_;
}
override protected function mutedChangeStart(param1:Boolean) : void
{
var _loc2_:SoundTransform = soundAdapter.soundTransform;
_loc2_.volume = param1 ? 0 : volume;
soundAdapter.soundTransform = _loc2_;
}
override protected function panChangeStart(param1:Number) : void
{
var _loc2_:SoundTransform = soundAdapter.soundTransform;
_loc2_.pan = param1;
soundAdapter.soundTransform = _loc2_;
}
}
}
@@ -0,0 +1,55 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import org.osmf.traits.PlayTrait;
public class AudioPlayTrait extends PlayTrait
{
private var lastPlayFailed:Boolean = false;
private var soundAdapter:SoundAdapter;
public function AudioPlayTrait(param1:SoundAdapter)
{
super();
this.soundAdapter = param1;
param1.addEventListener("complete",onPlaybackComplete,false,1,true);
}
override protected function playStateChangeStart(param1:String) : void
{
if(param1 == "playing")
{
lastPlayFailed = !soundAdapter.play();
}
else if(param1 == "paused")
{
soundAdapter.pause();
}
else if(param1 == "stopped")
{
soundAdapter.stop();
}
}
override protected function playStateChangeEnd() : void
{
if(lastPlayFailed)
{
stop();
lastPlayFailed = false;
}
else
{
super.playStateChangeEnd();
}
}
private function onPlaybackComplete(param1:Event) : void
{
stop();
}
}
}
@@ -0,0 +1,35 @@
package org.osmf.elements.audioClasses
{
import org.osmf.traits.SeekTrait;
import org.osmf.traits.TimeTrait;
public class AudioSeekTrait extends SeekTrait
{
private var soundAdapter:SoundAdapter;
public function AudioSeekTrait(param1:TimeTrait, param2:SoundAdapter)
{
super(param1);
this.soundAdapter = param2;
}
override protected function seekingChangeStart(param1:Boolean, param2:Number) : void
{
if(param1)
{
soundAdapter.seek(param2);
}
}
override protected function seekingChangeEnd(param1:Number) : void
{
super.seekingChangeEnd(param1);
if(seeking == true)
{
setSeeking(false,param1);
}
}
}
}
@@ -0,0 +1,45 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import org.osmf.traits.TimeTrait;
public class AudioTimeTrait extends TimeTrait
{
private var soundAdapter:SoundAdapter;
public function AudioTimeTrait(param1:SoundAdapter)
{
super();
this.soundAdapter = param1;
param1.addEventListener("progress",onDownloadProgress,false,0,true);
param1.addEventListener("downloadComplete",onDownloadComplete,false,0,true);
param1.addEventListener("complete",onPlaybackComplete,false,0,true);
}
override public function get currentTime() : Number
{
return soundAdapter.currentTime;
}
private function onDownloadProgress(param1:Event) : void
{
if(!isNaN(soundAdapter.estimatedDuration) && soundAdapter.estimatedDuration > 0)
{
soundAdapter.removeEventListener("progress",onDownloadProgress);
setDuration(soundAdapter.estimatedDuration);
}
}
private function onDownloadComplete(param1:Event) : void
{
setDuration(soundAdapter.estimatedDuration);
}
private function onPlaybackComplete(param1:Event) : void
{
signalComplete();
}
}
}
@@ -0,0 +1,162 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaElement;
public class SoundAdapter extends EventDispatcher
{
public static const DOWNLOAD_COMPLETE:String = "downloadComplete";
private var owner:MediaElement;
private var _soundTransform:SoundTransform;
private var sound:Sound;
private var playing:Boolean = false;
private var channel:SoundChannel;
private var lastStartTime:Number = 0;
public function SoundAdapter(param1:MediaElement, param2:Sound)
{
super();
this.owner = param1;
this.sound = param2;
_soundTransform = new SoundTransform();
param2.addEventListener("complete",onDownloadComplete,false,0,true);
param2.addEventListener("progress",onProgress,false,0,true);
param2.addEventListener("ioError",onIOError,false,0,true);
}
public function get currentTime() : Number
{
return channel != null ? channel.position / 1000 : lastStartTime / 1000;
}
public function get estimatedDuration() : Number
{
return sound.length / (1000 * sound.bytesLoaded / sound.bytesTotal);
}
public function get soundTransform() : SoundTransform
{
return _soundTransform;
}
public function set soundTransform(param1:SoundTransform) : void
{
_soundTransform = param1;
if(channel != null)
{
channel.soundTransform = param1;
}
}
public function play(param1:Number = -1) : Boolean
{
var _loc2_:Boolean = false;
if(channel == null)
{
try
{
channel = sound.play(param1 != -1 ? param1 : lastStartTime);
}
catch(error:ArgumentError)
{
channel = null;
}
if(channel != null)
{
playing = true;
channel.soundTransform = _soundTransform;
channel.addEventListener("soundComplete",onSoundComplete);
_loc2_ = true;
}
else
{
owner.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(10)));
}
}
return _loc2_;
}
public function pause() : void
{
if(channel != null)
{
lastStartTime = channel.position;
clearChannel();
playing = false;
}
}
public function stop() : void
{
if(channel != null)
{
lastStartTime = 0;
clearChannel();
playing = false;
}
}
public function seek(param1:Number) : void
{
var _loc2_:Boolean = playing;
if(channel != null)
{
clearChannel();
}
play(param1 * 1000);
if(_loc2_ == false)
{
pause();
}
}
private function clearChannel() : void
{
if(channel != null)
{
channel.removeEventListener("soundComplete",onSoundComplete);
channel.stop();
channel = null;
}
}
private function onSoundComplete(param1:Event) : void
{
lastStartTime = channel.position;
clearChannel();
playing = false;
dispatchEvent(new Event("complete"));
}
private function onDownloadComplete(param1:Event) : void
{
dispatchEvent(new Event("downloadComplete"));
}
private function onProgress(param1:ProgressEvent) : void
{
dispatchEvent(param1.clone());
}
private function onIOError(param1:IOErrorEvent) : void
{
owner.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(1)));
}
}
}
@@ -0,0 +1,70 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import flash.media.Sound;
import org.osmf.events.LoadEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class SoundLoadTrait extends LoadTrait
{
private var lastBytesTotal:Number;
private var _sound:Sound;
public function SoundLoadTrait(param1:LoaderBase, param2:MediaResourceBase)
{
super(param1,param2);
}
public function get sound() : Sound
{
return _sound;
}
public function set sound(param1:Sound) : void
{
_sound = param1;
}
override protected function loadStateChangeStart(param1:String) : void
{
if(param1 == "ready")
{
if(_sound != null)
{
_sound.addEventListener("open",bytesTotalCheckingHandler,false,0,true);
_sound.addEventListener("progress",bytesTotalCheckingHandler,false,0,true);
}
}
else if(param1 == "uninitialized")
{
_sound = null;
}
}
override public function get bytesLoaded() : Number
{
return _sound ? _sound.bytesLoaded : NaN;
}
override public function get bytesTotal() : Number
{
return _sound ? _sound.bytesTotal : NaN;
}
private function bytesTotalCheckingHandler(param1:Event) : void
{
var _loc2_:LoadEvent = null;
if(lastBytesTotal != _sound.bytesTotal)
{
_loc2_ = new LoadEvent("bytesTotalChange",false,false,null,_sound.bytesTotal);
lastBytesTotal = _sound.bytesTotal;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,16 @@
package org.osmf.elements.compositeClasses
{
public final class CompositionMode
{
public static const PARALLEL:String = "parallel";
public static const SERIAL:String = "serial";
public function CompositionMode()
{
super();
}
}
}
@@ -0,0 +1,91 @@
package org.osmf.elements.f4mClasses
{
import flash.utils.ByteArray;
internal class Base64Decoder
{
private static const ESCAPE_CHAR_CODE:Number = 61;
private static const inverse:Array = [64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,62,64,64,64,63,52,53,54,55,56,57,58,59,60,61,64,64,64,64,64,64,64,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,64,64,64,64,64,64,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64];
private var count:int = 0;
private var data:ByteArray;
private var filled:int = 0;
private var work:Array = [0,0,0,0];
public function Base64Decoder()
{
super();
data = new ByteArray();
}
private static function copyByteArray(param1:ByteArray, param2:ByteArray, param3:uint = 0) : void
{
var _loc5_:int = int(param1.position);
param1.position = 0;
param2.position = 0;
var _loc4_:uint = 0;
while(param1.bytesAvailable > 0 && _loc4_ < param3)
{
param2.writeByte(param1.readByte());
_loc4_++;
}
param1.position = _loc5_;
param2.position = 0;
}
public function decode(param1:String) : void
{
var _loc3_:* = 0;
var _loc2_:Number = NaN;
_loc3_ = 0;
for(; _loc3_ < param1.length; _loc3_++)
{
_loc2_ = param1.charCodeAt(_loc3_);
if(_loc2_ == 61)
{
work[count++] = -1;
}
else
{
if(inverse[_loc2_] == 64)
{
continue;
}
work[count++] = inverse[_loc2_];
}
if(count == 4)
{
count = 0;
data.writeByte(work[0] << 2 | (work[1] & 0xFF) >> 4);
filled = filled + 1;
if(work[2] == -1)
{
break;
}
data.writeByte(work[1] << 4 | (work[2] & 0xFF) >> 2);
filled = filled + 1;
if(work[3] == -1)
{
break;
}
data.writeByte(work[2] << 6 | work[3]);
filled = filled + 1;
}
}
}
public function drain() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
copyByteArray(data,_loc1_,filled);
filled = 0;
return _loc1_;
}
}
}
@@ -0,0 +1,22 @@
package org.osmf.elements.f4mClasses
{
import flash.utils.ByteArray;
public class BootstrapInfo
{
public var data:ByteArray;
public var url:String;
public var profile:String;
public var id:String;
public function BootstrapInfo()
{
super();
}
}
}
@@ -0,0 +1,20 @@
package org.osmf.elements.f4mClasses
{
import flash.utils.ByteArray;
public class DRMAdditionalHeader
{
public var data:ByteArray;
public var url:String;
public var id:String;
public function DRMAdditionalHeader()
{
super();
}
}
}
@@ -0,0 +1,88 @@
package org.osmf.elements.f4mClasses
{
internal class DateUtil
{
public function DateUtil()
{
super();
}
public static function parseW3CDTF(param1:String) : Date
{
var _loc3_:Date = null;
var _loc7_:String = null;
var _loc13_:String = null;
var _loc18_:Array = null;
var _loc9_:Number = NaN;
var _loc16_:Number = NaN;
var _loc2_:Number = NaN;
var _loc11_:Number = NaN;
var _loc19_:Number = NaN;
var _loc5_:Number = NaN;
var _loc21_:String = null;
var _loc20_:Array = null;
var _loc17_:Number = NaN;
var _loc12_:Number = NaN;
var _loc15_:Array = null;
var _loc14_:Number = NaN;
var _loc4_:Number = NaN;
var _loc10_:Number = NaN;
var _loc8_:Number = NaN;
var _loc6_:String = null;
try
{
_loc7_ = param1.substring(0,param1.indexOf("T"));
_loc13_ = param1.substring(param1.indexOf("T") + 1,param1.length);
_loc18_ = _loc7_.split("-");
_loc9_ = _loc18_.shift();
_loc16_ = _loc18_.shift();
_loc2_ = _loc18_.shift();
if(_loc13_.indexOf("Z") != -1)
{
_loc11_ = 1;
_loc19_ = 0;
_loc5_ = 0;
_loc13_ = _loc13_.replace("Z","");
}
else if(_loc13_.indexOf("+") != -1)
{
_loc11_ = 1;
_loc21_ = _loc13_.substring(_loc13_.indexOf("+") + 1,_loc13_.length);
_loc19_ = Number(_loc21_.substring(0,_loc21_.indexOf(":")));
_loc5_ = Number(_loc21_.substring(_loc21_.indexOf(":") + 1,_loc21_.length));
_loc13_ = _loc13_.substring(0,_loc13_.indexOf("+"));
}
else
{
_loc11_ = -1;
_loc21_ = _loc13_.substring(_loc13_.indexOf("-") + 1,_loc13_.length);
_loc19_ = Number(_loc21_.substring(0,_loc21_.indexOf(":")));
_loc5_ = Number(_loc21_.substring(_loc21_.indexOf(":") + 1,_loc21_.length));
_loc13_ = _loc13_.substring(0,_loc13_.indexOf("-"));
}
_loc20_ = _loc13_.split(":");
_loc17_ = _loc20_.shift();
_loc12_ = _loc20_.shift();
_loc15_ = _loc20_.length > 0 ? String(_loc20_.shift()).split(".") : null;
_loc14_ = _loc15_ != null && _loc15_.length > 0 ? Number(_loc15_.shift()) : 0;
_loc4_ = _loc15_ != null && _loc15_.length > 0 ? Number(_loc15_.shift()) : 0;
_loc10_ = Date.UTC(_loc9_,_loc16_ - 1,_loc2_,_loc17_,_loc12_,_loc14_,_loc4_);
_loc8_ = (_loc19_ * 3600000 + _loc5_ * 60000) * _loc11_;
_loc3_ = new Date(_loc10_ - _loc8_);
if(_loc3_.toString() == "Invalid Date")
{
throw new Error("This date does not conform to W3CDTF.");
}
}
catch(e:Error)
{
_loc6_ = "Unable to parse the string [" + param1 + "] into a date. ";
_loc6_ = _loc6_ + ("The internal error was: " + e.toString());
throw new Error(_loc6_);
}
return _loc3_;
}
}
}
@@ -0,0 +1,38 @@
package org.osmf.elements.f4mClasses
{
import org.osmf.net.httpstreaming.dvr.DVRInfo;
public class Manifest
{
public var id:String;
public var baseURL:String;
public var urlIncludesFMSApplicationInstance:Boolean = false;
public var duration:Number;
public var mimeType:String;
public var streamType:String;
public var deliveryType:String;
public var startTime:Date;
public var bootstrapInfos:Vector.<BootstrapInfo> = new Vector.<BootstrapInfo>();
public var drmAdditionalHeaders:Vector.<DRMAdditionalHeader> = new Vector.<DRMAdditionalHeader>();
public var media:Vector.<Media> = new Vector.<Media>();
public var dvrInfo:DVRInfo = null;
public function Manifest()
{
super();
}
}
}
@@ -0,0 +1,589 @@
package org.osmf.elements.f4mClasses
{
import flash.utils.ByteArray;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.metadata.Metadata;
import org.osmf.net.DynamicStreamingItem;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.MulticastResource;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.StreamingURLResource;
import org.osmf.net.httpstreaming.dvr.DVRInfo;
import org.osmf.utils.OSMFStrings;
import org.osmf.utils.URL;
public class ManifestParser
{
private namespace xmlns = "http://ns.adobe.com/f4m/1.0";
public function ManifestParser()
{
super();
}
public function parse(param1:String, param2:String = null) : Manifest
{
var _loc10_:Media = null;
var _loc5_:Manifest = new Manifest();
var _loc12_:Boolean = false;
var _loc9_:XML = new XML(param1);
if(_loc9_.id.length() > 0)
{
_loc5_.id = _loc9_.id.text();
}
if(_loc9_.duration.length() > 0)
{
_loc5_.duration = _loc9_.duration.text();
}
if(_loc9_.startTime.length() > 0)
{
_loc5_.startTime = DateUtil.parseW3CDTF(_loc9_.startTime.text());
}
if(_loc9_.mimeType.length() > 0)
{
_loc5_.mimeType = _loc9_.mimeType.text();
}
if(_loc9_.streamType.length() > 0)
{
_loc5_.streamType = _loc9_.streamType.text();
}
if(_loc9_.deliveryType.length() > 0)
{
_loc5_.deliveryType = _loc9_.deliveryType.text();
}
if(_loc9_.baseURL.length() > 0)
{
_loc5_.baseURL = _loc9_.baseURL.text();
}
if(_loc9_.urlIncludesFMSApplicationInstance.length() > 0)
{
_loc5_.urlIncludesFMSApplicationInstance = _loc9_.urlIncludesFMSApplicationInstance.text() == "true";
}
var _loc8_:String = _loc5_.baseURL != null ? _loc5_.baseURL : param2;
var _loc15_:int = 0;
var _loc14_:XMLList = _loc9_.dvrInfo;
for each(var _loc11_:XML in _loc14_)
{
parseDVRInfo(_loc11_,_loc8_,_loc5_);
}
var _loc6_:Boolean = false;
var _loc3_:Boolean = false;
for each(var _loc7_:XML in _loc9_.media)
{
_loc10_ = parseMedia(_loc7_,_loc8_);
if(_loc10_.multicastGroupspec != null && _loc10_.multicastGroupspec.length > 0 && (_loc10_.multicastStreamName == null || _loc10_.multicastStreamName.length <= 0) || _loc10_.multicastStreamName != null && _loc10_.multicastStreamName.length > 0 && (_loc10_.multicastGroupspec == null || _loc10_.multicastGroupspec.length <= 0))
{
_loc3_ = true;
}
if(_loc10_.multicastGroupspec != null && _loc10_.multicastGroupspec.length > 0)
{
_loc12_ = true;
}
_loc5_.media.push(_loc10_);
if(!_loc6_)
{
_loc6_ = isNaN(_loc10_.bitrate);
}
}
if(_loc3_)
{
throw new ArgumentError(OSMFStrings.getString("multicastParameterInvalid"));
}
if(_loc5_.media.length > 1 && _loc12_)
{
throw new ArgumentError(OSMFStrings.getString("multicastNotSupportMBR"));
}
if(_loc12_)
{
_loc5_.streamType = "live";
}
if(_loc5_.media.length > 1 && _loc6_)
{
throw new ArgumentError(OSMFStrings.getString("f4mBitrateMissing"));
}
for each(var _loc4_:XML in _loc9_.drmAdditionalHeader)
{
parseDRMAdditionalHeader(_loc4_,_loc5_.media,_loc8_,_loc5_);
}
for each(var _loc13_:XML in _loc9_.bootstrapInfo)
{
parseBootstrapInfo(_loc13_,_loc5_.media,_loc8_,_loc5_);
}
generateRTMPBaseURL(_loc5_);
return _loc5_;
}
private function parseMedia(param1:XML, param2:String) : Media
{
var _loc6_:Base64Decoder = null;
var _loc4_:ByteArray = null;
var _loc5_:String = null;
var _loc3_:Object = null;
var _loc7_:Media = new Media();
if(param1.attribute("url").length() > 0)
{
_loc7_.url = param1.@url;
if(param1.attribute("bitrate").length() > 0)
{
_loc7_.bitrate = param1.@bitrate;
}
if(param1.attribute("drmAdditionalHeaderId").length() > 0)
{
_loc7_.drmAdditionalHeader.id = param1.@drmAdditionalHeaderId;
}
if(param1.attribute("bootstrapInfoId").length() > 0)
{
_loc7_.bootstrapInfo = new BootstrapInfo();
_loc7_.bootstrapInfo.id = param1.@bootstrapInfoId;
}
if(param1.attribute("height").length() > 0)
{
_loc7_.height = param1.@height;
}
if(param1.attribute("width").length() > 0)
{
_loc7_.width = param1.@width;
}
if(param1.attribute("groupspec").length() > 0)
{
_loc7_.multicastGroupspec = param1.@groupspec;
}
if(param1.attribute("multicastStreamName").length() > 0)
{
_loc7_.multicastStreamName = param1.@multicastStreamName;
}
if(param1.moov.length() > 0)
{
_loc6_ = new Base64Decoder();
_loc6_.decode(param1.moov.text());
_loc7_.moov = _loc6_.drain();
}
if(param1.metadata.length() > 0)
{
_loc6_ = new Base64Decoder();
_loc6_.decode(param1.metadata.text());
_loc4_ = _loc6_.drain();
_loc4_.position = 0;
_loc4_.objectEncoding = 0;
try
{
_loc5_ = _loc4_.readObject() as String;
_loc3_ = _loc4_.readObject();
_loc7_.metadata = _loc3_;
}
catch(e:Error)
{
}
}
if(param1.xmpMetadata.length() > 0)
{
_loc6_ = new Base64Decoder();
_loc6_.decode(param1.xmpMetadata.text());
_loc7_.xmp = _loc6_.drain();
}
return _loc7_;
}
throw new ArgumentError(OSMFStrings.getString("f4mMediaURLMissing"));
}
private function parseDVRInfo(param1:XML, param2:String, param3:Manifest) : void
{
var _loc7_:String = null;
var _loc5_:Number = NaN;
var _loc4_:String = null;
var _loc6_:DVRInfo = new DVRInfo();
if(param1.attribute("id").length() > 0)
{
_loc6_.id = param1.@id;
}
if(param1.attribute("url").length() > 0)
{
_loc7_ = param1.@url;
if(!isAbsoluteURL(_loc7_))
{
_loc7_ = param2 + "/" + _loc7_;
}
_loc6_.url = _loc7_;
}
if(param1.attribute("beginOffset").length() > 0)
{
_loc6_.beginOffset = Math.max(0,parseInt(param1.@beginOffset));
}
if(param1.attribute("endOffset").length() > 0)
{
_loc5_ = new Number(param1.@endOffset);
if(_loc5_ > 0 && _loc5_ < 1)
{
_loc6_.endOffset = 1;
}
else
{
_loc6_.endOffset = Math.max(0,_loc5_);
}
}
if(param1.attribute("offline").length() > 0)
{
_loc4_ = param1.@offline;
_loc6_.offline = _loc4_.toLowerCase() == "true";
}
param3.dvrInfo = _loc6_;
}
private function parseDRMAdditionalHeader(param1:XML, param2:Vector.<Media>, param3:String, param4:Manifest) : void
{
var _loc7_:* = null;
var _loc5_:String = null;
var _loc8_:Base64Decoder = null;
var _loc9_:String = null;
var _loc6_:DRMAdditionalHeader = new DRMAdditionalHeader();
if(param1.attribute("id").length() > 0)
{
_loc6_.id = param1.@id;
}
if(param1.attribute("url").length() > 0)
{
_loc9_ = param1.@url;
if(!isAbsoluteURL(_loc9_))
{
_loc9_ = param3 + "/" + _loc9_;
}
_loc6_.url = _loc9_;
}
else
{
_loc5_ = param1.text();
_loc8_ = new Base64Decoder();
_loc8_.decode(_loc5_);
_loc6_.data = _loc8_.drain();
}
param4.drmAdditionalHeaders.push(_loc6_);
for each(_loc7_ in param2)
{
if(_loc7_.drmAdditionalHeader.id == _loc6_.id)
{
_loc7_.drmAdditionalHeader = _loc6_;
}
}
}
private function parseBootstrapInfo(param1:XML, param2:Vector.<Media>, param3:String, param4:Manifest) : void
{
var _loc7_:* = null;
var _loc5_:String = null;
var _loc8_:Base64Decoder = null;
var _loc9_:String = null;
var _loc6_:BootstrapInfo = new BootstrapInfo();
if(param1.attribute("profile").length() > 0)
{
_loc6_.profile = param1.@profile;
if(param1.attribute("id").length() > 0)
{
_loc6_.id = param1.@id;
}
if(param1.attribute("url").length() > 0)
{
_loc9_ = param1.@url;
if(!isAbsoluteURL(_loc9_) && param3 != null)
{
_loc9_ = param3 + "/" + _loc9_;
}
_loc6_.url = _loc9_;
}
else
{
_loc5_ = param1.text();
_loc8_ = new Base64Decoder();
_loc8_.decode(_loc5_);
_loc6_.data = _loc8_.drain();
}
for each(_loc7_ in param2)
{
if(_loc7_.bootstrapInfo == null)
{
_loc7_.bootstrapInfo = _loc6_;
}
else if(_loc7_.bootstrapInfo.id == _loc6_.id)
{
_loc7_.bootstrapInfo = _loc6_;
}
}
return;
}
throw new ArgumentError(OSMFStrings.getString("f4mProfileMissing"));
}
private function generateRTMPBaseURL(param1:Manifest) : void
{
if(param1.baseURL == null)
{
for each(var _loc2_:Media in param1.media)
{
if(NetStreamUtils.isRTMPStream(_loc2_.url))
{
param1.baseURL = _loc2_.url;
break;
}
}
}
}
public function createResource(param1:Manifest, param2:URLResource) : MediaResourceBase
{
var _loc6_:StreamingURLResource = null;
var _loc8_:Media = null;
var _loc11_:* = undefined;
var _loc10_:String = null;
var _loc19_:String = null;
var _loc13_:String = null;
var _loc12_:String = null;
var _loc18_:DynamicStreamingResource = null;
var _loc9_:* = undefined;
var _loc14_:String = null;
var _loc4_:DynamicStreamingItem = null;
var _loc16_:Metadata = null;
var _loc17_:Metadata = null;
var _loc15_:URL = new URL(param2.url);
var _loc3_:String = "/" + _loc15_.path;
_loc3_ = _loc3_.substr(0,_loc3_.lastIndexOf("/"));
var _loc7_:String = _loc15_.protocol + "://" + _loc15_.host + (_loc15_.port != "" ? ":" + _loc15_.port : "") + _loc3_;
if(param1.media.length == 1)
{
_loc8_ = param1.media[0] as Media;
_loc10_ = _loc8_.url;
_loc13_ = null;
if(isAbsoluteURL(_loc10_))
{
_loc13_ = _loc8_.url.substr(0,_loc8_.url.lastIndexOf("/"));
}
else if(param1.baseURL != null)
{
_loc13_ = param1.baseURL;
}
else
{
_loc13_ = _loc7_;
}
if(_loc8_.multicastGroupspec != null && _loc8_.multicastGroupspec.length > 0 && _loc8_.multicastStreamName != null && _loc8_.multicastStreamName.length > 0)
{
if(isAbsoluteURL(_loc10_))
{
_loc6_ = new MulticastResource(_loc10_,param1.streamType);
}
else if(param1.baseURL != null)
{
_loc6_ = new MulticastResource(param1.baseURL + "/" + _loc10_,streamType(param1));
}
else
{
_loc6_ = new MulticastResource(_loc7_ + "/" + _loc10_,streamType(param1));
}
MulticastResource(_loc6_).groupspec = _loc8_.multicastGroupspec;
MulticastResource(_loc6_).streamName = _loc8_.multicastStreamName;
}
else if(isAbsoluteURL(_loc10_))
{
_loc6_ = new StreamingURLResource(_loc10_,param1.streamType);
}
else if(param1.baseURL != null)
{
_loc6_ = new StreamingURLResource(param1.baseURL + "/" + _loc10_,streamType(param1));
}
else
{
_loc6_ = new StreamingURLResource(_loc7_ + "/" + _loc10_,streamType(param1));
}
_loc6_.urlIncludesFMSApplicationInstance = param1.urlIncludesFMSApplicationInstance;
if(_loc8_.bootstrapInfo != null)
{
_loc11_ = new Vector.<String>();
_loc11_.push(_loc13_);
_loc19_ = _loc8_.bootstrapInfo.url;
if(_loc8_.bootstrapInfo.url != null && isAbsoluteURL(_loc8_.bootstrapInfo.url) == false)
{
_loc19_ = _loc7_ + "/" + _loc19_;
_loc8_.bootstrapInfo.url = _loc19_;
}
_loc17_ = new Metadata();
_loc17_.addValue("bootstrap",_loc8_.bootstrapInfo);
if(_loc11_.length > 0)
{
_loc17_.addValue("serverBaseUrls",_loc11_);
}
}
if(_loc8_.metadata != null)
{
if(_loc17_ == null)
{
_loc17_ = new Metadata();
}
_loc17_.addValue("streamMetadata",_loc8_.metadata);
}
if(_loc8_.xmp != null)
{
if(_loc17_ == null)
{
_loc17_ = new Metadata();
}
_loc17_.addValue("xmpMetadata",_loc8_.xmp);
}
if(_loc8_.drmAdditionalHeader != null)
{
_loc16_ = new Metadata();
if(Media(param1.media[0]).drmAdditionalHeader != null && Media(param1.media[0]).drmAdditionalHeader.data != null)
{
_loc16_.addValue("DRMAdditionalHeader",Media(param1.media[0]).drmAdditionalHeader.data);
_loc6_.drmContentData = extractDRMMetadata(Media(param1.media[0]).drmAdditionalHeader.data);
}
}
if(_loc17_ != null)
{
_loc6_.addMetadataValue("http://www.osmf.org/httpstreaming/1.0",_loc17_);
}
if(_loc16_ != null)
{
_loc6_.addMetadataValue("http://www.osmf.org/drm/1.0",_loc16_);
}
}
else if(param1.media.length > 1)
{
_loc12_ = param1.baseURL != null ? param1.baseURL : _loc7_;
_loc11_ = new Vector.<String>();
_loc11_.push(_loc12_);
_loc18_ = new DynamicStreamingResource(_loc12_,streamType(param1));
_loc18_.urlIncludesFMSApplicationInstance = param1.urlIncludesFMSApplicationInstance;
_loc9_ = new Vector.<DynamicStreamingItem>();
if(NetStreamUtils.isRTMPStream(_loc12_) == false)
{
_loc17_ = new Metadata();
_loc18_.addMetadataValue("http://www.osmf.org/httpstreaming/1.0",_loc17_);
_loc17_.addValue("serverBaseUrls",_loc11_);
}
for each(_loc8_ in param1.media)
{
if(isAbsoluteURL(_loc8_.url))
{
_loc14_ = NetStreamUtils.getStreamNameFromURL(_loc8_.url);
}
else
{
_loc14_ = _loc8_.url;
}
_loc4_ = new DynamicStreamingItem(_loc14_,_loc8_.bitrate,_loc8_.width,_loc8_.height);
_loc9_.push(_loc4_);
if(_loc8_.drmAdditionalHeader != null)
{
if(_loc18_.getMetadataValue("http://www.osmf.org/drm/1.0") == null)
{
_loc16_ = new Metadata();
_loc18_.addMetadataValue("http://www.osmf.org/drm/1.0",_loc16_);
}
if(_loc8_.drmAdditionalHeader != null && _loc8_.drmAdditionalHeader.data != null)
{
_loc16_.addValue(_loc4_.streamName,extractDRMMetadata(_loc8_.drmAdditionalHeader.data));
_loc16_.addValue("DRMAdditionalHeader" + _loc4_.streamName,_loc8_.drmAdditionalHeader.data);
}
}
if(_loc8_.bootstrapInfo != null)
{
_loc19_ = _loc8_.bootstrapInfo.url ? _loc8_.bootstrapInfo.url : null;
if(_loc8_.bootstrapInfo.url != null && isAbsoluteURL(_loc8_.bootstrapInfo.url) == false)
{
_loc19_ = _loc7_ + "/" + _loc19_;
_loc8_.bootstrapInfo.url = _loc19_;
}
_loc17_.addValue("bootstrap" + _loc4_.streamName,_loc8_.bootstrapInfo);
}
if(_loc8_.metadata != null)
{
_loc17_.addValue("streamMetadata" + _loc4_.streamName,_loc8_.metadata);
}
if(_loc8_.xmp != null)
{
_loc17_.addValue("xmpMetadata" + _loc4_.streamName,_loc8_.xmp);
}
}
_loc18_.streamItems = _loc9_;
_loc6_ = _loc18_;
}
else if(param1.baseURL == null)
{
throw new ArgumentError(OSMFStrings.getString("f4mMediaURLMissing"));
}
if(param1.mimeType != null)
{
_loc6_.mediaType = "video";
_loc6_.mimeType = param1.mimeType;
}
var _loc5_:StreamingURLResource = param2 as StreamingURLResource;
if(_loc5_ != null)
{
_loc6_.clipStartTime = _loc5_.clipStartTime;
_loc6_.clipEndTime = _loc5_.clipEndTime;
}
_loc6_.addMetadataValue("http://www.osmf.org/derivedResource/1.0",param2);
addDVRInfo(param1,_loc6_);
return _loc6_;
}
private function isAbsoluteURL(param1:String) : Boolean
{
var _loc2_:URL = new URL(param1);
return _loc2_.absolute;
}
private function extractDRMMetadata(param1:ByteArray) : ByteArray
{
var _loc4_:Object = null;
var _loc3_:Object = null;
var _loc6_:Object = null;
var _loc9_:Object = null;
var _loc10_:Object = null;
var _loc5_:Object = null;
var _loc7_:String = null;
var _loc8_:Base64Decoder = null;
var _loc2_:ByteArray = null;
param1.position = 0;
param1.objectEncoding = 0;
try
{
_loc4_ = param1.readObject();
_loc3_ = param1.readObject();
_loc6_ = _loc3_["Encryption"];
_loc9_ = _loc6_["Params"];
_loc10_ = _loc9_["KeyInfo"];
_loc5_ = _loc10_["FMRMS_METADATA"];
_loc7_ = _loc5_["Metadata"] as String;
_loc8_ = new Base64Decoder();
_loc8_.decode(_loc7_);
_loc2_ = _loc8_.drain();
}
catch(e:Error)
{
_loc2_ = null;
}
return _loc2_;
}
private function addDVRInfo(param1:Manifest, param2:StreamingURLResource) : void
{
if(param1.dvrInfo == null)
{
return;
}
var _loc3_:Metadata = new Metadata();
_loc3_.addValue("beginOffset",param1.dvrInfo.beginOffset);
_loc3_.addValue("endOffset",param1.dvrInfo.endOffset);
_loc3_.addValue("dvrOffline",param1.dvrInfo.offline);
_loc3_.addValue("dvrId",param1.dvrInfo.id);
param2.addMetadataValue("http://www.osmf.org/dvr/1.0",_loc3_);
}
private function streamType(param1:Manifest) : String
{
return param1.streamType == "live" && param1.dvrInfo != null ? "dvr" : param1.streamType;
}
}
}
@@ -0,0 +1,36 @@
package org.osmf.elements.f4mClasses
{
import flash.utils.ByteArray;
internal class Media
{
public var drmAdditionalHeader:DRMAdditionalHeader = new DRMAdditionalHeader();
public var bootstrapInfo:BootstrapInfo;
public var metadata:Object;
public var xmp:ByteArray;
public var url:String;
public var bitrate:Number;
public var moov:ByteArray;
public var width:Number;
public var height:Number;
public var multicastGroupspec:String;
public var multicastStreamName:String;
public function Media()
{
super();
}
}
}
@@ -0,0 +1,54 @@
package org.osmf.elements.loaderClasses
{
import flash.display.Loader;
import flash.events.ProgressEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class LoaderLoadTrait extends LoadTrait
{
private var _loader:Loader;
public function LoaderLoadTrait(param1:LoaderBase, param2:MediaResourceBase)
{
super(param1,param2);
}
public function get loader() : Loader
{
return _loader;
}
public function set loader(param1:Loader) : void
{
_loader = param1;
}
override protected function loadStateChangeStart(param1:String) : void
{
if(param1 == "loading")
{
loader.contentLoaderInfo.addEventListener("progress",onContentLoadProgress,false,0,true);
}
else if(param1 == "ready")
{
setBytesTotal(loader.contentLoaderInfo.bytesTotal);
setBytesLoaded(loader.contentLoaderInfo.bytesLoaded);
loader.contentLoaderInfo.addEventListener("progress",onContentLoadProgress,false,0,true);
}
else if(param1 == "uninitialized")
{
setBytesLoaded(0);
}
}
private function onContentLoadProgress(param1:ProgressEvent) : void
{
setBytesTotal(param1.bytesTotal);
setBytesLoaded(param1.bytesLoaded);
}
}
}
@@ -0,0 +1,174 @@
package org.osmf.elements.loaderClasses
{
import flash.display.DisplayObject;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.errors.IOError;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.events.TimerEvent;
import flash.geom.Rectangle;
import flash.net.URLRequest;
import flash.system.ApplicationDomain;
import flash.system.Capabilities;
import flash.system.LoaderContext;
import flash.system.SecurityDomain;
import flash.utils.Timer;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaElement;
import org.osmf.media.URLResource;
import org.osmf.traits.DisplayObjectTrait;
import org.osmf.traits.LoadTrait;
public class LoaderUtils
{
private static const SWF_MIME_TYPE:String = "application/x-shockwave-flash";
public function LoaderUtils()
{
super();
}
public static function createDisplayObjectTrait(param1:Loader, param2:MediaElement) : DisplayObjectTrait
{
var _loc3_:DisplayObject = null;
var _loc5_:Number = 0;
var _loc4_:Number = 0;
var _loc6_:LoaderInfo = param1.contentLoaderInfo;
_loc3_ = param1;
_loc3_.scrollRect = new Rectangle(0,0,_loc6_.width,_loc6_.height);
_loc5_ = _loc6_.width;
_loc4_ = _loc6_.height;
return new DisplayObjectTrait(_loc3_,_loc5_,_loc4_);
}
public static function loadLoadTrait(param1:LoadTrait, param2:Function, param3:Boolean, param4:Boolean, param5:Function = null) : void
{
var context:LoaderContext;
var urlReq:URLRequest;
var loadTrait:LoadTrait = param1;
var updateLoadTraitFunction:Function = param2;
var useCurrentSecurityDomain:Boolean = param3;
var checkPolicyFile:Boolean = param4;
var validateLoadedContentFunction:Function = param5;
var toggleLoaderListeners:* = function(param1:Loader, param2:Boolean):void
{
if(param2)
{
param1.contentLoaderInfo.addEventListener("complete",onLoadComplete);
param1.contentLoaderInfo.addEventListener("ioError",onIOError);
param1.contentLoaderInfo.addEventListener("securityError",onSecurityError);
}
else
{
param1.contentLoaderInfo.removeEventListener("complete",onLoadComplete);
param1.contentLoaderInfo.removeEventListener("ioError",onIOError);
param1.contentLoaderInfo.removeEventListener("securityError",onSecurityError);
}
};
var onLoadComplete:* = function(param1:Event):void
{
var validated:Boolean;
var timer:Timer;
var onTimer:*;
var event:Event = param1;
toggleLoaderListeners(loader,false);
if(loadTrait.loadState == "loading")
{
if(validateLoadedContentFunction != null)
{
validated = Boolean(validateLoadedContentFunction(loader.content));
if(validated)
{
if(Capabilities.isDebugger)
{
onTimer = function(param1:TimerEvent):void
{
timer.removeEventListener("timerComplete",onTimer);
timer = null;
loader.unloadAndStop();
loader = null;
loadLoadTrait(loadTrait,updateLoadTraitFunction,useCurrentSecurityDomain,false,null);
};
timer = new Timer(250,1);
timer.addEventListener("timerComplete",onTimer);
timer.start();
}
else
{
loader.unloadAndStop();
loader = null;
loadLoadTrait(loadTrait,updateLoadTraitFunction,useCurrentSecurityDomain,false,null);
}
}
else
{
loader.unloadAndStop();
loader = null;
updateLoadTraitFunction(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(1)));
}
}
else
{
updateLoadTraitFunction(loadTrait,"ready");
}
}
};
var onIOError:* = function(param1:IOErrorEvent, param2:String = null):void
{
toggleLoaderListeners(loader,false);
loader = null;
updateLoadTraitFunction(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(1,param1 ? param1.text : param2)));
};
var onSecurityError:* = function(param1:SecurityErrorEvent, param2:String = null):void
{
toggleLoaderListeners(loader,false);
loader = null;
updateLoadTraitFunction(loadTrait,"loadError");
loadTrait.dispatchEvent(new MediaErrorEvent("mediaError",false,false,new MediaError(2,param1 ? param1.text : param2)));
};
var loaderLoadTrait:LoaderLoadTrait = loadTrait as LoaderLoadTrait;
var loader:Loader = new Loader();
loaderLoadTrait.loader = loader;
updateLoadTraitFunction(loadTrait,"loading");
context = new LoaderContext();
urlReq = new URLRequest((loadTrait.resource as URLResource).url.toString());
context.checkPolicyFile = checkPolicyFile;
if(useCurrentSecurityDomain && urlReq.url.search(/^file:\//i) == -1)
{
context.securityDomain = SecurityDomain.currentDomain;
}
if(validateLoadedContentFunction != null)
{
context.applicationDomain = new ApplicationDomain();
}
toggleLoaderListeners(loader,true);
try
{
loader.load(urlReq,context);
}
catch(ioError:IOError)
{
onIOError(null,ioError.message);
}
catch(securityError:SecurityError)
{
onSecurityError(null,securityError.message);
}
}
public static function unloadLoadTrait(param1:LoadTrait, param2:Function) : void
{
var _loc3_:LoaderLoadTrait = param1 as LoaderLoadTrait;
param2(param1,"unloading");
_loc3_.loader.unloadAndStop();
param2(param1,"uninitialized");
}
}
}
@@ -0,0 +1,35 @@
package org.osmf.elements.proxyClasses
{
import org.osmf.events.LoadEvent;
import org.osmf.media.MediaElement;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class LoadFromDocumentLoadTrait extends LoadTrait
{
private var _mediaElement:MediaElement;
public function LoadFromDocumentLoadTrait(param1:LoaderBase, param2:MediaResourceBase)
{
super(param1,param2);
}
override protected function loadStateChangeEnd() : void
{
dispatchEvent(new LoadEvent("loadStateChange",false,false,loadState));
}
public function set mediaElement(param1:MediaElement) : void
{
_mediaElement = param1;
}
public function get mediaElement() : MediaElement
{
return _mediaElement;
}
}
}
@@ -0,0 +1,61 @@
package org.osmf.elements.proxyClasses
{
import flash.events.Event;
import org.osmf.metadata.Metadata;
public class ProxyMetadata extends Metadata
{
private var proxiedMetadata:Metadata;
public function ProxyMetadata()
{
super();
proxiedMetadata = new Metadata();
proxiedMetadata.addEventListener("valueAdd",redispatchEvent);
proxiedMetadata.addEventListener("valueChange",redispatchEvent);
proxiedMetadata.addEventListener("valueRemove",redispatchEvent);
}
public function set metadata(param1:Metadata) : void
{
proxiedMetadata.removeEventListener("valueAdd",redispatchEvent);
proxiedMetadata.removeEventListener("valueChange",redispatchEvent);
proxiedMetadata.removeEventListener("valueRemove",redispatchEvent);
for each(var _loc2_:String in proxiedMetadata.keys)
{
param1.addValue(_loc2_,proxiedMetadata.getValue(_loc2_));
}
proxiedMetadata = param1;
proxiedMetadata.addEventListener("valueAdd",redispatchEvent);
proxiedMetadata.addEventListener("valueChange",redispatchEvent);
proxiedMetadata.addEventListener("valueRemove",redispatchEvent);
}
override public function getValue(param1:String) : *
{
return proxiedMetadata.getValue(param1);
}
override public function addValue(param1:String, param2:Object) : void
{
proxiedMetadata.addValue(param1,param2);
}
override public function removeValue(param1:String) : *
{
return proxiedMetadata.removeValue(param1);
}
override public function get keys() : Vector.<String>
{
return proxiedMetadata.keys;
}
private function redispatchEvent(param1:Event) : void
{
dispatchEvent(param1.clone());
}
}
}