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,34 @@
package org.osmf.captioning
{
import org.osmf.captioning.media.CaptioningProxyElement;
import org.osmf.media.MediaElement;
import org.osmf.media.MediaFactoryItem;
import org.osmf.media.MediaFactoryItemType;
import org.osmf.media.PluginInfo;
import org.osmf.net.NetLoader;
public class CaptioningPluginInfo extends PluginInfo
{
public static const CAPTIONING_METADATA_NAMESPACE:String = "http://www.osmf.org/captioning/1.0";
public static const CAPTIONING_METADATA_KEY_URI:String = "uri";
public static const CAPTIONING_TEMPORAL_METADATA_NAMESPACE:String = "http://www.osmf.org/temporal/captioning";
public function CaptioningPluginInfo()
{
var _loc1_:Vector.<MediaFactoryItem> = new Vector.<MediaFactoryItem>();
var _loc2_:NetLoader = new NetLoader();
var _loc3_:MediaFactoryItem = new MediaFactoryItem("org.osmf.captioning.CaptioningPluginInfo",_loc2_.canHandleResource,this.createCaptioningProxyElement,MediaFactoryItemType.PROXY);
_loc1_.push(_loc3_);
super(_loc1_);
}
private function createCaptioningProxyElement() : MediaElement
{
return new CaptioningProxyElement();
}
}
}
@@ -0,0 +1,29 @@
package org.osmf.captioning.loader
{
import org.osmf.captioning.model.CaptioningDocument;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class CaptioningLoadTrait extends LoadTrait
{
private var _document:CaptioningDocument;
public function CaptioningLoadTrait(param1:LoaderBase, param2:MediaResourceBase)
{
super(param1,param2);
}
public function get document() : CaptioningDocument
{
return this._document;
}
public function set document(param1:CaptioningDocument) : void
{
this._document = param1;
}
}
}
@@ -0,0 +1,88 @@
package org.osmf.captioning.loader
{
import org.osmf.captioning.model.CaptioningDocument;
import org.osmf.captioning.parsers.DFXPParser;
import org.osmf.captioning.parsers.ICaptioningParser;
import org.osmf.events.LoaderEvent;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.HTTPLoadTrait;
import org.osmf.utils.HTTPLoader;
public class CaptioningLoader extends LoaderBase
{
private var httpLoader:HTTPLoader;
public function CaptioningLoader(param1:HTTPLoader = null)
{
super();
this.httpLoader = param1 != null ? param1 : new HTTPLoader();
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
return this.httpLoader.canHandleResource(param1);
}
override protected function executeLoad(param1:LoadTrait) : void
{
var httpLoadTrait:HTTPLoadTrait = null;
var onHTTPLoaderStateChange:Function = null;
var onLoadError:Function = null;
var loadTrait:LoadTrait = param1;
onHTTPLoaderStateChange = function(param1:LoaderEvent):void
{
var parser:ICaptioningParser = null;
var captioningDocument:CaptioningDocument = null;
var event:LoaderEvent = param1;
if(event.newState == LoadState.READY)
{
httpLoader.removeEventListener(LoaderEvent.LOAD_STATE_CHANGE,onHTTPLoaderStateChange);
httpLoadTrait.removeEventListener(MediaErrorEvent.MEDIA_ERROR,onLoadError);
parser = createCaptioningParser();
try
{
captioningDocument = parser.parse(httpLoadTrait.urlLoader.data.toString());
}
catch(e:Error)
{
updateLoadTrait(loadTrait,LoadState.LOAD_ERROR);
}
CaptioningLoadTrait(loadTrait).document = captioningDocument;
updateLoadTrait(loadTrait,LoadState.READY);
}
else if(event.newState == LoadState.LOAD_ERROR)
{
httpLoader.removeEventListener(LoaderEvent.LOAD_STATE_CHANGE,onHTTPLoaderStateChange);
updateLoadTrait(loadTrait,event.newState);
}
};
onLoadError = function(param1:MediaErrorEvent):void
{
httpLoadTrait.removeEventListener(MediaErrorEvent.MEDIA_ERROR,onLoadError);
loadTrait.dispatchEvent(param1.clone());
};
updateLoadTrait(loadTrait,LoadState.LOADING);
this.httpLoader.addEventListener(LoaderEvent.LOAD_STATE_CHANGE,onHTTPLoaderStateChange);
httpLoadTrait = new HTTPLoadTrait(this.httpLoader,loadTrait.resource);
httpLoadTrait.addEventListener(MediaErrorEvent.MEDIA_ERROR,onLoadError);
this.httpLoader.load(httpLoadTrait);
}
override protected function executeUnload(param1:LoadTrait) : void
{
updateLoadTrait(param1,LoadState.UNLOADING);
updateLoadTrait(param1,LoadState.UNINITIALIZED);
}
protected function createCaptioningParser() : ICaptioningParser
{
return new DFXPParser();
}
}
}
@@ -0,0 +1,141 @@
package org.osmf.captioning.media
{
import org.osmf.captioning.CaptioningPluginInfo;
import org.osmf.captioning.loader.CaptioningLoadTrait;
import org.osmf.captioning.loader.CaptioningLoader;
import org.osmf.captioning.model.Caption;
import org.osmf.captioning.model.CaptioningDocument;
import org.osmf.elements.ProxyElement;
import org.osmf.events.LoadEvent;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaElement;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.URLResource;
import org.osmf.metadata.Metadata;
import org.osmf.metadata.TimelineMetadata;
import org.osmf.traits.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.MediaTraitType;
public class CaptioningProxyElement extends ProxyElement
{
public static const MEDIA_ERROR_INVALID_PROXIED_ELEMENT:int = 2201;
private static const ERROR_MISSING_CAPTION_METADATA:String = "Media Element is missing Captioning metadata";
private static const ERROR_MISSING_RESOURCE:String = "Media Element is missing a valid resource";
private var loadTrait:CaptioningLoadTrait;
private var _continueLoadOnFailure:Boolean;
public function CaptioningProxyElement(param1:MediaElement = null, param2:Boolean = true)
{
super(param1);
this._continueLoadOnFailure = param2;
}
public function get continueLoadOnFailure() : Boolean
{
return this._continueLoadOnFailure;
}
override public function set proxiedElement(param1:MediaElement) : void
{
var _loc2_:MediaElement = null;
var _loc3_:MediaResourceBase = null;
var _loc4_:Metadata = null;
var _loc5_:String = null;
super.proxiedElement = param1;
if(param1 != null)
{
_loc2_ = super.proxiedElement;
_loc3_ = Boolean(_loc2_) && _loc2_.resource != null ? _loc2_.resource : resource;
if(_loc3_ == null)
{
dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MEDIA_ERROR_INVALID_PROXIED_ELEMENT)));
}
else
{
_loc4_ = _loc3_.getMetadataValue(CaptioningPluginInfo.CAPTIONING_METADATA_NAMESPACE) as Metadata;
if(_loc4_ == null)
{
if(!this._continueLoadOnFailure)
{
dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MEDIA_ERROR_INVALID_PROXIED_ELEMENT)));
}
}
else
{
_loc5_ = _loc4_.getValue(CaptioningPluginInfo.CAPTIONING_METADATA_KEY_URI);
if(_loc5_ != null)
{
this.loadTrait = new CaptioningLoadTrait(new CaptioningLoader(),new URLResource(_loc5_));
this.loadTrait.addEventListener(LoadEvent.LOAD_STATE_CHANGE,this.onLoadStateChange,false,99);
addTrait(MediaTraitType.LOAD,this.loadTrait);
}
else if(!this._continueLoadOnFailure)
{
dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MEDIA_ERROR_INVALID_PROXIED_ELEMENT)));
}
}
}
}
}
private function onLoadStateChange(param1:LoadEvent) : void
{
var _loc2_:CaptioningDocument = null;
var _loc3_:MediaElement = null;
var _loc4_:TimelineMetadata = null;
var _loc5_:int = 0;
var _loc6_:Caption = null;
if(param1.loadState == LoadState.READY)
{
_loc2_ = this.loadTrait.document;
if(_loc2_)
{
_loc3_ = super.proxiedElement;
_loc4_ = proxiedElement.getMetadata(CaptioningPluginInfo.CAPTIONING_TEMPORAL_METADATA_NAMESPACE) as TimelineMetadata;
if(_loc4_ == null)
{
_loc4_ = new TimelineMetadata(proxiedElement);
proxiedElement.addMetadata(CaptioningPluginInfo.CAPTIONING_TEMPORAL_METADATA_NAMESPACE,_loc4_);
}
_loc5_ = 0;
while(_loc5_ < _loc2_.numCaptions)
{
_loc6_ = _loc2_.getCaptionAt(_loc5_);
_loc4_.addMarker(_loc6_);
_loc5_++;
}
}
this.cleanUp();
}
else if(param1.loadState == LoadState.LOAD_ERROR)
{
if(!this._continueLoadOnFailure)
{
dispatchEvent(param1.clone());
}
else
{
this.cleanUp();
}
}
}
private function cleanUp() : void
{
removeTrait(MediaTraitType.LOAD);
var _loc1_:LoadTrait = getTrait(MediaTraitType.LOAD) as LoadTrait;
if(_loc1_ != null && _loc1_.loadState == LoadState.UNINITIALIZED)
{
_loc1_.load();
}
}
}
}
@@ -0,0 +1,68 @@
package org.osmf.captioning.model
{
import flash.errors.IllegalOperationError;
import org.osmf.metadata.TimelineMarker;
import org.osmf.utils.OSMFStrings;
public class Caption extends TimelineMarker
{
private var _id:uint;
private var _captionText:String;
private var _formats:Vector.<CaptionFormat>;
public function Caption(param1:uint, param2:Number, param3:Number, param4:String)
{
var _loc5_:Number = param3 > 0 ? param3 - param2 : NaN;
super(param2,_loc5_);
this._id = param1;
this._captionText = param4;
}
public function addCaptionFormat(param1:CaptionFormat) : void
{
if(this._formats == null)
{
this._formats = new Vector.<CaptionFormat>();
}
this._formats.push(param1);
}
public function get numCaptionFormats() : int
{
var _loc1_:int = 0;
if(this._formats != null)
{
_loc1_ = int(this._formats.length);
}
return _loc1_;
}
public function getCaptionFormatAt(param1:int) : CaptionFormat
{
if(this._formats == null || param1 >= this._formats.length || param1 < 0)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this._formats[param1];
}
public function get text() : String
{
return this._captionText;
}
public function get clearText() : String
{
var _loc1_:String = "";
if(this._captionText != null && this._captionText.length > 0)
{
_loc1_ = this._captionText.replace(/<(.|\n)*?>/g,"");
}
return _loc1_;
}
}
}
@@ -0,0 +1,44 @@
package org.osmf.captioning.model
{
public class CaptionFormat
{
public static const UNDEFINED_INDEX:int = -1;
private static const MISSING_STYLE_ERROR_MSG:String = "CaptionStyle is required for CaptionFormat objects";
private var _startIndex:int;
private var _endIndex:int;
private var _style:CaptionStyle;
public function CaptionFormat(param1:CaptionStyle, param2:int = -1, param3:int = -1)
{
super();
if(param1 == null)
{
throw new ArgumentError(MISSING_STYLE_ERROR_MSG);
}
this._startIndex = param2;
this._endIndex = param3;
this._style = param1;
}
public function get startIndex() : int
{
return this._startIndex;
}
public function get endIndex() : int
{
return this._endIndex;
}
public function get style() : CaptionStyle
{
return this._style;
}
}
}
@@ -0,0 +1,140 @@
package org.osmf.captioning.model
{
public class CaptionStyle
{
private var _id:String;
private var _backgroundColor:Object;
private var _backgroundColorAlpha:Object;
private var _textColor:Object;
private var _textColorAlpha:Object;
private var _fontFamily:String;
private var _fontSize:int;
private var _fontStyle:String;
private var _fontWeight:String;
private var _textAlign:String;
private var _wrapOption:Boolean;
public function CaptionStyle(param1:String)
{
super();
this._id = param1;
}
public function get id() : String
{
return this._id;
}
public function get backgroundColor() : Object
{
return this._backgroundColor;
}
public function set backgroundColor(param1:Object) : void
{
this._backgroundColor = param1;
}
public function get backgroundColorAlpha() : Object
{
return this._backgroundColorAlpha;
}
public function set backgroundColorAlpha(param1:Object) : void
{
this._backgroundColorAlpha = param1;
}
public function get textColor() : Object
{
return this._textColor;
}
public function set textColor(param1:Object) : void
{
this._textColor = param1;
}
public function get textColorAlpha() : Object
{
return this._textColorAlpha;
}
public function set textColorAlpha(param1:Object) : void
{
this._textColorAlpha = param1;
}
public function get fontFamily() : String
{
return this._fontFamily;
}
public function set fontFamily(param1:String) : void
{
this._fontFamily = param1;
}
public function get fontSize() : int
{
return this._fontSize;
}
public function set fontSize(param1:int) : void
{
this._fontSize = param1;
}
public function get fontStyle() : String
{
return this._fontStyle;
}
public function set fontStyle(param1:String) : void
{
this._fontStyle = param1;
}
public function get fontWeight() : String
{
return this._fontWeight;
}
public function set fontWeight(param1:String) : void
{
this._fontWeight = param1;
}
public function get textAlign() : String
{
return this._textAlign;
}
public function set textAlign(param1:String) : void
{
this._textAlign = param1;
}
public function get wrapOption() : Boolean
{
return this._wrapOption;
}
public function set wrapOption(param1:Boolean) : void
{
this._wrapOption = param1;
}
}
}
@@ -0,0 +1,111 @@
package org.osmf.captioning.model
{
import flash.errors.IllegalOperationError;
import org.osmf.utils.OSMFStrings;
public class CaptioningDocument
{
private var _title:String;
private var _desc:String;
private var _copyright:String;
private var _captions:Vector.<Caption>;
private var _styles:Vector.<CaptionStyle>;
public function CaptioningDocument()
{
super();
}
public function get title() : String
{
return this._title;
}
public function set title(param1:String) : void
{
this._title = param1;
}
public function get description() : String
{
return this._desc;
}
public function set description(param1:String) : void
{
this._desc = param1;
}
public function get copyright() : String
{
return this._copyright;
}
public function set copyright(param1:String) : void
{
this._copyright = param1;
}
public function addStyle(param1:CaptionStyle) : void
{
if(this._styles == null)
{
this._styles = new Vector.<CaptionStyle>();
}
this._styles.push(param1);
}
public function get numStyles() : int
{
var _loc1_:int = 0;
if(this._styles != null)
{
_loc1_ = int(this._styles.length);
}
return _loc1_;
}
public function getStyleAt(param1:int) : CaptionStyle
{
if(this._styles == null || param1 >= this._styles.length)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this._styles[param1];
}
public function addCaption(param1:Caption) : void
{
if(this._captions == null)
{
this._captions = new Vector.<Caption>();
}
this._captions.push(param1);
}
public function get numCaptions() : int
{
var _loc1_:int = 0;
if(this._captions != null)
{
_loc1_ = int(this._captions.length);
}
return _loc1_;
}
public function getCaptionAt(param1:int) : Caption
{
if(this._captions == null || param1 >= this._captions.length)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this._captions[param1];
}
}
}
@@ -0,0 +1,515 @@
package org.osmf.captioning.parsers
{
import flash.utils.Dictionary;
import org.osmf.captioning.model.Caption;
import org.osmf.captioning.model.CaptionFormat;
import org.osmf.captioning.model.CaptionStyle;
import org.osmf.captioning.model.CaptioningDocument;
import org.osmf.utils.TimeUtil;
public class DFXPParser implements ICaptioningParser
{
private var ns:Namespace;
private var ttm:Namespace;
private var tts:Namespace;
private var rootNamespace:Namespace;
private var namedColorMap:Dictionary;
public function DFXPParser()
{
super();
this.namedColorMap = new Dictionary();
this.namedColorMap["transparent"] = 0;
this.namedColorMap["black"] = 0;
this.namedColorMap["silver"] = 12632256;
this.namedColorMap["gray"] = 8421504;
this.namedColorMap["white"] = 16777215;
this.namedColorMap["maroon"] = 8388608;
this.namedColorMap["red"] = 16711680;
this.namedColorMap["purple"] = 8388736;
this.namedColorMap["fuchsia"] = 16711935;
this.namedColorMap["magenta"] = 16711935;
this.namedColorMap["green"] = 32768;
this.namedColorMap["lime"] = 65280;
this.namedColorMap["olive"] = 8421376;
this.namedColorMap["yellow"] = 16776960;
this.namedColorMap["navy"] = 128;
this.namedColorMap["blue"] = 255;
this.namedColorMap["teal"] = 32896;
this.namedColorMap["aqua"] = 65535;
this.namedColorMap["cyan"] = 65535;
}
public function parse(param1:String) : CaptioningDocument
{
var xml:XML = null;
var rawData:String = param1;
var document:CaptioningDocument = new CaptioningDocument();
var saveXMLIgnoreWhitespace:Boolean = Boolean(XML.ignoreWhitespace);
var saveXMLPrettyPrinting:Boolean = Boolean(XML.prettyPrinting);
var xmlStr:String = rawData.replace(/\s+$/,"");
xmlStr = xmlStr.replace(/>\s+</g,"><");
XML.ignoreWhitespace = false;
XML.prettyPrinting = false;
try
{
xml = new XML(xmlStr);
}
catch(e:Error)
{
debugLog("Unhandled exception in DFXPParser : " + e.message);
throw e;
}
finally
{
XML.ignoreWhitespace = saveXMLIgnoreWhitespace;
XML.prettyPrinting = saveXMLPrettyPrinting;
}
this.rootNamespace = xml.namespace();
this.ns = xml.namespace();
this.ttm = xml.namespace("ttm");
this.tts = xml.namespace("tts");
try
{
this.parseHead(document,xml);
this.parseBody(document,xml);
}
catch(err:Error)
{
debugLog("Unhandled exception in DFXPParser : " + err.message);
throw err;
}
return document;
}
private function parseHead(param1:CaptioningDocument, param2:XML) : void
{
var styling:XMLList;
var styles:XMLList = null;
var i:uint = 0;
var styleNode:XML = null;
var styleObj:CaptionStyle = null;
var doc:CaptioningDocument = param1;
var xml:XML = param2;
try
{
doc.title = xml..this.ttm::title.text();
doc.description = xml..this.ttm::desc.text();
doc.copyright = xml..this.ttm::copyright.text();
}
catch(err:Error)
{
if(err.errorID != 1080)
{
throw err;
}
}
styling = xml..this.ns::styling;
if(styling.length())
{
styles = styling.children();
i = 0;
while(i < styles.length())
{
styleNode = styles[i];
styleObj = this.createStyleObject(styleNode);
doc.addStyle(styleObj);
i++;
}
}
}
private function createStyleObject(param1:XML) : CaptionStyle
{
var _loc4_:Object = null;
var _loc2_:String = param1.@id;
var _loc3_:CaptionStyle = new CaptionStyle(_loc2_);
var _loc5_:String = param1.this.tts::@backgroundColor;
if(_loc5_ != "")
{
_loc4_ = this.parseColor(_loc5_);
_loc3_.backgroundColor = _loc4_.color;
_loc3_.backgroundColorAlpha = _loc4_.alpha;
}
_loc3_.textAlign = param1.this.tts::@textAlign;
_loc5_ = param1.this.tts::@color;
if(_loc5_ != "")
{
_loc4_ = this.parseColor(_loc5_);
_loc3_.textColor = _loc4_.color;
_loc3_.textColorAlpha = _loc4_.alpha;
}
_loc3_.fontFamily = this.parseFontFamily(param1.this.tts::@fontFamily);
var _loc6_:String = this.parseFontSize(param1.this.tts::@fontSize);
_loc3_.fontSize = parseInt(_loc6_);
_loc3_.fontStyle = param1.this.tts::@fontStyle;
_loc3_.fontWeight = param1.this.tts::@fontWeight;
_loc3_.wrapOption = String(param1.this.tts::@wrapOption).toLowerCase() == "nowrap" ? false : true;
return _loc3_;
}
private function parseColor(param1:String) : Object
{
var _loc2_:Object = null;
var _loc3_:Object = null;
var _loc4_:RegExp = /^\s*#([\dA-Fa-f][\dA-Fa-f][\dA-Fa-f][\dA-Fa-f][\dA-Fa-f][\dA-Fa-f])([\dA-Fa-f][\dA-Fa-f])?\s*$/;
var _loc5_:Array = param1.match(_loc4_);
if(_loc5_ != null)
{
_loc2_ = parseInt(_loc5_[1],16);
if(_loc5_.length == 3)
{
_loc3_ = Number(parseInt(_loc5_[2]) / 255);
}
}
else
{
_loc4_ = /^\s*rgb(a)?\((\d+),(\d+),(\d+)(\)|(,(\d+)\)))\s*$/i;
_loc5_ = param1.match(_loc4_);
if(_loc5_ != null && _loc5_.length >= 5)
{
_loc2_ = (parseInt(_loc5_[2]) << 16) + (parseInt(_loc5_[3]) << 8) + parseInt(_loc5_[4]);
if(_loc5_.length == 8 && _loc5_[7] != undefined)
{
_loc3_ = Number(parseInt(_loc5_[7]) / 255);
}
}
else
{
_loc2_ = this.namedColorMap[param1.toLowerCase()];
if(_loc2_ == null)
{
_loc2_ = parseInt(param1);
if(isNaN(int(_loc2_)))
{
_loc2_ = null;
this.debugLog("Invalid DFXP document: invalid color value of " + param1);
}
}
}
}
return {
"color":_loc2_,
"alpha":_loc3_
};
}
private function parseFontSize(param1:String) : String
{
var _loc5_:RegExp = null;
var _loc6_:Object = null;
var _loc7_:RegExp = null;
var _loc8_:Object = null;
if(!param1 || param1 == "")
{
return "";
}
var _loc2_:String = "";
var _loc3_:RegExp = new RegExp(/^\s*\d+%.*$/);
var _loc4_:Object = _loc3_.exec(param1);
if(_loc4_)
{
this.debugLog("Invalid DFXP document: percentages are not supported for font size.");
_loc2_ = "";
}
else
{
_loc5_ = new RegExp(/^\s*[\+\-]\d.*/);
_loc6_ = _loc5_.exec(param1);
if(_loc6_)
{
this.debugLog("Invalid DFXP document: increment values are not supported for font size.");
_loc2_ = "";
}
else
{
_loc7_ = new RegExp(/^\s*(\d+).*$/);
_loc8_ = _loc7_.exec(param1);
if((Boolean(_loc8_)) && _loc8_[1] != undefined)
{
_loc2_ = _loc8_[1];
}
}
}
return _loc2_;
}
private function parseFontFamily(param1:String) : String
{
var _loc5_:Object = null;
if(!param1 || param1 == "")
{
return "";
}
var _loc2_:String = "";
var _loc3_:RegExp = new RegExp(/^\s*([^,\s]+)\s*((,\s*([^,\s]+)\s*)*)$/);
var _loc4_:Boolean = false;
do
{
_loc5_ = _loc3_.exec(param1);
if(!_loc5_)
{
_loc4_ = true;
}
else
{
if(_loc2_.length > 0)
{
_loc2_ += ",";
}
switch(_loc5_[1])
{
case "default":
case "serif":
case "proportionalSerif":
_loc2_ += "_serif";
break;
case "monospace":
case "monospaceSansSerif":
case "monospaceSerif":
_loc2_ += "_typewriter";
break;
case "sansSerif":
case "proportionalSansSerif":
_loc2_ += "_sans";
break;
default:
_loc2_ += _loc5_[1];
}
if(_loc5_[2] != undefined && _loc5_[2] != "")
{
param1 = _loc5_[2].slice(1);
}
else
{
_loc4_ = true;
}
}
}
while(!_loc4_);
return _loc2_;
}
private function parseBody(param1:CaptioningDocument, param2:XML) : void
{
var _loc4_:XMLList = null;
var _loc5_:XMLList = null;
var _loc6_:uint = 0;
var _loc7_:XML = null;
var _loc3_:XMLList = param2..this.ns::body;
if(_loc3_.length() <= 0)
{
this.debugLog("Invalid DFXP document: <body> tag is required.");
}
else
{
_loc4_ = param2..this.ns::div;
_loc5_ = _loc4_.length() ? _loc4_.children() : (_loc3_.length() ? _loc3_.children() : new XMLList());
_loc6_ = 0;
while(_loc6_ < _loc5_.length())
{
_loc7_ = _loc5_[_loc6_];
if(this.rootNamespace == _loc7_.namespace())
{
this.parsePTag(param1,_loc7_,_loc6_);
}
else
{
this.debugLog("Ignoring this tag, foreign namespaces not supported: \"" + _loc7_ + "\"");
}
_loc6_++;
}
}
}
private function parsePTag(param1:CaptioningDocument, param2:XML, param3:uint) : void
{
var _loc10_:String = null;
var _loc15_:XML = null;
var _loc16_:uint = 0;
var _loc17_:String = null;
var _loc18_:Array = null;
var _loc19_:uint = 0;
var _loc20_:CaptionStyle = null;
var _loc21_:CaptionFormat = null;
var _loc22_:CaptionFormat = null;
var _loc4_:String = param2.@begin;
var _loc5_:String = param2.@end;
var _loc6_:String = param2.@dur;
if(_loc4_ == "")
{
_loc4_ = "0s";
}
var _loc7_:Number = TimeUtil.parseTime(_loc4_);
var _loc8_:Number = 0;
if(_loc5_ != "")
{
_loc8_ = TimeUtil.parseTime(_loc5_);
}
else if(_loc6_ != "")
{
_loc8_ = _loc7_ + TimeUtil.parseTime(_loc6_);
}
var _loc9_:Array = new Array();
_loc10_ = new String("<p>");
var _loc11_:XMLList = param2.children();
var _loc12_:uint = 0;
while(_loc12_ < _loc11_.length())
{
_loc15_ = _loc11_[_loc12_];
switch(_loc15_.nodeKind())
{
case "text":
_loc10_ += this.formatCCText(_loc15_.toString());
break;
case "element":
switch(_loc15_.localName())
{
case "set":
case "metadata":
break;
case "span":
_loc16_ = uint(this.calcClearTextLength(_loc10_));
_loc18_ = new Array();
_loc10_ += this.parseSpanTag(param1,_loc15_,_loc18_);
_loc19_ = uint(this.calcClearTextLength(_loc10_));
for each(_loc20_ in _loc18_)
{
_loc21_ = new CaptionFormat(_loc20_,_loc16_,_loc19_);
_loc9_.push(_loc21_);
}
break;
case "br":
_loc10_ += "<br />";
break;
default:
_loc10_ += this.formatCCText(_loc15_.toString());
}
}
_loc12_++;
}
_loc10_ += "</p>";
var _loc13_:Caption = new Caption(param3,_loc7_,_loc8_,_loc10_);
var _loc14_:CaptionStyle = this.parseStyleAttrib(param1,param2);
if(_loc14_)
{
_loc22_ = new CaptionFormat(_loc14_);
_loc13_.addCaptionFormat(_loc22_);
}
_loc12_ = 0;
while(_loc12_ < _loc9_.length)
{
_loc13_.addCaptionFormat(_loc9_[_loc12_]);
_loc12_++;
}
param1.addCaption(_loc13_);
}
private function parseStyleAttrib(param1:CaptioningDocument, param2:XML) : CaptionStyle
{
var i:uint = 0;
var attributes:XMLList = null;
var attrib:XML = null;
var localName:String = null;
var doc:CaptioningDocument = param1;
var node:XML = param2;
var styleId:String = node.@style;
var captionStyle:CaptionStyle = null;
if(styleId != "")
{
while(i < doc.numStyles)
{
if(doc.getStyleAt(i).id == styleId)
{
captionStyle = doc.getStyleAt(i);
}
i++;
}
}
else
{
try
{
attributes = node.this.tts::@*;
}
catch(err:Error)
{
if(err.errorID != 1080)
{
throw err;
}
}
i = 0;
while(attributes != null && i < attributes.length())
{
attrib = attributes[i];
localName = attrib.localName();
if(localName != "inherit")
{
captionStyle = this.createStyleObject(node);
}
i++;
}
}
return captionStyle;
}
private function parseSpanTag(param1:CaptioningDocument, param2:XML, param3:Array) : String
{
var _loc8_:XML = null;
var _loc4_:CaptionStyle = this.parseStyleAttrib(param1,param2);
if(_loc4_ != null)
{
param3.push(_loc4_);
}
var _loc5_:String = new String();
var _loc6_:XMLList = param2.children();
var _loc7_:uint = 0;
while(_loc7_ < _loc6_.length())
{
_loc8_ = _loc6_[_loc7_];
switch(_loc8_.nodeKind())
{
case "text":
_loc5_ += this.formatCCText(_loc8_.toString());
break;
case "element":
switch(_loc8_.localName())
{
case "set":
case "metadata":
break;
case "br":
_loc5_ += "<br/>";
break;
default:
_loc5_ += _loc8_.toString();
}
}
_loc7_++;
}
return _loc5_;
}
private function formatCCText(param1:String) : String
{
return param1.replace(/\s+/g," ");
}
private function calcClearTextLength(param1:String) : int
{
var _loc2_:String = param1.replace(/<(.|\n)*?>/g,"");
return _loc2_.length;
}
private function debugLog(param1:String) : void
{
}
}
}
@@ -0,0 +1,11 @@
package org.osmf.captioning.parsers
{
import org.osmf.captioning.model.CaptioningDocument;
public interface ICaptioningParser
{
function parse(param1:String) : CaptioningDocument;
}
}
@@ -0,0 +1,15 @@
package org.osmf.containers
{
import org.osmf.media.MediaElement;
public interface IMediaContainer
{
function addMediaElement(param1:MediaElement) : MediaElement;
function removeMediaElement(param1:MediaElement) : MediaElement;
function containsMediaElement(param1:MediaElement) : Boolean;
}
}
@@ -0,0 +1,211 @@
package org.osmf.containers
{
import flash.display.DisplayObject;
import flash.errors.IllegalOperationError;
import flash.geom.Rectangle;
import flash.utils.Dictionary;
import org.osmf.events.ContainerChangeEvent;
import org.osmf.layout.LayoutMetadata;
import org.osmf.layout.LayoutRenderer;
import org.osmf.layout.LayoutRendererBase;
import org.osmf.layout.LayoutTargetEvent;
import org.osmf.layout.LayoutTargetSprite;
import org.osmf.layout.MediaElementLayoutTarget;
import org.osmf.media.MediaElement;
import org.osmf.utils.OSMFStrings;
public class MediaContainer extends LayoutTargetSprite implements IMediaContainer
{
private var layoutTargets:Dictionary = new Dictionary();
private var _layoutRenderer:LayoutRendererBase;
private var _backgroundColor:Number;
private var _backgroundAlpha:Number;
private var lastAvailableWidth:Number;
private var lastAvailableHeight:Number;
public function MediaContainer(param1:LayoutRendererBase = null, param2:LayoutMetadata = null)
{
super(param2);
this._layoutRenderer = param1 || new LayoutRenderer();
this._layoutRenderer.container = this;
}
public function addMediaElement(param1:MediaElement) : MediaElement
{
var _loc2_:MediaElementLayoutTarget = null;
if(param1 == null)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
if(this.layoutTargets[param1] == undefined)
{
param1.dispatchEvent(new ContainerChangeEvent(ContainerChangeEvent.CONTAINER_CHANGE,false,false,param1.container,this));
_loc2_ = MediaElementLayoutTarget.getInstance(param1);
this.layoutTargets[param1] = _loc2_;
this._layoutRenderer.addTarget(_loc2_);
param1.addEventListener(ContainerChangeEvent.CONTAINER_CHANGE,this.onElementContainerChange);
return param1;
}
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
public function removeMediaElement(param1:MediaElement) : MediaElement
{
var _loc2_:MediaElement = null;
if(param1 == null)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
var _loc3_:MediaElementLayoutTarget = this.layoutTargets[param1];
if(_loc3_)
{
param1.removeEventListener(ContainerChangeEvent.CONTAINER_CHANGE,this.onElementContainerChange);
this._layoutRenderer.removeTarget(_loc3_);
delete this.layoutTargets[param1];
_loc2_ = param1;
if(param1.container == this)
{
param1.dispatchEvent(new ContainerChangeEvent(ContainerChangeEvent.CONTAINER_CHANGE,false,false,param1.container,null));
}
return _loc2_;
}
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
public function containsMediaElement(param1:MediaElement) : Boolean
{
return this.layoutTargets[param1] != undefined;
}
public function get layoutRenderer() : LayoutRendererBase
{
return this._layoutRenderer;
}
public function get clipChildren() : Boolean
{
return scrollRect != null;
}
public function set clipChildren(param1:Boolean) : void
{
if(param1 && scrollRect == null)
{
scrollRect = new Rectangle(0,0,this._layoutRenderer.measuredWidth,this._layoutRenderer.measuredHeight);
}
else if(param1 == false && Boolean(scrollRect))
{
scrollRect = null;
}
}
public function get backgroundColor() : Number
{
return this._backgroundColor;
}
public function set backgroundColor(param1:Number) : void
{
if(param1 != this._backgroundColor)
{
this._backgroundColor = param1;
this.drawBackground();
}
}
public function get backgroundAlpha() : Number
{
return this._backgroundAlpha;
}
public function set backgroundAlpha(param1:Number) : void
{
if(param1 != this._backgroundAlpha)
{
this._backgroundAlpha = param1;
this.drawBackground();
}
}
override public function layout(param1:Number, param2:Number, param3:Boolean = true) : void
{
super.layout(param1,param2,param3);
this.lastAvailableWidth = param1;
this.lastAvailableHeight = param2;
if(!isNaN(this.backgroundColor))
{
this.drawBackground();
}
if(scrollRect)
{
scrollRect = new Rectangle(0,0,param1,param2);
}
}
override public function validateNow() : void
{
this._layoutRenderer.validateNow();
}
override public function addChild(param1:DisplayObject) : DisplayObject
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.DIRECT_DISPLAY_LIST_MOD_ERROR));
}
override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.DIRECT_DISPLAY_LIST_MOD_ERROR));
}
override public function removeChild(param1:DisplayObject) : DisplayObject
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.DIRECT_DISPLAY_LIST_MOD_ERROR));
}
override public function setChildIndex(param1:DisplayObject, param2:int) : void
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.DIRECT_DISPLAY_LIST_MOD_ERROR));
}
override protected function onAddChildAt(param1:LayoutTargetEvent) : void
{
super.addChildAt(param1.displayObject,param1.index);
}
override protected function onRemoveChild(param1:LayoutTargetEvent) : void
{
super.removeChild(param1.displayObject);
}
override protected function onSetChildIndex(param1:LayoutTargetEvent) : void
{
super.setChildIndex(param1.displayObject,param1.index);
}
private function drawBackground() : void
{
graphics.clear();
if(Boolean(!isNaN(this._backgroundColor) && this._backgroundAlpha != 0) && Boolean(this.lastAvailableWidth) && Boolean(this.lastAvailableHeight))
{
graphics.beginFill(this._backgroundColor,this._backgroundAlpha);
graphics.drawRect(0,0,this.lastAvailableWidth,this.lastAvailableHeight);
graphics.endFill();
}
}
private function onElementContainerChange(param1:ContainerChangeEvent) : void
{
if(param1.oldContainer == this)
{
this.removeMediaElement(param1.target as MediaElement);
}
}
}
}
@@ -0,0 +1,183 @@
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.MediaErrorCodes;
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.MediaTraitType;
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(OSMFStrings.INVALID_PARAM));
}
}
public function get defaultDuration() : Number
{
return this.defaultTimeTrait ? this.defaultTimeTrait.duration : NaN;
}
public function set defaultDuration(param1:Number) : void
{
if(isNaN(param1) || param1 < 0)
{
if(this.defaultTimeTrait != null)
{
removeTraitResolver(MediaTraitType.TIME);
this.defaultTimeTrait = null;
}
}
else
{
if(this.defaultTimeTrait == null)
{
this.defaultTimeTrait = new ModifiableTimeTrait();
addTraitResolver(MediaTraitType.TIME,new DefaultTraitResolver(MediaTraitType.TIME,this.defaultTimeTrait));
}
this.defaultTimeTrait.duration = param1;
}
}
override public function set resource(param1:MediaResourceBase) : void
{
loader = getLoaderForResource(param1,this.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 _loc2_:TimeTrait = null;
var _loc4_:Boolean = false;
var _loc5_:SoundLoadTrait = null;
var _loc1_:LoadTrait = getTrait(MediaTraitType.LOAD) as LoadTrait;
this.soundAdapter = null;
this.stream = null;
var _loc3_:NetStreamLoadTrait = _loc1_ as NetStreamLoadTrait;
if(_loc3_)
{
this.stream = _loc3_.netStream;
this.stream.addEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent);
_loc3_.connection.addEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent,false,0,true);
_loc4_ = false;
if(loader is NetLoader)
{
_loc4_ = (loader as NetLoader).reconnectStreams;
}
addTrait(MediaTraitType.PLAY,new NetStreamPlayTrait(this.stream,resource,_loc4_,_loc3_.connection));
_loc2_ = new NetStreamTimeTrait(this.stream,resource,this.defaultDuration);
addTrait(MediaTraitType.TIME,_loc2_);
addTrait(MediaTraitType.SEEK,new NetStreamSeekTrait(_loc2_,_loc1_,this.stream));
addTrait(MediaTraitType.AUDIO,new NetStreamAudioTrait(this.stream));
addTrait(MediaTraitType.BUFFER,new NetStreamBufferTrait(this.stream));
}
else
{
_loc5_ = _loc1_ as SoundLoadTrait;
this.soundAdapter = new SoundAdapter(this,_loc5_.sound);
addTrait(MediaTraitType.PLAY,new AudioPlayTrait(this.soundAdapter));
_loc2_ = new AudioTimeTrait(this.soundAdapter);
addTrait(MediaTraitType.TIME,_loc2_);
addTrait(MediaTraitType.SEEK,new AudioSeekTrait(_loc2_,this.soundAdapter));
addTrait(MediaTraitType.AUDIO,new AudioAudioTrait(this.soundAdapter));
}
}
override protected function processUnloadingState() : void
{
if(this.stream != null)
{
this.stream.removeEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent);
}
var _loc1_:NetStreamLoadTrait = getTrait(MediaTraitType.LOAD) as NetStreamLoadTrait;
if(_loc1_ != null)
{
_loc1_.connection.removeEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent);
}
removeTrait(MediaTraitType.PLAY);
removeTrait(MediaTraitType.SEEK);
removeTrait(MediaTraitType.TIME);
removeTrait(MediaTraitType.AUDIO);
removeTrait(MediaTraitType.BUFFER);
if(this.soundAdapter != null)
{
this.soundAdapter.pause();
}
this.soundAdapter = null;
this.stream = null;
}
private function onNetStatusEvent(param1:NetStatusEvent) : void
{
var _loc2_:MediaError = null;
switch(param1.info.code)
{
case NetStreamCodes.NETSTREAM_PLAY_FAILED:
case NetStreamCodes.NETSTREAM_FAILED:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_PLAY_FAILED,param1.info.description);
break;
case NetStreamCodes.NETSTREAM_PLAY_STREAMNOTFOUND:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_STREAM_NOT_FOUND,param1.info.description);
break;
case NetStreamCodes.NETSTREAM_PLAY_FILESTRUCTUREINVALID:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_FILE_STRUCTURE_INVALID,param1.info.description);
break;
case NetStreamCodes.NETSTREAM_PLAY_NOSUPPORTEDTRACKFOUND:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_NO_SUPPORTED_TRACK_FOUND,param1.info.description);
break;
case NetConnectionCodes.CONNECT_IDLE_TIME_OUT:
_loc2_ = new MediaError(MediaErrorCodes.NETCONNECTION_TIMEOUT,param1.info.description);
}
if(_loc2_ != null)
{
dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,_loc2_));
}
}
private function get alternateLoaders() : Vector.<LoaderBase>
{
if(this._alternateLoaders == null)
{
this._alternateLoaders = new Vector.<LoaderBase>();
this._alternateLoaders.push(new SoundLoader());
this._alternateLoaders.push(new NetLoader());
}
return this._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,196 @@
package org.osmf.elements
{
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.SecurityErrorEvent;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
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.MediaErrorCodes;
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.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.OSMFStrings;
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();
this.supportedMimeTypes.push(F4M_MIME_TYPE);
if(param1 == null)
{
param1 = new DefaultMediaFactory();
}
this.parser = new ManifestParser();
this.factory = param1;
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc3_:URLResource = null;
var _loc4_:String = null;
var _loc2_:int = MediaTypeUtil.checkMetadataMatchWithResource(param1,new Vector.<String>(),this.supportedMimeTypes);
if(_loc2_ == MediaTypeUtil.METADATA_MATCH_FOUND)
{
return true;
}
if(param1 is URLResource)
{
_loc3_ = URLResource(param1);
_loc4_ = new URL(_loc3_.url).extension;
return _loc4_ == F4M_EXTENSION;
}
return false;
}
override protected function executeLoad(param1:LoadTrait) : void
{
var manifest:Manifest = null;
var manifestLoader:URLLoader = null;
var onError:Function = null;
var onComplete:Function = null;
var loadTrait:LoadTrait = param1;
onError = function(param1:ErrorEvent):void
{
manifestLoader.removeEventListener(Event.COMPLETE,onComplete);
manifestLoader.removeEventListener(IOErrorEvent.IO_ERROR,onError);
manifestLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,onError);
updateLoadTrait(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(0,param1.text)));
};
onComplete = function(param1:Event):void
{
var completionCallback:Function;
var unfinishedLoads:Number = NaN;
var item:DRMAdditionalHeader = null;
var event:Event = param1;
manifestLoader.removeEventListener(Event.COMPLETE,onComplete);
manifestLoader.removeEventListener(IOErrorEvent.IO_ERROR,onError);
manifestLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,onError);
try
{
manifest = parser.parse(event.target.data,getRootUrl(URLResource(loadTrait.resource).url));
}
catch(parseError:Error)
{
updateLoadTrait(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,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;
}
if(unfinishedLoads == 0)
{
finishLoad();
}
};
unfinishedLoads++;
loadAdditionalHeader(item,completionCallback,onError);
}
}
if(unfinishedLoads == 0)
{
finishLoad();
}
}
};
var finishLoad:Function = function():void
{
var netResource:MediaResourceBase = null;
var loadedElem:MediaElement = null;
var s:OSMFStrings = null;
try
{
netResource = parser.createResource(manifest,URLResource(loadTrait.resource));
loadedElem = factory.createMediaElement(netResource);
if(loadedElem.hasOwnProperty("defaultDuration") && !isNaN(manifest.duration))
{
loadedElem["defaultDuration"] = manifest.duration;
}
LoadFromDocumentLoadTrait(loadTrait).mediaElement = loadedElem;
updateLoadTrait(loadTrait,LoadState.READY);
}
catch(error:Error)
{
updateLoadTrait(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.F4M_FILE_INVALID,error.message)));
}
};
updateLoadTrait(loadTrait,LoadState.LOADING);
manifestLoader = new URLLoader(new URLRequest(URLResource(loadTrait.resource).url));
manifestLoader.addEventListener(Event.COMPLETE,onComplete);
manifestLoader.addEventListener(IOErrorEvent.IO_ERROR,onError);
manifestLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,onError);
}
override protected function executeUnload(param1:LoadTrait) : void
{
updateLoadTrait(param1,LoadState.UNINITIALIZED);
}
private function loadAdditionalHeader(param1:DRMAdditionalHeader, param2:Function, param3:Function) : void
{
var onDRMLoadComplete:Function = null;
var item:DRMAdditionalHeader = param1;
var completionCallback:Function = param2;
var onError:Function = param3;
onDRMLoadComplete = function(param1:Event):void
{
param1.target.removeEventListener(Event.COMPLETE,onDRMLoadComplete);
param1.target.removeEventListener(IOErrorEvent.IO_ERROR,onError);
param1.target.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,onError);
item.data = URLLoader(param1.target).data;
completionCallback(true);
};
var drmLoader:URLLoader = new URLLoader();
drmLoader.dataFormat = URLLoaderDataFormat.BINARY;
drmLoader.addEventListener(Event.COMPLETE,onDRMLoadComplete);
drmLoader.addEventListener(IOErrorEvent.IO_ERROR,onError);
drmLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,onError);
drmLoader.load(new URLRequest(HTTPStreamingUtils.normalizeURL(item.url)));
}
private function getRootUrl(param1:String) : String
{
return param1.substr(0,param1.lastIndexOf("/"));
}
}
}
@@ -0,0 +1,86 @@
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;
import org.osmf.traits.MediaTraitType;
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 this._smoothing;
}
public function set smoothing(param1:Boolean) : void
{
if(this._smoothing != param1)
{
this._smoothing = param1;
this.applySmoothingSetting();
}
}
override protected function createLoadTrait(param1:MediaResourceBase, param2:LoaderBase) : LoadTrait
{
return new LoaderLoadTrait(param2,param1);
}
override protected function processReadyState() : void
{
var _loc1_:LoaderLoadTrait = getTrait(MediaTraitType.LOAD) as LoaderLoadTrait;
addTrait(MediaTraitType.DISPLAY_OBJECT,LoaderUtils.createDisplayObjectTrait(_loc1_.loader,this));
this.applySmoothingSetting();
}
override protected function processUnloadingState() : void
{
removeTrait(MediaTraitType.DISPLAY_OBJECT);
}
private function applySmoothingSetting() : void
{
var _loc2_:Loader = null;
var _loc3_:Bitmap = null;
var _loc1_:DisplayObjectTrait = getTrait(MediaTraitType.DISPLAY_OBJECT) as DisplayObjectTrait;
if(_loc1_)
{
_loc2_ = _loc1_.displayObject as Loader;
if(_loc2_ != null)
{
try
{
_loc3_ = _loc2_.content as Bitmap;
if(_loc3_ != null)
{
_loc3_.smoothing = this._smoothing;
}
}
catch(error:SecurityError)
{
}
}
}
}
}
}
@@ -0,0 +1,55 @@
package org.osmf.elements
{
import org.osmf.elements.loaderClasses.LoaderUtils;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.MediaType;
import org.osmf.media.MediaTypeUtil;
import org.osmf.media.URLResource;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.*;
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>([MediaType.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_ != MediaTypeUtil.METADATA_MATCH_UNKNOWN)
{
return _loc2_ == MediaTypeUtil.METADATA_MATCH_FOUND;
}
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,this.checkPolicyFile);
}
override protected function executeUnload(param1:LoadTrait) : void
{
LoaderUtils.unloadLoadTrait(param1,updateLoadTrait);
}
}
}
@@ -0,0 +1,435 @@
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.system.SystemUpdaterType;
import flash.utils.ByteArray;
import org.osmf.events.DRMEvent;
import org.osmf.events.MediaError;
import org.osmf.events.MediaErrorCodes;
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.NetConnectionCodes;
import org.osmf.net.NetLoader;
import org.osmf.net.NetStreamAudioTrait;
import org.osmf.net.NetStreamBufferTrait;
import org.osmf.net.NetStreamCodes;
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.StreamType;
import org.osmf.net.StreamingURLResource;
import org.osmf.net.drm.NetStreamDRMTrait;
import org.osmf.traits.DRMState;
import org.osmf.traits.DisplayObjectTrait;
import org.osmf.traits.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.traits.MediaTraitBase;
import org.osmf.traits.MediaTraitType;
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(OSMFStrings.INVALID_PARAM));
}
}
public function get client() : NetClient
{
return this.stream != null ? this.stream.client as NetClient : null;
}
public function get defaultDuration() : Number
{
return this.defaultTimeTrait ? this.defaultTimeTrait.duration : NaN;
}
public function set defaultDuration(param1:Number) : void
{
if(isNaN(param1) || param1 < 0)
{
if(this.defaultTimeTrait != null)
{
removeTraitResolver(MediaTraitType.TIME);
this.defaultTimeTrait = null;
}
}
else
{
if(this.defaultTimeTrait == null)
{
this.defaultTimeTrait = new ModifiableTimeTrait();
addTraitResolver(MediaTraitType.TIME,new DefaultTraitResolver(MediaTraitType.TIME,this.defaultTimeTrait));
}
this.defaultTimeTrait.duration = param1;
}
}
public function get smoothing() : Boolean
{
return this._smoothing;
}
public function set smoothing(param1:Boolean) : void
{
this._smoothing = param1;
if(this.video != null)
{
this.video.smoothing = param1;
}
}
public function get deblocking() : int
{
return this._deblocking;
}
public function set deblocking(param1:int) : void
{
this._deblocking = param1;
if(this.video != null)
{
this.video.deblocking = param1;
}
}
public function get currentFPS() : Number
{
return this.stream != null ? this.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_:StreamingURLResource = null;
var _loc3_:ByteArray = null;
var _loc1_:NetStreamLoadTrait = getTrait(MediaTraitType.LOAD) as NetStreamLoadTrait;
this.stream = _loc1_.netStream;
this.video = this.createVideo();
this.video.smoothing = this._smoothing;
this.video.deblocking = this._deblocking;
this.video.width = this.video.height = 0;
this.video.attachNetStream(this.stream);
NetClient(this.stream.client).addHandler(NetStreamCodes.ON_META_DATA,this.onMetaData);
NetClient(this.stream.client).addHandler(NetStreamCodes.ON_CUE_POINT,this.onCuePoint);
this.stream.addEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent);
_loc1_.connection.addEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent,false,0,true);
this.stream.addEventListener(DRMErrorEvent.DRM_ERROR,this.onDRMErrorEvent);
_loc2_ = resource as StreamingURLResource;
if(_loc2_ != null && Boolean(_loc2_.drmContentData))
{
_loc3_ = _loc2_.drmContentData;
this.setupDRMTrait(_loc3_);
}
else
{
this.stream.addEventListener(StatusEvent.STATUS,this.onStatus);
this.stream.addEventListener(DRMStatusEvent.DRM_STATUS,this.onDRMStatus);
}
this.finishLoad();
}
private function finishLoad() : void
{
var reconnectStreams:Boolean;
var dsResource:DynamicStreamingResource;
var trait:MediaTraitBase = null;
var timeTrait:TimeTrait = null;
var onDurationChange:Function = null;
var dsTrait:MediaTraitBase = null;
var loadTrait:NetStreamLoadTrait = getTrait(MediaTraitType.LOAD) as NetStreamLoadTrait;
trait = loadTrait.getTrait(MediaTraitType.DVR);
if(trait != null)
{
addTrait(MediaTraitType.DVR,trait);
}
trait = loadTrait.getTrait(MediaTraitType.AUDIO);
addTrait(MediaTraitType.AUDIO,trait || new NetStreamAudioTrait(this.stream));
trait = loadTrait.getTrait(MediaTraitType.BUFFER);
addTrait(MediaTraitType.BUFFER,trait || new NetStreamBufferTrait(this.stream));
timeTrait = (trait = loadTrait.getTrait(MediaTraitType.TIME)) as TimeTrait;
if(timeTrait == null)
{
timeTrait = new NetStreamTimeTrait(this.stream,loadTrait.resource,this.defaultDuration);
}
addTrait(MediaTraitType.TIME,timeTrait);
trait = loadTrait.getTrait(MediaTraitType.DISPLAY_OBJECT);
addTrait(MediaTraitType.DISPLAY_OBJECT,trait || new NetStreamDisplayObjectTrait(this.stream,this.video,NaN,NaN));
trait = loadTrait.getTrait(MediaTraitType.PLAY);
reconnectStreams = false;
reconnectStreams = (loader as NetLoader).reconnectStreams;
addTrait(MediaTraitType.PLAY,trait || new NetStreamPlayTrait(this.stream,resource,reconnectStreams,loadTrait.connection));
trait = loadTrait.getTrait(MediaTraitType.SEEK);
if(trait == null && NetStreamUtils.getStreamType(resource) != StreamType.LIVE)
{
trait = new NetStreamSeekTrait(timeTrait,loadTrait,this.stream,this.video);
}
if(trait != null)
{
if(isNaN(timeTrait.duration) || timeTrait.duration == 0)
{
onDurationChange = function(param1:TimeEvent):void
{
timeTrait.removeEventListener(TimeEvent.DURATION_CHANGE,onDurationChange);
addTrait(MediaTraitType.SEEK,trait);
};
timeTrait.addEventListener(TimeEvent.DURATION_CHANGE,onDurationChange);
}
else
{
addTrait(MediaTraitType.SEEK,trait);
}
}
dsResource = resource as DynamicStreamingResource;
if(dsResource != null && loadTrait.switchManager != null)
{
dsTrait = loadTrait.getTrait(MediaTraitType.DYNAMIC_STREAM);
addTrait(MediaTraitType.DYNAMIC_STREAM,dsTrait || new NetStreamDynamicStreamTrait(this.stream,loadTrait.switchManager,dsResource));
}
}
override protected function processUnloadingState() : void
{
var _loc1_:NetStreamLoadTrait = getTrait(MediaTraitType.LOAD) as NetStreamLoadTrait;
NetClient(this.stream.client).removeHandler(NetStreamCodes.ON_META_DATA,this.onMetaData);
this.stream.removeEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent);
_loc1_.connection.removeEventListener(NetStatusEvent.NET_STATUS,this.onNetStatusEvent);
removeTrait(MediaTraitType.AUDIO);
removeTrait(MediaTraitType.BUFFER);
removeTrait(MediaTraitType.PLAY);
removeTrait(MediaTraitType.TIME);
removeTrait(MediaTraitType.DISPLAY_OBJECT);
removeTrait(MediaTraitType.SEEK);
removeTrait(MediaTraitType.DYNAMIC_STREAM);
removeTrait(MediaTraitType.DVR);
this.stream.removeEventListener(DRMErrorEvent.DRM_ERROR,this.onDRMErrorEvent);
this.stream.removeEventListener(DRMStatusEvent.DRM_STATUS,this.onDRMStatus);
this.stream.removeEventListener(StatusEvent.STATUS,this.onStatus);
if(this.drmTrait != null)
{
this.drmTrait.removeEventListener(DRMEvent.DRM_STATE_CHANGE,this.reloadAfterAuth);
removeTrait(MediaTraitType.DRM);
this.drmTrait = null;
}
this.video.attachNetStream(null);
this.stream = null;
this.video = null;
this.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(CuePoint.DYNAMIC_CUEPOINTS_NAMESPACE) as TimelineMetadata;
if(_loc3_ == null)
{
_loc3_ = new TimelineMetadata(this);
addMetadata(CuePoint.DYNAMIC_CUEPOINTS_NAMESPACE,_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(this.embeddedCuePoints == null)
{
this.embeddedCuePoints = new TimelineMetadata(this);
addMetadata(CuePoint.EMBEDDED_CUEPOINTS_NAMESPACE,this.embeddedCuePoints);
}
var _loc2_:CuePoint = new CuePoint(param1.type,param1.time,param1.name,param1.parameters);
try
{
this.embeddedCuePoints.addMarker(_loc2_);
}
catch(error:ArgumentError)
{
}
}
private function onUpdateComplete(param1:Event) : void
{
(getTrait(MediaTraitType.LOAD) as LoadTrait).unload();
(getTrait(MediaTraitType.LOAD) as LoadTrait).load();
}
private function onNetStatusEvent(param1:NetStatusEvent) : void
{
var _loc2_:MediaError = null;
switch(param1.info.code)
{
case NetStreamCodes.NETSTREAM_PLAY_FAILED:
case NetStreamCodes.NETSTREAM_FAILED:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_PLAY_FAILED,param1.info.description);
break;
case NetStreamCodes.NETSTREAM_PLAY_STREAMNOTFOUND:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_STREAM_NOT_FOUND,param1.info.description);
break;
case NetStreamCodes.NETSTREAM_PLAY_FILESTRUCTUREINVALID:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_FILE_STRUCTURE_INVALID,param1.info.description);
break;
case NetStreamCodes.NETSTREAM_PLAY_NOSUPPORTEDTRACKFOUND:
_loc2_ = new MediaError(MediaErrorCodes.NETSTREAM_NO_SUPPORTED_TRACK_FOUND,param1.info.description);
break;
case NetConnectionCodes.CONNECT_IDLE_TIME_OUT:
_loc2_ = new MediaError(MediaErrorCodes.NETCONNECTION_TIMEOUT,param1.info.description);
}
if(param1.info.code == NetStreamCodes.NETSTREAM_DRM_UPDATE)
{
this.update(SystemUpdaterType.DRM);
}
if(_loc2_ != null)
{
dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,_loc2_));
}
}
private function onStatus(param1:StatusEvent) : void
{
if(param1.code == DRM_STATUS_CODE && getTrait(MediaTraitType.DRM) == null)
{
this.createDRMTrait();
}
}
private function onDRMStatus(param1:DRMStatusEvent) : void
{
this.drmTrait.inlineOnVoucher(param1);
}
private function reloadAfterAuth(param1:DRMEvent) : void
{
var _loc2_:NetStreamLoadTrait = null;
if(this.drmTrait.drmState == DRMState.AUTHENTICATION_COMPLETE)
{
_loc2_ = getTrait(MediaTraitType.LOAD) as NetStreamLoadTrait;
if(_loc2_.loadState == LoadState.READY)
{
_loc2_.unload();
}
_loc2_.load();
}
}
private function createDRMTrait() : void
{
this.drmTrait = new NetStreamDRMTrait();
addTrait(MediaTraitType.DRM,this.drmTrait);
}
private function setupDRMTrait(param1:ByteArray) : void
{
this.createDRMTrait();
this.drmTrait.drmMetadata = param1;
}
private function onDRMErrorEvent(param1:DRMErrorEvent) : void
{
if(param1.errorID == DRM_NEEDS_AUTHENTICATION)
{
this.drmTrait.addEventListener(DRMEvent.DRM_STATE_CHANGE,this.reloadAfterAuth);
this.drmTrait.drmMetadata = param1.contentData;
}
else if(param1.drmUpdateNeeded)
{
this.update(SystemUpdaterType.DRM);
}
else if(param1.systemUpdateNeeded)
{
this.update(SystemUpdaterType.SYSTEM);
}
else
{
this.drmTrait.inlineDRMFailed(new MediaError(param1.errorID));
}
}
private function update(param1:String) : void
{
if(this.drmTrait == null)
{
this.createDRMTrait();
}
var _loc2_:SystemUpdater = this.drmTrait.update(param1);
_loc2_.addEventListener(Event.COMPLETE,this.onUpdateComplete);
}
}
}
@@ -0,0 +1,90 @@
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.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.traits.MediaTraitType;
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(OSMFStrings.NULL_PARAM));
}
}
override public function set resource(param1:MediaResourceBase) : void
{
if(this._resource != param1 && param1 != null)
{
this._resource = param1;
this.loadTrait = new LoadFromDocumentLoadTrait(this.loader,this.resource);
this.loadTrait.addEventListener(LoadEvent.LOAD_STATE_CHANGE,this.onLoadStateChange,false,int.MAX_VALUE);
if(super.getTrait(MediaTraitType.LOAD) != null)
{
super.removeTrait(MediaTraitType.LOAD);
}
super.addTrait(MediaTraitType.LOAD,this.loadTrait);
}
}
override public function get resource() : MediaResourceBase
{
return this._resource;
}
private function onLoaderStateChange(param1:Event) : void
{
removeTrait(MediaTraitType.LOAD);
proxiedElement = this.loadTrait.mediaElement;
}
private function onLoadStateChange(param1:LoadEvent) : void
{
var proxiedLoadTrait:LoadTrait = null;
var onProxiedElementLoadStateChange:Function = null;
var event:LoadEvent = param1;
if(event.loadState == LoadState.READY)
{
onProxiedElementLoadStateChange = function(param1:LoadEvent):void
{
if(param1.loadState == LoadState.LOADING)
{
param1.stopImmediatePropagation();
}
else
{
proxiedLoadTrait.removeEventListener(LoadEvent.LOAD_STATE_CHANGE,onProxiedElementLoadStateChange);
}
};
event.stopImmediatePropagation();
removeTrait(MediaTraitType.LOAD);
proxiedLoadTrait = this.loadTrait.mediaElement.getTrait(MediaTraitType.LOAD) as LoadTrait;
proxiedLoadTrait.addEventListener(LoadEvent.LOAD_STATE_CHANGE,onProxiedElementLoadStateChange,false,int.MAX_VALUE);
proxiedElement = this.loadTrait.mediaElement;
if(proxiedLoadTrait.loadState == LoadState.UNINITIALIZED)
{
proxiedLoadTrait.load();
}
}
}
}
}
@@ -0,0 +1,283 @@
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(MediaElementEvent.TRAIT_ADD,this.onProxyTraitAdd,false,int.MAX_VALUE);
this.addEventListener(MediaElementEvent.TRAIT_REMOVE,this.onProxyTraitRemove,false,int.MAX_VALUE);
this.addEventListener(ContainerChangeEvent.CONTAINER_CHANGE,this.onProxyContainerChange);
this.proxiedElement = param1;
}
public function get proxiedElement() : MediaElement
{
return this._proxiedElement;
}
public function set proxiedElement(param1:MediaElement) : void
{
var _loc2_:String = null;
if(param1 != this._proxiedElement)
{
if(this._proxiedElement != null)
{
this.toggleMediaElementListeners(this._proxiedElement,false);
for each(_loc2_ in this._proxiedElement.traitTypes)
{
if(super.hasTrait(_loc2_) == false && (this._blockedTraits == null || this._blockedTraits.indexOf(_loc2_) == -1))
{
super.dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_REMOVE,false,false,_loc2_));
}
}
}
this._proxiedElement = param1;
if(this._proxiedElement != null)
{
ProxyMetadata(metadata).metadata = this._proxiedElement.metadata;
this._proxiedElement.dispatchEvent(new ContainerChangeEvent(ContainerChangeEvent.CONTAINER_CHANGE,false,false,this._proxiedElement.container,container));
this.toggleMediaElementListeners(this._proxiedElement,true);
for each(_loc2_ in this._proxiedElement.traitTypes)
{
if(super.hasTrait(_loc2_) == false && (this._blockedTraits == null || this._blockedTraits.indexOf(_loc2_) == -1))
{
super.dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_ADD,false,false,_loc2_));
}
}
}
}
}
override public function get traitTypes() : Vector.<String>
{
var _loc2_:String = null;
var _loc1_:Vector.<String> = new Vector.<String>();
for each(_loc2_ in MediaTraitType.ALL_TYPES)
{
if(this.hasTrait(_loc2_))
{
_loc1_.push(_loc2_);
}
}
return _loc1_;
}
override public function hasTrait(param1:String) : Boolean
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this.getTrait(param1) != null;
}
override public function getTrait(param1:String) : MediaTraitBase
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
var _loc2_:MediaTraitBase = null;
if(this.blocksTrait(param1) == false)
{
_loc2_ = super.getTrait(param1) || (this.proxiedElement != null ? this.proxiedElement.getTrait(param1) : null);
}
return _loc2_;
}
override public function get resource() : MediaResourceBase
{
return this.proxiedElement ? this.proxiedElement.resource : null;
}
override public function set resource(param1:MediaResourceBase) : void
{
if(this.proxiedElement != null)
{
this.proxiedElement.resource = param1;
}
}
override protected function addTrait(param1:String, param2:MediaTraitBase) : void
{
if(this.blocksTrait(param1) == false && this.proxiedElement != null && this.proxiedElement.hasTrait(param1) == true)
{
super.dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_REMOVE,false,false,param1));
}
super.addTrait(param1,param2);
}
override protected function removeTrait(param1:String) : MediaTraitBase
{
var _loc2_:MediaTraitBase = super.removeTrait(param1);
if(this.blocksTrait(param1) == false && this.proxiedElement != null && this.proxiedElement.hasTrait(param1) == true)
{
super.dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_ADD,false,false,param1));
}
return _loc2_;
}
override protected function createMetadata() : Metadata
{
return new ProxyMetadata();
}
final protected function get blockedTraits() : Vector.<String>
{
if(this._blockedTraits == null)
{
this._blockedTraits = new Vector.<String>();
}
return this._blockedTraits;
}
final protected function set blockedTraits(param1:Vector.<String>) : void
{
var _loc4_:String = null;
if(param1 == this._blockedTraits)
{
return;
}
var _loc2_:Array = [];
var _loc3_:Array = [];
if(this._proxiedElement != null)
{
for each(_loc4_ in MediaTraitType.ALL_TYPES)
{
if(param1.indexOf(_loc4_) != -1)
{
if(this._blockedTraits == null || this._blockedTraits.indexOf(_loc4_) == -1)
{
_loc2_.push(_loc4_);
}
}
else if(this._blockedTraits != null && this._blockedTraits.indexOf(_loc4_) != -1)
{
_loc3_.push(_loc4_);
}
}
}
if(this._proxiedElement != null)
{
for each(_loc4_ in _loc2_)
{
if(this.proxiedElement.hasTrait(_loc4_) || Boolean(super.hasTrait(_loc4_)))
{
dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_REMOVE,false,false,_loc4_));
}
}
this._blockedTraits = param1;
for each(_loc4_ in _loc3_)
{
if(this.proxiedElement.hasTrait(_loc4_) || Boolean(super.hasTrait(_loc4_)))
{
dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_ADD,false,false,_loc4_));
}
}
}
else
{
this._blockedTraits = param1;
}
}
private function toggleMediaElementListeners(param1:MediaElement, param2:Boolean) : void
{
if(param2)
{
this._proxiedElement.addEventListener(MediaErrorEvent.MEDIA_ERROR,this.onMediaError);
this._proxiedElement.addEventListener(MediaElementEvent.TRAIT_ADD,this.onTraitAdd);
this._proxiedElement.addEventListener(MediaElementEvent.TRAIT_REMOVE,this.onTraitRemove);
this._proxiedElement.addEventListener(MediaElementEvent.METADATA_ADD,this.onMetadataEvent);
this._proxiedElement.addEventListener(MediaElementEvent.METADATA_REMOVE,this.onMetadataEvent);
}
else
{
this._proxiedElement.removeEventListener(MediaErrorEvent.MEDIA_ERROR,this.onMediaError);
this._proxiedElement.removeEventListener(MediaElementEvent.TRAIT_ADD,this.onTraitAdd);
this._proxiedElement.removeEventListener(MediaElementEvent.TRAIT_REMOVE,this.onTraitRemove);
this._proxiedElement.removeEventListener(MediaElementEvent.METADATA_ADD,this.onMetadataEvent);
this._proxiedElement.removeEventListener(MediaElementEvent.METADATA_REMOVE,this.onMetadataEvent);
}
}
private function onMediaError(param1:MediaErrorEvent) : void
{
dispatchEvent(param1.clone());
}
private function onTraitAdd(param1:MediaElementEvent) : void
{
this.processTraitsChangeEvent(param1);
}
private function onTraitRemove(param1:MediaElementEvent) : void
{
this.processTraitsChangeEvent(param1);
}
private function onMetadataEvent(param1:MediaElementEvent) : void
{
dispatchEvent(param1.clone());
}
private function onProxyContainerChange(param1:ContainerChangeEvent) : void
{
if(this.proxiedElement != null)
{
this.proxiedElement.dispatchEvent(param1.clone());
}
}
private function onProxyTraitAdd(param1:MediaElementEvent) : void
{
this.processProxyTraitsChangeEvent(param1);
}
private function onProxyTraitRemove(param1:MediaElementEvent) : void
{
this.processProxyTraitsChangeEvent(param1);
}
private function processTraitsChangeEvent(param1:MediaElementEvent) : void
{
if(this.blocksTrait(param1.traitType) == false && super.hasTrait(param1.traitType) == false)
{
super.dispatchEvent(param1.clone());
}
}
private function processProxyTraitsChangeEvent(param1:MediaElementEvent) : void
{
if(this.blocksTrait(param1.traitType) == true)
{
param1.stopImmediatePropagation();
}
}
private function blocksTrait(param1:String) : Boolean
{
return Boolean(this._blockedTraits) && this._blockedTraits.indexOf(param1) != -1;
}
}
}
@@ -0,0 +1,41 @@
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;
import org.osmf.traits.MediaTraitType;
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(MediaTraitType.LOAD) as LoaderLoadTrait;
addTrait(MediaTraitType.DISPLAY_OBJECT,LoaderUtils.createDisplayObjectTrait(_loc1_.loader,this));
}
override protected function processUnloadingState() : void
{
removeTrait(MediaTraitType.DISPLAY_OBJECT);
}
}
}
@@ -0,0 +1,69 @@
package org.osmf.elements
{
import org.osmf.elements.loaderClasses.LoaderUtils;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.MediaType;
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>([MediaType.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_ != MediaTypeUtil.METADATA_MATCH_UNKNOWN)
{
return _loc2_ == MediaTypeUtil.METADATA_MATCH_FOUND;
}
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,this.useCurrentSecurityDomain,false,this.validateLoadedContentFunction);
}
override protected function executeUnload(param1:LoadTrait) : void
{
LoaderUtils.unloadLoadTrait(param1,updateLoadTrait);
}
public function get validateLoadedContentFunction() : Function
{
return allowValidationOfLoadedContent ? this._validateLoadedContentFunction : null;
}
public function set validateLoadedContentFunction(param1:Function) : void
{
this._validateLoadedContentFunction = param1;
}
}
}
@@ -0,0 +1,144 @@
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.MediaErrorCodes;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.MediaType;
import org.osmf.media.MediaTypeUtil;
import org.osmf.media.URLResource;
import org.osmf.traits.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.utils.*;
public class SoundLoader extends LoaderBase
{
private static const MIME_TYPES_SUPPORTED:Vector.<String> = Vector.<String>(["audio/mpeg"]);
private static const MEDIA_TYPES_SUPPORTED:Vector.<String> = Vector.<String>([MediaType.AUDIO]);
private static const MIN_BYTES_TO_RECEIVE:int = 16;
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_ != MediaTypeUtil.METADATA_MATCH_UNKNOWN)
{
return _loc2_ == MediaTypeUtil.METADATA_MATCH_FOUND;
}
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 urlRequest:URLRequest;
var context:SoundLoaderContext;
var soundLoadTrait:SoundLoadTrait = null;
var sound:Sound = null;
var onProgress:Function = null;
var onIOError:Function = null;
var loadTrait:LoadTrait = param1;
var toggleSoundListeners:Function = function(param1:Sound, param2:Boolean):void
{
if(param2)
{
param1.addEventListener(ProgressEvent.PROGRESS,onProgress);
param1.addEventListener(IOErrorEvent.IO_ERROR,onIOError);
}
else
{
param1.removeEventListener(ProgressEvent.PROGRESS,onProgress);
param1.removeEventListener(IOErrorEvent.IO_ERROR,onIOError);
}
};
onProgress = function(param1:ProgressEvent):void
{
if(param1.bytesTotal >= MIN_BYTES_TO_RECEIVE && soundLoadTrait.loadState == LoadState.LOADING)
{
toggleSoundListeners(sound,false);
soundLoadTrait.sound = sound;
updateLoadTrait(soundLoadTrait,LoadState.READY);
}
};
onIOError = function(param1:IOErrorEvent, param2:String = null):void
{
toggleSoundListeners(sound,false);
updateLoadTrait(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.IO_ERROR,param1 ? param1.text : param2)));
};
var handleSecurityError:Function = function(param1:String):void
{
toggleSoundListeners(sound,false);
updateLoadTrait(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.SECURITY_ERROR,param1)));
};
soundLoadTrait = loadTrait as SoundLoadTrait;
updateLoadTrait(soundLoadTrait,LoadState.LOADING);
sound = new Sound();
toggleSoundListeners(sound,true);
urlRequest = new URLRequest((soundLoadTrait.resource as URLResource).url.toString());
context = new SoundLoaderContext(1000,this.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_,LoadState.UNLOADING);
try
{
if(_loc2_.sound != null)
{
_loc2_.sound.close();
}
}
catch(error:IOError)
{
}
updateLoadTrait(_loc2_,LoadState.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,this.alternateLoaders);
super.resource = param1;
}
private function get alternateLoaders() : Vector.<LoaderBase>
{
if(this._alternateLoaders == null)
{
this._alternateLoaders = new Vector.<LoaderBase>();
this._alternateLoaders.push(new HTTPStreamingNetLoader());
this._alternateLoaders.push(new RTMPDynamicStreamingNetLoader());
this._alternateLoaders.push(new NetLoader());
}
return this._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 = this.soundAdapter.soundTransform;
_loc2_.volume = muted ? 0 : param1;
this.soundAdapter.soundTransform = _loc2_;
}
override protected function mutedChangeStart(param1:Boolean) : void
{
var _loc2_:SoundTransform = this.soundAdapter.soundTransform;
_loc2_.volume = param1 ? 0 : volume;
this.soundAdapter.soundTransform = _loc2_;
}
override protected function panChangeStart(param1:Number) : void
{
var _loc2_:SoundTransform = this.soundAdapter.soundTransform;
_loc2_.pan = param1;
this.soundAdapter.soundTransform = _loc2_;
}
}
}
@@ -0,0 +1,56 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import org.osmf.traits.PlayState;
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(Event.COMPLETE,this.onPlaybackComplete,false,1,true);
}
override protected function playStateChangeStart(param1:String) : void
{
if(param1 == PlayState.PLAYING)
{
this.lastPlayFailed = !this.soundAdapter.play();
}
else if(param1 == PlayState.PAUSED)
{
this.soundAdapter.pause();
}
else if(param1 == PlayState.STOPPED)
{
this.soundAdapter.stop();
}
}
override protected function playStateChangeEnd() : void
{
if(this.lastPlayFailed)
{
stop();
this.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)
{
this.soundAdapter.seek(param2);
}
}
override protected function seekingChangeEnd(param1:Number) : void
{
super.seekingChangeEnd(param1);
if(seeking == true)
{
setSeeking(false,param1);
}
}
}
}
@@ -0,0 +1,46 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import flash.events.ProgressEvent;
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(ProgressEvent.PROGRESS,this.onDownloadProgress,false,0,true);
param1.addEventListener(SoundAdapter.DOWNLOAD_COMPLETE,this.onDownloadComplete,false,0,true);
param1.addEventListener(Event.COMPLETE,this.onPlaybackComplete,false,0,true);
}
override public function get currentTime() : Number
{
return this.soundAdapter.currentTime;
}
private function onDownloadProgress(param1:Event) : void
{
if(!isNaN(this.soundAdapter.estimatedDuration) && this.soundAdapter.estimatedDuration > 0)
{
this.soundAdapter.removeEventListener(ProgressEvent.PROGRESS,this.onDownloadProgress);
setDuration(this.soundAdapter.estimatedDuration);
}
}
private function onDownloadComplete(param1:Event) : void
{
setDuration(this.soundAdapter.estimatedDuration);
}
private function onPlaybackComplete(param1:Event) : void
{
signalComplete();
}
}
}
@@ -0,0 +1,164 @@
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.MediaErrorCodes;
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;
this._soundTransform = new SoundTransform();
param2.addEventListener(Event.COMPLETE,this.onDownloadComplete,false,0,true);
param2.addEventListener(ProgressEvent.PROGRESS,this.onProgress,false,0,true);
param2.addEventListener(IOErrorEvent.IO_ERROR,this.onIOError,false,0,true);
}
public function get currentTime() : Number
{
return this.channel != null ? this.channel.position / 1000 : this.lastStartTime / 1000;
}
public function get estimatedDuration() : Number
{
return this.sound.length / (1000 * this.sound.bytesLoaded / this.sound.bytesTotal);
}
public function get soundTransform() : SoundTransform
{
return this._soundTransform;
}
public function set soundTransform(param1:SoundTransform) : void
{
this._soundTransform = param1;
if(this.channel != null)
{
this.channel.soundTransform = param1;
}
}
public function play(param1:Number = -1) : Boolean
{
var time:Number = param1;
var success:Boolean = false;
if(this.channel == null)
{
try
{
this.channel = this.sound.play(time != -1 ? time : this.lastStartTime);
}
catch(error:ArgumentError)
{
channel = null;
}
if(this.channel != null)
{
this.playing = true;
this.channel.soundTransform = this._soundTransform;
this.channel.addEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
success = true;
}
else
{
this.owner.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.SOUND_PLAY_FAILED)));
}
}
return success;
}
public function pause() : void
{
if(this.channel != null)
{
this.lastStartTime = this.channel.position;
this.clearChannel();
this.playing = false;
}
}
public function stop() : void
{
if(this.channel != null)
{
this.lastStartTime = 0;
this.clearChannel();
this.playing = false;
}
}
public function seek(param1:Number) : void
{
var _loc2_:Boolean = this.playing;
if(this.channel != null)
{
this.clearChannel();
}
this.play(param1 * 1000);
if(_loc2_ == false)
{
this.pause();
}
}
private function clearChannel() : void
{
if(this.channel != null)
{
this.channel.removeEventListener(Event.SOUND_COMPLETE,this.onSoundComplete);
this.channel.stop();
this.channel = null;
}
}
private function onSoundComplete(param1:Event) : void
{
this.lastStartTime = this.channel.position;
this.clearChannel();
this.playing = false;
dispatchEvent(new Event(Event.COMPLETE));
}
private function onDownloadComplete(param1:Event) : void
{
dispatchEvent(new Event(DOWNLOAD_COMPLETE));
}
private function onProgress(param1:ProgressEvent) : void
{
dispatchEvent(param1.clone());
}
private function onIOError(param1:IOErrorEvent) : void
{
this.owner.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.IO_ERROR)));
}
}
}
@@ -0,0 +1,72 @@
package org.osmf.elements.audioClasses
{
import flash.events.Event;
import flash.events.ProgressEvent;
import flash.media.Sound;
import org.osmf.events.LoadEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadState;
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 this._sound;
}
public function set sound(param1:Sound) : void
{
this._sound = param1;
}
override protected function loadStateChangeStart(param1:String) : void
{
if(param1 == LoadState.READY)
{
if(this._sound != null)
{
this._sound.addEventListener(Event.OPEN,this.bytesTotalCheckingHandler,false,0,true);
this._sound.addEventListener(ProgressEvent.PROGRESS,this.bytesTotalCheckingHandler,false,0,true);
}
}
else if(param1 == LoadState.UNINITIALIZED)
{
this._sound = null;
}
}
override public function get bytesLoaded() : Number
{
return this._sound ? this._sound.bytesLoaded : NaN;
}
override public function get bytesTotal() : Number
{
return this._sound ? this._sound.bytesTotal : NaN;
}
private function bytesTotalCheckingHandler(param1:Event) : void
{
var _loc2_:LoadEvent = null;
if(this.lastBytesTotal != this._sound.bytesTotal)
{
_loc2_ = new LoadEvent(LoadEvent.BYTES_TOTAL_CHANGE,false,false,null,this._sound.bytesTotal);
this.lastBytesTotal = this._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();
this.data = new ByteArray();
}
private static function copyByteArray(param1:ByteArray, param2:ByteArray, param3:uint = 0) : void
{
var _loc4_:int = int(param1.position);
param1.position = 0;
param2.position = 0;
var _loc5_:uint = 0;
while(param1.bytesAvailable > 0 && _loc5_ < param3)
{
param2.writeByte(param1.readByte());
_loc5_++;
}
param1.position = _loc4_;
param2.position = 0;
}
public function decode(param1:String) : void
{
var _loc3_:Number = NaN;
var _loc2_:uint = 0;
for(; _loc2_ < param1.length; _loc2_++)
{
_loc3_ = param1.charCodeAt(_loc2_);
if(_loc3_ == ESCAPE_CHAR_CODE)
{
var _loc4_:Number;
this.work[_loc4_ = this.count++] = -1;
}
else
{
if(inverse[_loc3_] == 64)
{
continue;
}
this.work[_loc4_ = this.count++] = inverse[_loc3_];
}
if(this.count == 4)
{
this.count = 0;
this.data.writeByte(this.work[0] << 2 | (this.work[1] & 0xFF) >> 4);
++this.filled;
if(this.work[2] == -1)
{
break;
}
this.data.writeByte(this.work[1] << 4 | (this.work[2] & 0xFF) >> 2);
++this.filled;
if(this.work[3] == -1)
{
break;
}
this.data.writeByte(this.work[2] << 6 | this.work[3]);
++this.filled;
}
}
}
public function drain() : ByteArray
{
var _loc1_:ByteArray = new ByteArray();
copyByteArray(this.data,_loc1_,this.filled);
this.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,89 @@
package org.osmf.elements.f4mClasses
{
internal class DateUtil
{
public function DateUtil()
{
super();
}
public static function parseW3CDTF(param1:String) : Date
{
var finalDate:Date = null;
var dateStr:String = null;
var timeStr:String = null;
var dateArr:Array = null;
var year:Number = NaN;
var month:Number = NaN;
var date:Number = NaN;
var multiplier:Number = NaN;
var offsetHours:Number = NaN;
var offsetMinutes:Number = NaN;
var offsetStr:String = null;
var timeArr:Array = null;
var hour:Number = NaN;
var minutes:Number = NaN;
var secondsArr:Array = null;
var seconds:Number = NaN;
var milliseconds:Number = NaN;
var utc:Number = NaN;
var offset:Number = NaN;
var eStr:String = null;
var str:String = param1;
try
{
dateStr = str.substring(0,str.indexOf("T"));
timeStr = str.substring(str.indexOf("T") + 1,str.length);
dateArr = dateStr.split("-");
year = Number(dateArr.shift());
month = Number(dateArr.shift());
date = Number(dateArr.shift());
if(timeStr.indexOf("Z") != -1)
{
multiplier = 1;
offsetHours = 0;
offsetMinutes = 0;
timeStr = timeStr.replace("Z","");
}
else if(timeStr.indexOf("+") != -1)
{
multiplier = 1;
offsetStr = timeStr.substring(timeStr.indexOf("+") + 1,timeStr.length);
offsetHours = Number(offsetStr.substring(0,offsetStr.indexOf(":")));
offsetMinutes = Number(offsetStr.substring(offsetStr.indexOf(":") + 1,offsetStr.length));
timeStr = timeStr.substring(0,timeStr.indexOf("+"));
}
else
{
multiplier = -1;
offsetStr = timeStr.substring(timeStr.indexOf("-") + 1,timeStr.length);
offsetHours = Number(offsetStr.substring(0,offsetStr.indexOf(":")));
offsetMinutes = Number(offsetStr.substring(offsetStr.indexOf(":") + 1,offsetStr.length));
timeStr = timeStr.substring(0,timeStr.indexOf("-"));
}
timeArr = timeStr.split(":");
hour = Number(timeArr.shift());
minutes = Number(timeArr.shift());
secondsArr = timeArr.length > 0 ? String(timeArr.shift()).split(".") : null;
seconds = secondsArr != null && secondsArr.length > 0 ? Number(secondsArr.shift()) : 0;
milliseconds = secondsArr != null && secondsArr.length > 0 ? Number(secondsArr.shift()) : 0;
utc = Date.UTC(year,month - 1,date,hour,minutes,seconds,milliseconds);
offset = (offsetHours * 3600000 + offsetMinutes * 60000) * multiplier;
finalDate = new Date(utc - offset);
if(finalDate.toString() == "Invalid Date")
{
throw new Error("This date does not conform to W3CDTF.");
}
}
catch(e:Error)
{
eStr = "Unable to parse the string [" + str + "] into a date. ";
eStr += "The internal error was: " + e.toString();
throw new Error(eStr);
}
return finalDate;
}
}
}
@@ -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,597 @@
package org.osmf.elements.f4mClasses
{
import flash.utils.ByteArray;
import org.osmf.media.MediaResourceBase;
import org.osmf.media.MediaType;
import org.osmf.media.URLResource;
import org.osmf.metadata.Metadata;
import org.osmf.metadata.MetadataNamespaces;
import org.osmf.net.DynamicStreamingItem;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.MulticastResource;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.StreamType;
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
{
internal namespace xmlns = "http://ns.adobe.com/f4m/1.0";
public function ManifestParser()
{
super();
}
public function parse(param1:String, param2:String = null) : Manifest
{
var _loc7_:XML = null;
var _loc8_:Boolean = false;
var _loc9_:Boolean = false;
var _loc10_:XML = null;
var _loc11_:XML = null;
var _loc12_:XML = null;
var _loc13_:Media = null;
var _loc3_:Manifest = new Manifest();
var _loc4_:Boolean = false;
var _loc5_:XML = new XML(param1);
if(_loc5_.id.length() > 0)
{
_loc3_.id = _loc5_.id.text();
}
if(_loc5_.duration.length() > 0)
{
_loc3_.duration = _loc5_.duration.text();
}
if(_loc5_.startTime.length() > 0)
{
_loc3_.startTime = DateUtil.parseW3CDTF(_loc5_.startTime.text());
}
if(_loc5_.mimeType.length() > 0)
{
_loc3_.mimeType = _loc5_.mimeType.text();
}
if(_loc5_.streamType.length() > 0)
{
_loc3_.streamType = _loc5_.streamType.text();
}
if(_loc5_.deliveryType.length() > 0)
{
_loc3_.deliveryType = _loc5_.deliveryType.text();
}
if(_loc5_.baseURL.length() > 0)
{
_loc3_.baseURL = _loc5_.baseURL.text();
}
if(_loc5_.urlIncludesFMSApplicationInstance.length() > 0)
{
_loc3_.urlIncludesFMSApplicationInstance = _loc5_.urlIncludesFMSApplicationInstance.text() == "true";
}
var _loc6_:String = _loc3_.baseURL != null ? _loc3_.baseURL : param2;
var _loc14_:int = 0;
var _loc15_:* = _loc5_.dvrInfo;
for each(_loc7_ in _loc15_)
{
this.parseDVRInfo(_loc7_,_loc6_,_loc3_);
}
_loc8_ = false;
_loc9_ = false;
for each(_loc10_ in _loc5_.media)
{
_loc13_ = this.parseMedia(_loc10_,_loc6_);
if(_loc13_.multicastGroupspec != null && _loc13_.multicastGroupspec.length > 0 && (_loc13_.multicastStreamName == null || _loc13_.multicastStreamName.length <= 0) || _loc13_.multicastStreamName != null && _loc13_.multicastStreamName.length > 0 && (_loc13_.multicastGroupspec == null || _loc13_.multicastGroupspec.length <= 0))
{
_loc9_ = true;
}
if(_loc13_.multicastGroupspec != null && _loc13_.multicastGroupspec.length > 0)
{
_loc4_ = true;
}
_loc3_.media.push(_loc13_);
_loc8_ ||= isNaN(_loc13_.bitrate);
}
if(_loc9_)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.MULTICAST_PARAMETER_INVALID));
}
if(_loc3_.media.length > 1 && _loc4_)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.MULTICAST_NOT_SUPPORT_MBR));
}
if(_loc4_)
{
_loc3_.streamType = StreamType.LIVE;
}
if(_loc3_.media.length > 1 && _loc8_)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.F4M_PARSE_BITRATE_MISSING));
}
for each(_loc11_ in _loc5_.drmAdditionalHeader)
{
this.parseDRMAdditionalHeader(_loc11_,_loc3_.media,_loc6_,_loc3_);
}
for each(_loc12_ in _loc5_.bootstrapInfo)
{
this.parseBootstrapInfo(_loc12_,_loc3_.media,_loc6_,_loc3_);
}
this.generateRTMPBaseURL(_loc3_);
return _loc3_;
}
private function parseMedia(param1:XML, param2:String) : Media
{
var _loc3_:Base64Decoder = null;
var _loc5_:ByteArray = null;
var _loc6_:String = null;
var _loc7_:Object = null;
var _loc4_:Media = new Media();
if(param1.attribute("url").length() > 0)
{
_loc4_.url = param1.@url;
if(param1.attribute("bitrate").length() > 0)
{
_loc4_.bitrate = param1.@bitrate;
}
if(param1.attribute("drmAdditionalHeaderId").length() > 0)
{
_loc4_.drmAdditionalHeader.id = param1.@drmAdditionalHeaderId;
}
if(param1.attribute("bootstrapInfoId").length() > 0)
{
_loc4_.bootstrapInfo = new BootstrapInfo();
_loc4_.bootstrapInfo.id = param1.@bootstrapInfoId;
}
if(param1.attribute("height").length() > 0)
{
_loc4_.height = param1.@height;
}
if(param1.attribute("width").length() > 0)
{
_loc4_.width = param1.@width;
}
if(param1.attribute("groupspec").length() > 0)
{
_loc4_.multicastGroupspec = param1.@groupspec;
}
if(param1.attribute("multicastStreamName").length() > 0)
{
_loc4_.multicastStreamName = param1.@multicastStreamName;
}
if(param1.moov.length() > 0)
{
_loc3_ = new Base64Decoder();
_loc3_.decode(param1.moov.text());
_loc4_.moov = _loc3_.drain();
}
if(param1.metadata.length() > 0)
{
_loc3_ = new Base64Decoder();
_loc3_.decode(param1.metadata.text());
_loc5_ = _loc3_.drain();
_loc5_.position = 0;
_loc5_.objectEncoding = 0;
try
{
_loc6_ = _loc5_.readObject() as String;
_loc7_ = _loc5_.readObject();
_loc4_.metadata = _loc7_;
}
catch(e:Error)
{
}
}
if(param1.xmpMetadata.length() > 0)
{
_loc3_ = new Base64Decoder();
_loc3_.decode(param1.xmpMetadata.text());
_loc4_.xmp = _loc3_.drain();
}
return _loc4_;
}
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.F4M_PARSE_MEDIA_URL_MISSING));
}
private function parseDVRInfo(param1:XML, param2:String, param3:Manifest) : void
{
var _loc5_:String = null;
var _loc6_:Number = NaN;
var _loc7_:String = null;
var _loc4_:DVRInfo = new DVRInfo();
if(param1.attribute("id").length() > 0)
{
_loc4_.id = param1.@id;
}
if(param1.attribute("url").length() > 0)
{
_loc5_ = param1.@url;
if(!this.isAbsoluteURL(_loc5_))
{
_loc5_ = param2 + "/" + _loc5_;
}
_loc4_.url = _loc5_;
}
if(param1.attribute("beginOffset").length() > 0)
{
_loc4_.beginOffset = Math.max(0,parseInt(param1.@beginOffset));
}
if(param1.attribute("endOffset").length() > 0)
{
_loc6_ = new Number(param1.@endOffset);
if(_loc6_ > 0 && _loc6_ < 1)
{
_loc4_.endOffset = 1;
}
else
{
_loc4_.endOffset = Math.max(0,_loc6_);
}
}
if(param1.attribute("offline").length() > 0)
{
_loc7_ = param1.@offline;
_loc4_.offline = _loc7_.toLowerCase() == "true";
}
param3.dvrInfo = _loc4_;
}
private function parseDRMAdditionalHeader(param1:XML, param2:Vector.<Media>, param3:String, param4:Manifest) : void
{
var _loc6_:Media = null;
var _loc8_:String = null;
var _loc9_:Base64Decoder = null;
var _loc5_:String = null;
var _loc7_:DRMAdditionalHeader = new DRMAdditionalHeader();
if(param1.attribute("id").length() > 0)
{
_loc7_.id = param1.@id;
}
if(param1.attribute("url").length() > 0)
{
_loc5_ = param1.@url;
if(!this.isAbsoluteURL(_loc5_))
{
_loc5_ = param3 + "/" + _loc5_;
}
_loc7_.url = _loc5_;
}
else
{
_loc8_ = param1.text();
_loc9_ = new Base64Decoder();
_loc9_.decode(_loc8_);
_loc7_.data = _loc9_.drain();
}
param4.drmAdditionalHeaders.push(_loc7_);
for each(_loc6_ in param2)
{
if(_loc6_.drmAdditionalHeader.id == _loc7_.id)
{
_loc6_.drmAdditionalHeader = _loc7_;
}
}
}
private function parseBootstrapInfo(param1:XML, param2:Vector.<Media>, param3:String, param4:Manifest) : void
{
var _loc5_:Media = null;
var _loc8_:String = null;
var _loc9_:Base64Decoder = null;
var _loc6_:String = null;
var _loc7_:BootstrapInfo = new BootstrapInfo();
if(param1.attribute("profile").length() > 0)
{
_loc7_.profile = param1.@profile;
if(param1.attribute("id").length() > 0)
{
_loc7_.id = param1.@id;
}
if(param1.attribute("url").length() > 0)
{
_loc6_ = param1.@url;
if(!this.isAbsoluteURL(_loc6_) && param3 != null)
{
_loc6_ = param3 + "/" + _loc6_;
}
_loc7_.url = _loc6_;
}
else
{
_loc8_ = param1.text();
_loc9_ = new Base64Decoder();
_loc9_.decode(_loc8_);
_loc7_.data = _loc9_.drain();
}
for each(_loc5_ in param2)
{
if(_loc5_.bootstrapInfo == null)
{
_loc5_.bootstrapInfo = _loc7_;
}
else if(_loc5_.bootstrapInfo.id == _loc7_.id)
{
_loc5_.bootstrapInfo = _loc7_;
}
}
return;
}
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.F4M_PARSE_PROFILE_MISSING));
}
private function generateRTMPBaseURL(param1:Manifest) : void
{
var _loc2_:Media = null;
if(param1.baseURL == null)
{
for each(_loc2_ in param1.media)
{
if(NetStreamUtils.isRTMPStream(_loc2_.url))
{
param1.baseURL = _loc2_.url;
break;
}
}
}
}
public function createResource(param1:Manifest, param2:URLResource) : MediaResourceBase
{
var _loc5_:StreamingURLResource = null;
var _loc6_:Media = null;
var _loc7_:Vector.<String> = null;
var _loc8_:String = null;
var _loc9_:String = null;
var _loc14_:String = null;
var _loc15_:String = null;
var _loc16_:DynamicStreamingResource = null;
var _loc17_:Vector.<DynamicStreamingItem> = null;
var _loc18_:String = null;
var _loc19_:DynamicStreamingItem = null;
var _loc3_:Metadata = null;
var _loc4_:Metadata = null;
var _loc10_:URL = new URL(param2.url);
var _loc11_:String = "/" + _loc10_.path;
_loc11_ = _loc11_.substr(0,_loc11_.lastIndexOf("/"));
var _loc12_:String = _loc10_.protocol + "://" + _loc10_.host + (_loc10_.port != "" ? ":" + _loc10_.port : "") + _loc11_;
if(param1.media.length == 1)
{
_loc6_ = param1.media[0] as Media;
_loc8_ = _loc6_.url;
_loc14_ = null;
if(this.isAbsoluteURL(_loc8_))
{
_loc14_ = _loc6_.url.substr(0,_loc6_.url.lastIndexOf("/"));
}
else if(param1.baseURL != null)
{
_loc14_ = param1.baseURL;
}
else
{
_loc14_ = _loc12_;
}
if(_loc6_.multicastGroupspec != null && _loc6_.multicastGroupspec.length > 0 && _loc6_.multicastStreamName != null && _loc6_.multicastStreamName.length > 0)
{
if(this.isAbsoluteURL(_loc8_))
{
_loc5_ = new MulticastResource(_loc8_,param1.streamType);
}
else if(param1.baseURL != null)
{
_loc5_ = new MulticastResource(param1.baseURL + "/" + _loc8_,this.streamType(param1));
}
else
{
_loc5_ = new MulticastResource(_loc12_ + "/" + _loc8_,this.streamType(param1));
}
MulticastResource(_loc5_).groupspec = _loc6_.multicastGroupspec;
MulticastResource(_loc5_).streamName = _loc6_.multicastStreamName;
}
else if(this.isAbsoluteURL(_loc8_))
{
_loc5_ = new StreamingURLResource(_loc8_,param1.streamType);
}
else if(param1.baseURL != null)
{
_loc5_ = new StreamingURLResource(param1.baseURL + "/" + _loc8_,this.streamType(param1));
}
else
{
_loc5_ = new StreamingURLResource(_loc12_ + "/" + _loc8_,this.streamType(param1));
}
_loc5_.urlIncludesFMSApplicationInstance = param1.urlIncludesFMSApplicationInstance;
if(_loc6_.bootstrapInfo != null)
{
_loc7_ = new Vector.<String>();
_loc7_.push(_loc14_);
_loc9_ = _loc6_.bootstrapInfo.url;
if(_loc6_.bootstrapInfo.url != null && this.isAbsoluteURL(_loc6_.bootstrapInfo.url) == false)
{
_loc9_ = _loc12_ + "/" + _loc9_;
_loc6_.bootstrapInfo.url = _loc9_;
}
_loc4_ = new Metadata();
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_BOOTSTRAP_KEY,_loc6_.bootstrapInfo);
if(_loc7_.length > 0)
{
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_SERVER_BASE_URLS_KEY,_loc7_);
}
}
if(_loc6_.metadata != null)
{
if(_loc4_ == null)
{
_loc4_ = new Metadata();
}
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_STREAM_METADATA_KEY,_loc6_.metadata);
}
if(_loc6_.xmp != null)
{
if(_loc4_ == null)
{
_loc4_ = new Metadata();
}
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_XMP_METADATA_KEY,_loc6_.xmp);
}
if(_loc6_.drmAdditionalHeader != null)
{
_loc3_ = new Metadata();
if(Media(param1.media[0]).drmAdditionalHeader != null && Media(param1.media[0]).drmAdditionalHeader.data != null)
{
_loc3_.addValue(MetadataNamespaces.DRM_ADDITIONAL_HEADER_KEY,Media(param1.media[0]).drmAdditionalHeader.data);
_loc5_.drmContentData = this.extractDRMMetadata(Media(param1.media[0]).drmAdditionalHeader.data);
}
}
if(_loc4_ != null)
{
_loc5_.addMetadataValue(MetadataNamespaces.HTTP_STREAMING_METADATA,_loc4_);
}
if(_loc3_ != null)
{
_loc5_.addMetadataValue(MetadataNamespaces.DRM_METADATA,_loc3_);
}
}
else if(param1.media.length > 1)
{
_loc15_ = param1.baseURL != null ? param1.baseURL : _loc12_;
_loc7_ = new Vector.<String>();
_loc7_.push(_loc15_);
_loc16_ = new DynamicStreamingResource(_loc15_,this.streamType(param1));
_loc16_.urlIncludesFMSApplicationInstance = param1.urlIncludesFMSApplicationInstance;
_loc17_ = new Vector.<DynamicStreamingItem>();
if(NetStreamUtils.isRTMPStream(_loc15_) == false)
{
_loc4_ = new Metadata();
_loc16_.addMetadataValue(MetadataNamespaces.HTTP_STREAMING_METADATA,_loc4_);
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_SERVER_BASE_URLS_KEY,_loc7_);
}
for each(_loc6_ in param1.media)
{
if(this.isAbsoluteURL(_loc6_.url))
{
_loc18_ = NetStreamUtils.getStreamNameFromURL(_loc6_.url);
}
else
{
_loc18_ = _loc6_.url;
}
_loc19_ = new DynamicStreamingItem(_loc18_,_loc6_.bitrate,_loc6_.width,_loc6_.height);
_loc17_.push(_loc19_);
if(_loc6_.drmAdditionalHeader != null)
{
if(_loc16_.getMetadataValue(MetadataNamespaces.DRM_METADATA) == null)
{
_loc3_ = new Metadata();
_loc16_.addMetadataValue(MetadataNamespaces.DRM_METADATA,_loc3_);
}
if(_loc6_.drmAdditionalHeader != null && _loc6_.drmAdditionalHeader.data != null)
{
_loc3_.addValue(_loc19_.streamName,this.extractDRMMetadata(_loc6_.drmAdditionalHeader.data));
_loc3_.addValue(MetadataNamespaces.DRM_ADDITIONAL_HEADER_KEY + _loc19_.streamName,_loc6_.drmAdditionalHeader.data);
}
}
if(_loc6_.bootstrapInfo != null)
{
_loc9_ = _loc6_.bootstrapInfo.url ? _loc6_.bootstrapInfo.url : null;
if(_loc6_.bootstrapInfo.url != null && this.isAbsoluteURL(_loc6_.bootstrapInfo.url) == false)
{
_loc9_ = _loc12_ + "/" + _loc9_;
_loc6_.bootstrapInfo.url = _loc9_;
}
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_BOOTSTRAP_KEY + _loc19_.streamName,_loc6_.bootstrapInfo);
}
if(_loc6_.metadata != null)
{
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_STREAM_METADATA_KEY + _loc19_.streamName,_loc6_.metadata);
}
if(_loc6_.xmp != null)
{
_loc4_.addValue(MetadataNamespaces.HTTP_STREAMING_XMP_METADATA_KEY + _loc19_.streamName,_loc6_.xmp);
}
}
_loc16_.streamItems = _loc17_;
_loc5_ = _loc16_;
}
else if(param1.baseURL == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.F4M_PARSE_MEDIA_URL_MISSING));
}
if(param1.mimeType != null)
{
_loc5_.mediaType = MediaType.VIDEO;
_loc5_.mimeType = param1.mimeType;
}
var _loc13_:StreamingURLResource = param2 as StreamingURLResource;
if(_loc13_ != null)
{
_loc5_.clipStartTime = _loc13_.clipStartTime;
_loc5_.clipEndTime = _loc13_.clipEndTime;
}
_loc5_.addMetadataValue(MetadataNamespaces.DERIVED_RESOURCE_METADATA,param2);
this.addDVRInfo(param1,_loc5_);
return _loc5_;
}
private function isAbsoluteURL(param1:String) : Boolean
{
var _loc2_:URL = new URL(param1);
return _loc2_.absolute;
}
private function extractDRMMetadata(param1:ByteArray) : ByteArray
{
var header:Object = null;
var encryption:Object = null;
var enc:Object = null;
var params:Object = null;
var keyInfo:Object = null;
var fmrmsMetadata:Object = null;
var drmMetadata:String = null;
var decoder:Base64Decoder = null;
var data:ByteArray = param1;
var metadata:ByteArray = null;
data.position = 0;
data.objectEncoding = 0;
try
{
header = data.readObject();
encryption = data.readObject();
enc = encryption["Encryption"];
params = enc["Params"];
keyInfo = params["KeyInfo"];
fmrmsMetadata = keyInfo["FMRMS_METADATA"];
drmMetadata = fmrmsMetadata["Metadata"] as String;
decoder = new Base64Decoder();
decoder.decode(drmMetadata);
metadata = decoder.drain();
}
catch(e:Error)
{
metadata = null;
}
return metadata;
}
private function addDVRInfo(param1:Manifest, param2:StreamingURLResource) : void
{
if(param1.dvrInfo == null)
{
return;
}
var _loc3_:Metadata = new Metadata();
_loc3_.addValue(MetadataNamespaces.HTTP_STREAMING_DVR_BEGIN_OFFSET_KEY,param1.dvrInfo.beginOffset);
_loc3_.addValue(MetadataNamespaces.HTTP_STREAMING_DVR_END_OFFSET_KEY,param1.dvrInfo.endOffset);
_loc3_.addValue(MetadataNamespaces.HTTP_STREAMING_DVR_OFFLINE_KEY,param1.dvrInfo.offline);
_loc3_.addValue(MetadataNamespaces.HTTP_STREAMING_DVR_ID_KEY,param1.dvrInfo.id);
param2.addMetadataValue(MetadataNamespaces.DVR_METADATA,_loc3_);
}
private function streamType(param1:Manifest) : String
{
return param1.streamType == StreamType.LIVE && param1.dvrInfo != null ? StreamType.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,55 @@
package org.osmf.elements.loaderClasses
{
import flash.display.Loader;
import flash.events.ProgressEvent;
import org.osmf.media.MediaResourceBase;
import org.osmf.traits.LoadState;
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 this._loader;
}
public function set loader(param1:Loader) : void
{
this._loader = param1;
}
override protected function loadStateChangeStart(param1:String) : void
{
if(param1 == LoadState.LOADING)
{
this.loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onContentLoadProgress,false,0,true);
}
else if(param1 == LoadState.READY)
{
setBytesTotal(this.loader.contentLoaderInfo.bytesTotal);
setBytesLoaded(this.loader.contentLoaderInfo.bytesLoaded);
this.loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,this.onContentLoadProgress,false,0,true);
}
else if(param1 == LoadState.UNINITIALIZED)
{
setBytesLoaded(0);
}
}
private function onContentLoadProgress(param1:ProgressEvent) : void
{
setBytesTotal(param1.bytesTotal);
setBytesLoaded(param1.bytesLoaded);
}
}
}
@@ -0,0 +1,180 @@
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.MediaErrorCodes;
import org.osmf.events.MediaErrorEvent;
import org.osmf.media.MediaElement;
import org.osmf.media.URLResource;
import org.osmf.traits.DisplayObjectTrait;
import org.osmf.traits.LoadState;
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 _loc4_:Number = 0;
var _loc5_:Number = 0;
var _loc6_:LoaderInfo = param1.contentLoaderInfo;
_loc3_ = param1;
_loc3_.scrollRect = new Rectangle(0,0,_loc6_.width,_loc6_.height);
_loc4_ = _loc6_.width;
_loc5_ = _loc6_.height;
return new DisplayObjectTrait(_loc3_,_loc4_,_loc5_);
}
public static function loadLoadTrait(param1:LoadTrait, param2:Function, param3:Boolean, param4:Boolean, param5:Function = null) : void
{
var context:LoaderContext;
var urlReq:URLRequest;
var loader:Loader = null;
var onLoadComplete:Function = null;
var onIOError:Function = null;
var onSecurityError:Function = null;
var loadTrait:LoadTrait = param1;
var updateLoadTraitFunction:Function = param2;
var useCurrentSecurityDomain:Boolean = param3;
var checkPolicyFile:Boolean = param4;
var validateLoadedContentFunction:Function = param5;
var toggleLoaderListeners:Function = function(param1:Loader, param2:Boolean):void
{
if(param2)
{
param1.contentLoaderInfo.addEventListener(Event.COMPLETE,onLoadComplete);
param1.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,onIOError);
param1.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,onSecurityError);
}
else
{
param1.contentLoaderInfo.removeEventListener(Event.COMPLETE,onLoadComplete);
param1.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,onIOError);
param1.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,onSecurityError);
}
};
onLoadComplete = function(param1:Event):void
{
var validated:Boolean = false;
var timer:Timer = null;
var onTimer:Function = null;
var event:Event = param1;
toggleLoaderListeners(loader,false);
if(loadTrait.loadState == LoadState.LOADING)
{
if(validateLoadedContentFunction != null)
{
validated = Boolean(validateLoadedContentFunction(loader.content));
if(validated)
{
if(Capabilities.isDebugger)
{
onTimer = function(param1:TimerEvent):void
{
timer.removeEventListener(TimerEvent.TIMER_COMPLETE,onTimer);
timer = null;
loader.unloadAndStop();
loader = null;
loadLoadTrait(loadTrait,updateLoadTraitFunction,useCurrentSecurityDomain,false,null);
};
timer = new Timer(250,1);
timer.addEventListener(TimerEvent.TIMER_COMPLETE,onTimer);
timer.start();
}
else
{
loader.unloadAndStop();
loader = null;
loadLoadTrait(loadTrait,updateLoadTraitFunction,useCurrentSecurityDomain,false,null);
}
}
else
{
loader.unloadAndStop();
loader = null;
updateLoadTraitFunction(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.IO_ERROR)));
}
}
else
{
updateLoadTraitFunction(loadTrait,LoadState.READY);
}
}
};
onIOError = function(param1:IOErrorEvent, param2:String = null):void
{
toggleLoaderListeners(loader,false);
loader = null;
updateLoadTraitFunction(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.IO_ERROR,param1 ? param1.text : param2)));
};
onSecurityError = function(param1:SecurityErrorEvent, param2:String = null):void
{
toggleLoaderListeners(loader,false);
loader = null;
updateLoadTraitFunction(loadTrait,LoadState.LOAD_ERROR);
loadTrait.dispatchEvent(new MediaErrorEvent(MediaErrorEvent.MEDIA_ERROR,false,false,new MediaError(MediaErrorCodes.SECURITY_ERROR,param1 ? param1.text : param2)));
};
var loaderLoadTrait:LoaderLoadTrait = loadTrait as LoaderLoadTrait;
loader = new Loader();
loaderLoadTrait.loader = loader;
updateLoadTraitFunction(loadTrait,LoadState.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,LoadState.UNLOADING);
_loc3_.loader.unloadAndStop();
param2(param1,LoadState.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(LoadEvent.LOAD_STATE_CHANGE,false,false,loadState));
}
public function set mediaElement(param1:MediaElement) : void
{
this._mediaElement = param1;
}
public function get mediaElement() : MediaElement
{
return this._mediaElement;
}
}
}
@@ -0,0 +1,63 @@
package org.osmf.elements.proxyClasses
{
import flash.events.Event;
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.Metadata;
public class ProxyMetadata extends Metadata
{
private var proxiedMetadata:Metadata;
public function ProxyMetadata()
{
super();
this.proxiedMetadata = new Metadata();
this.proxiedMetadata.addEventListener(MetadataEvent.VALUE_ADD,this.redispatchEvent);
this.proxiedMetadata.addEventListener(MetadataEvent.VALUE_CHANGE,this.redispatchEvent);
this.proxiedMetadata.addEventListener(MetadataEvent.VALUE_REMOVE,this.redispatchEvent);
}
public function set metadata(param1:Metadata) : void
{
var _loc2_:String = null;
this.proxiedMetadata.removeEventListener(MetadataEvent.VALUE_ADD,this.redispatchEvent);
this.proxiedMetadata.removeEventListener(MetadataEvent.VALUE_CHANGE,this.redispatchEvent);
this.proxiedMetadata.removeEventListener(MetadataEvent.VALUE_REMOVE,this.redispatchEvent);
for each(_loc2_ in this.proxiedMetadata.keys)
{
param1.addValue(_loc2_,this.proxiedMetadata.getValue(_loc2_));
}
this.proxiedMetadata = param1;
this.proxiedMetadata.addEventListener(MetadataEvent.VALUE_ADD,this.redispatchEvent);
this.proxiedMetadata.addEventListener(MetadataEvent.VALUE_CHANGE,this.redispatchEvent);
this.proxiedMetadata.addEventListener(MetadataEvent.VALUE_REMOVE,this.redispatchEvent);
}
override public function getValue(param1:String) : *
{
return this.proxiedMetadata.getValue(param1);
}
override public function addValue(param1:String, param2:Object) : void
{
this.proxiedMetadata.addValue(param1,param2);
}
override public function removeValue(param1:String) : *
{
return this.proxiedMetadata.removeValue(param1);
}
override public function get keys() : Vector.<String>
{
return this.proxiedMetadata.keys;
}
private function redispatchEvent(param1:Event) : void
{
dispatchEvent(param1.clone());
}
}
}
@@ -0,0 +1,49 @@
package org.osmf.events
{
import flash.events.Event;
public class AudioEvent extends Event
{
public static const VOLUME_CHANGE:String = "volumeChange";
public static const MUTED_CHANGE:String = "mutedChange";
public static const PAN_CHANGE:String = "panChange";
private var _muted:Boolean;
private var _volume:Number;
private var _pan:Number;
public function AudioEvent(param1:String, param2:Boolean, param3:Boolean, param4:Boolean = false, param5:Number = NaN, param6:Number = NaN)
{
super(param1,param2,param3);
this._muted = param4;
this._volume = param5;
this._pan = param6;
}
public function get muted() : Boolean
{
return this._muted;
}
public function get volume() : Number
{
return this._volume;
}
public function get pan() : Number
{
return this._pan;
}
override public function clone() : Event
{
return new AudioEvent(type,bubbles,cancelable,this._muted,this._volume,this._pan);
}
}
}
@@ -0,0 +1,49 @@
package org.osmf.events
{
import flash.events.Event;
public class BufferEvent extends Event
{
public static const BUFFERING_CHANGE:String = "bufferingChange";
public static const BUFFER_TIME_CHANGE:String = "bufferTimeChange";
public static const BUFFER_LENGTH_CHANGE:String = "bufferLengthChange";
private var _buffering:Boolean;
private var _bufferTime:Number;
private var _bufferLength:Number;
public function BufferEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Number = NaN, param6:Number = NaN)
{
super(param1,param2,param3);
this._buffering = param4;
this._bufferTime = param5;
this._bufferLength = param6;
}
public function get buffering() : Boolean
{
return this._buffering;
}
public function get bufferTime() : Number
{
return this._bufferTime;
}
public function get bufferLength() : Number
{
return this._bufferLength;
}
override public function clone() : Event
{
return new BufferEvent(type,bubbles,cancelable,this._buffering,this._bufferTime,this._bufferLength);
}
}
}
@@ -0,0 +1,38 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.containers.IMediaContainer;
public class ContainerChangeEvent extends Event
{
public static const CONTAINER_CHANGE:String = "containerChange";
private var _oldContainer:IMediaContainer;
private var _newContainer:IMediaContainer;
public function ContainerChangeEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:IMediaContainer = null, param5:IMediaContainer = null)
{
super(param1,param2,param3);
this._oldContainer = param4;
this._newContainer = param5;
}
public function get oldContainer() : IMediaContainer
{
return this._oldContainer;
}
public function get newContainer() : IMediaContainer
{
return this._newContainer;
}
override public function clone() : Event
{
return new ContainerChangeEvent(type,bubbles,cancelable,this._oldContainer,this._newContainer);
}
}
}
@@ -0,0 +1,77 @@
package org.osmf.events
{
import flash.events.Event;
public class DRMEvent extends Event
{
public static const DRM_STATE_CHANGE:String = "drmStateChange";
private var _drmState:String;
private var _startDate:Date;
private var _endDate:Date;
private var _period:Number;
private var _serverURL:String;
private var _token:Object;
private var _mediaError:MediaError;
public function DRMEvent(param1:String, param2:String, param3:Boolean = false, param4:Boolean = false, param5:Date = null, param6:Date = null, param7:Number = 0, param8:String = null, param9:Object = null, param10:MediaError = null)
{
super(param1,param3,param4);
this._drmState = param2;
this._token = param9;
this._mediaError = param10;
this._startDate = param5;
this._endDate = param6;
this._period = param7;
this._serverURL = param8;
}
public function get token() : Object
{
return this._token;
}
public function get mediaError() : MediaError
{
return this._mediaError;
}
public function get startDate() : Date
{
return this._startDate;
}
public function get endDate() : Date
{
return this._endDate;
}
public function get period() : Number
{
return this._period;
}
public function get drmState() : String
{
return this._drmState;
}
public function get serverURL() : String
{
return this._serverURL;
}
override public function clone() : Event
{
return new DRMEvent(type,this._drmState,bubbles,cancelable,this._startDate,this._endDate,this._period,this._serverURL,this._token,this._mediaError);
}
}
}
@@ -0,0 +1,21 @@
package org.osmf.events
{
import flash.events.Event;
public class DVREvent extends Event
{
public static const IS_RECORDING_CHANGE:String = "isRecordingChange";
public function DVREvent(param1:String, param2:Boolean = false, param3:Boolean = false)
{
super(param1,param2,param3);
}
override public function clone() : Event
{
return new DVREvent(type,bubbles,cancelable);
}
}
}
@@ -0,0 +1,29 @@
package org.osmf.events
{
import flash.events.Event;
public class DVRStreamInfoEvent extends Event
{
public static const DVRSTREAMINFO:String = "DVRStreamInfo";
private var _info:Object;
public function DVRStreamInfoEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Object = null)
{
super(param1,param2,param3);
this._info = param4;
}
override public function clone() : Event
{
return new DVRStreamInfoEvent(type,bubbles,cancelable,this.info);
}
public function get info() : Object
{
return this._info;
}
}
}
@@ -0,0 +1,72 @@
package org.osmf.events
{
import flash.display.DisplayObject;
import flash.events.Event;
public class DisplayObjectEvent extends Event
{
public static const DISPLAY_OBJECT_CHANGE:String = "displayObjectChange";
public static const MEDIA_SIZE_CHANGE:String = "mediaSizeChange";
private var _oldDisplayObject:DisplayObject;
private var _newDisplayObject:DisplayObject;
private var _oldWidth:Number;
private var _oldHeight:Number;
private var _newWidth:Number;
private var _newHeight:Number;
public function DisplayObjectEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:DisplayObject = null, param5:DisplayObject = null, param6:Number = NaN, param7:Number = NaN, param8:Number = NaN, param9:Number = NaN)
{
super(param1,param2,param3);
this._oldDisplayObject = param4;
this._newDisplayObject = param5;
this._oldWidth = param6;
this._oldHeight = param7;
this._newWidth = param8;
this._newHeight = param9;
}
public function get oldDisplayObject() : DisplayObject
{
return this._oldDisplayObject;
}
public function get newDisplayObject() : DisplayObject
{
return this._newDisplayObject;
}
public function get oldWidth() : Number
{
return this._oldWidth;
}
public function get oldHeight() : Number
{
return this._oldHeight;
}
public function get newWidth() : Number
{
return this._newWidth;
}
public function get newHeight() : Number
{
return this._newHeight;
}
override public function clone() : Event
{
return new DisplayObjectEvent(type,bubbles,cancelable,this._oldDisplayObject,this._newDisplayObject,this._oldWidth,this._oldHeight,this._newWidth,this._newHeight);
}
}
}
@@ -0,0 +1,41 @@
package org.osmf.events
{
import flash.events.Event;
public class DynamicStreamEvent extends Event
{
public static const SWITCHING_CHANGE:String = "switchingChange";
public static const NUM_DYNAMIC_STREAMS_CHANGE:String = "numDynamicStreamsChange";
public static const AUTO_SWITCH_CHANGE:String = "autoSwitchChange";
private var _switching:Boolean;
private var _autoSwitch:Boolean;
public function DynamicStreamEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Boolean = false)
{
super(param1,param2,param3);
this._switching = param4;
this._autoSwitch = param5;
}
public function get switching() : Boolean
{
return this._switching;
}
public function get autoSwitch() : Boolean
{
return this._autoSwitch;
}
override public function clone() : Event
{
return new DynamicStreamEvent(type,bubbles,cancelable,this._switching,this._autoSwitch);
}
}
}
@@ -0,0 +1,77 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.net.httpstreaming.f4f.AdobeBootstrapBox;
import org.osmf.net.httpstreaming.flv.FLVTagScriptDataObject;
public class HTTPStreamingFileHandlerEvent extends Event
{
public static const NOTIFY_SEGMENT_DURATION:String = "notifySegmentDuration";
public static const NOTIFY_SCRIPT_DATA:String = "notifyScriptData";
public static const NOTIFY_BOOTSTRAP_BOX:String = "notifyBootstrapBox";
public static const NOTIFY_ERROR:String = "notifyError";
private var _segmentDuration:Number;
private var _scriptDataObject:FLVTagScriptDataObject;
private var _scriptDataFirst:Boolean;
private var _scriptDataImmediate:Boolean;
private var _abst:AdobeBootstrapBox;
private var _error:Boolean;
public function HTTPStreamingFileHandlerEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Number = 0, param5:FLVTagScriptDataObject = null, param6:Boolean = false, param7:Boolean = false, param8:AdobeBootstrapBox = null, param9:Boolean = false)
{
super(param1,param2,param3);
this._segmentDuration = param4;
this._scriptDataObject = param5;
this._scriptDataFirst = param6;
this._scriptDataImmediate = param7;
this._abst = param8;
this._error = param9;
}
public function get segmentDuration() : Number
{
return this._segmentDuration;
}
public function get scriptDataObject() : FLVTagScriptDataObject
{
return this._scriptDataObject;
}
public function get scriptDataFirst() : Boolean
{
return this._scriptDataFirst;
}
public function get scriptDataImmediate() : Boolean
{
return this._scriptDataImmediate;
}
public function get bootstrapBox() : AdobeBootstrapBox
{
return this._abst;
}
public function get error() : Boolean
{
return this._error;
}
override public function clone() : Event
{
return new HTTPStreamingFileHandlerEvent(type,bubbles,cancelable,this.segmentDuration,this.scriptDataObject,this.scriptDataFirst,this.scriptDataImmediate,this.bootstrapBox,this.error);
}
}
}
@@ -0,0 +1,121 @@
package org.osmf.events
{
import flash.events.Event;
import flash.net.URLRequest;
import org.osmf.net.httpstreaming.flv.FLVTagScriptDataObject;
public class HTTPStreamingIndexHandlerEvent extends Event
{
public static const NOTIFY_INDEX_READY:String = "notifyIndexReady";
public static const NOTIFY_RATES:String = "notifyRates";
public static const REQUEST_LOAD_INDEX:String = "requestLoadIndex";
public static const NOTIFY_ERROR:String = "notifyError";
public static const NOTIFY_SEGMENT_DURATION:String = "notifySegmentDuration";
public static const NOTIFY_SCRIPT_DATA:String = "notifyScriptData";
private var _streamNames:Array;
private var _rates:Array;
private var _request:URLRequest;
private var _requestContext:Object;
private var _binaryData:Boolean;
private var _segmentDuration:Number;
private var _scriptDataObject:FLVTagScriptDataObject;
private var _scriptDataFirst:Boolean;
private var _scriptDataImmediate:Boolean;
private var _live:Boolean;
private var _offset:Number;
public function HTTPStreamingIndexHandlerEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Number = NaN, param6:Array = null, param7:Array = null, param8:URLRequest = null, param9:Object = null, param10:Boolean = true, param11:Number = 0, param12:FLVTagScriptDataObject = null, param13:Boolean = false, param14:Boolean = false)
{
super(param1,param2,param3);
this._live = param4;
this._offset = param5;
this._streamNames = param6;
this._rates = param7;
this._request = param8;
this._requestContext = param9;
this._binaryData = param10;
this._segmentDuration = param11;
this._scriptDataObject = param12;
this._scriptDataFirst = param13;
this._scriptDataImmediate = param14;
}
public function get live() : Boolean
{
return this._live;
}
public function get offset() : Number
{
return this._offset;
}
public function get streamNames() : Array
{
return this._streamNames;
}
public function get rates() : Array
{
return this._rates;
}
public function get request() : URLRequest
{
return this._request;
}
public function get requestContext() : Object
{
return this._requestContext;
}
public function get binaryData() : Boolean
{
return this._binaryData;
}
public function get segmentDuration() : Number
{
return this._segmentDuration;
}
public function get scriptDataObject() : FLVTagScriptDataObject
{
return this._scriptDataObject;
}
public function get scriptDataFirst() : Boolean
{
return this._scriptDataFirst;
}
public function get scriptDataImmediate() : Boolean
{
return this._scriptDataImmediate;
}
override public function clone() : Event
{
return new HTTPStreamingIndexHandlerEvent(type,bubbles,cancelable,this.live,this.offset,this.streamNames,this.rates,this.request,this.requestContext,this.binaryData,this.segmentDuration,this.scriptDataObject,this.scriptDataFirst,this.scriptDataImmediate);
}
}
}
@@ -0,0 +1,41 @@
package org.osmf.events
{
import flash.events.Event;
public class LoadEvent extends Event
{
public static const LOAD_STATE_CHANGE:String = "loadStateChange";
public static const BYTES_LOADED_CHANGE:String = "bytesLoadedChange";
public static const BYTES_TOTAL_CHANGE:String = "bytesTotalChange";
private var _loadState:String;
private var _bytes:Number;
public function LoadEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:String = null, param5:Number = NaN)
{
super(param1,param2,param3);
this._loadState = param4;
this._bytes = param5;
}
override public function clone() : Event
{
return new LoadEvent(type,bubbles,cancelable,this.loadState,this.bytes);
}
public function get loadState() : String
{
return this._loadState;
}
public function get bytes() : Number
{
return this._bytes;
}
}
}
@@ -0,0 +1,55 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
public class LoaderEvent extends Event
{
public static const LOAD_STATE_CHANGE:String = "loadStateChange";
private var _loader:LoaderBase;
private var _loadTrait:LoadTrait;
private var _oldState:String;
private var _newState:String;
public function LoaderEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:LoaderBase = null, param5:LoadTrait = null, param6:String = null, param7:String = null)
{
super(param1,param2,param3);
this._loader = param4;
this._loadTrait = param5;
this._oldState = param6;
this._newState = param7;
}
public function get loader() : LoaderBase
{
return this._loader;
}
public function get loadTrait() : LoadTrait
{
return this._loadTrait;
}
public function get oldState() : String
{
return this._oldState;
}
public function get newState() : String
{
return this._newState;
}
override public function clone() : Event
{
return new LoaderEvent(type,bubbles,cancelable,this.loader,this.loadTrait,this.oldState,this.newState);
}
}
}
@@ -0,0 +1,21 @@
package org.osmf.events
{
import flash.events.Event;
public class MediaElementChangeEvent extends Event
{
public static const MEDIA_ELEMENT_CHANGE:String = "mediaElementChange";
public function MediaElementChangeEvent(param1:String, param2:Boolean = false, param3:Boolean = false)
{
super(param1,param2,param3);
}
override public function clone() : Event
{
return new MediaElementChangeEvent(type,bubbles,cancelable);
}
}
}
@@ -0,0 +1,52 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.metadata.Metadata;
public class MediaElementEvent extends Event
{
public static const TRAIT_ADD:String = "traitAdd";
public static const TRAIT_REMOVE:String = "traitRemove";
public static const METADATA_ADD:String = "metadataAdd";
public static const METADATA_REMOVE:String = "metadataRemove";
private var _traitType:String;
private var _namespaceURL:String;
private var _metadata:Metadata;
public function MediaElementEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:String = null, param5:String = null, param6:Metadata = null)
{
super(param1,param2,param3);
this._traitType = param4;
this._namespaceURL = param5;
this._metadata = param6;
}
override public function clone() : Event
{
return new MediaElementEvent(type,bubbles,cancelable,this.traitType,this.namespaceURL,this.metadata);
}
public function get traitType() : String
{
return this._traitType;
}
public function get namespaceURL() : String
{
return this._namespaceURL;
}
public function get metadata() : Metadata
{
return this._metadata;
}
}
}
@@ -0,0 +1,25 @@
package org.osmf.events
{
public class MediaError extends Error
{
private var _detail:String;
public function MediaError(param1:int, param2:String = null)
{
super(this.getMessageForErrorID(param1),param1);
this._detail = param2;
}
public function get detail() : String
{
return this._detail;
}
protected function getMessageForErrorID(param1:int) : String
{
return MediaErrorCodes.getMessageForErrorID(param1);
}
}
}
@@ -0,0 +1,147 @@
package org.osmf.events
{
import org.osmf.utils.OSMFStrings;
public final class MediaErrorCodes
{
public static const IO_ERROR:int = 1;
public static const SECURITY_ERROR:int = 2;
public static const ASYNC_ERROR:int = 3;
public static const ARGUMENT_ERROR:int = 4;
public static const URL_SCHEME_INVALID:int = 5;
public static const HTTP_GET_FAILED:int = 6;
public static const MEDIA_LOAD_FAILED:int = 7;
public static const PLUGIN_VERSION_INVALID:int = 8;
public static const PLUGIN_IMPLEMENTATION_INVALID:int = 9;
public static const SOUND_PLAY_FAILED:int = 10;
public static const NETCONNECTION_REJECTED:int = 11;
public static const NETCONNECTION_APPLICATION_INVALID:int = 12;
public static const NETCONNECTION_FAILED:int = 13;
public static const NETCONNECTION_TIMEOUT:int = 14;
public static const NETSTREAM_PLAY_FAILED:int = 15;
public static const NETSTREAM_STREAM_NOT_FOUND:int = 16;
public static const NETSTREAM_FILE_STRUCTURE_INVALID:int = 17;
public static const NETSTREAM_NO_SUPPORTED_TRACK_FOUND:int = 18;
public static const DRM_SYSTEM_UPDATE_ERROR:int = 19;
public static const DVRCAST_SUBSCRIBE_FAILED:int = 20;
public static const DVRCAST_CONTENT_OFFLINE:int = 21;
public static const DVRCAST_STREAM_INFO_RETRIEVAL_FAILED:int = 22;
public static const F4M_FILE_INVALID:int = 23;
private static const errorMap:Array = [{
"errorID":IO_ERROR,
"message":OSMFStrings.IO_ERROR
},{
"errorID":SECURITY_ERROR,
"message":OSMFStrings.SECURITY_ERROR
},{
"errorID":ASYNC_ERROR,
"message":OSMFStrings.ASYNC_ERROR
},{
"errorID":ARGUMENT_ERROR,
"message":OSMFStrings.ARGUMENT_ERROR
},{
"errorID":URL_SCHEME_INVALID,
"message":OSMFStrings.URL_SCHEME_INVALID
},{
"errorID":HTTP_GET_FAILED,
"message":OSMFStrings.HTTP_GET_FAILED
},{
"errorID":MEDIA_LOAD_FAILED,
"message":OSMFStrings.MEDIA_LOAD_FAILED
},{
"errorID":PLUGIN_VERSION_INVALID,
"message":OSMFStrings.PLUGIN_VERSION_INVALID
},{
"errorID":PLUGIN_IMPLEMENTATION_INVALID,
"message":OSMFStrings.PLUGIN_IMPLEMENTATION_INVALID
},{
"errorID":SOUND_PLAY_FAILED,
"message":OSMFStrings.SOUND_PLAY_FAILED
},{
"errorID":NETCONNECTION_REJECTED,
"message":OSMFStrings.NETCONNECTION_REJECTED
},{
"errorID":NETCONNECTION_APPLICATION_INVALID,
"message":OSMFStrings.NETCONNECTION_APPLICATION_INVALID
},{
"errorID":NETCONNECTION_FAILED,
"message":OSMFStrings.NETCONNECTION_FAILED
},{
"errorID":NETCONNECTION_TIMEOUT,
"message":OSMFStrings.NETCONNECTION_TIMEOUT
},{
"errorID":NETSTREAM_PLAY_FAILED,
"message":OSMFStrings.NETSTREAM_PLAY_FAILED
},{
"errorID":NETSTREAM_STREAM_NOT_FOUND,
"message":OSMFStrings.NETSTREAM_STREAM_NOT_FOUND
},{
"errorID":NETSTREAM_FILE_STRUCTURE_INVALID,
"message":OSMFStrings.NETSTREAM_FILE_STRUCTURE_INVALID
},{
"errorID":NETSTREAM_NO_SUPPORTED_TRACK_FOUND,
"message":OSMFStrings.NETSTREAM_NO_SUPPORTED_TRACK_FOUND
},{
"errorID":DRM_SYSTEM_UPDATE_ERROR,
"message":OSMFStrings.DRM_SYSTEM_UPDATE_ERROR
},{
"errorID":DVRCAST_SUBSCRIBE_FAILED,
"message":OSMFStrings.DVRCAST_SUBSCRIBE_FAILED
},{
"errorID":DVRCAST_CONTENT_OFFLINE,
"message":OSMFStrings.DVRCAST_CONTENT_OFFLINE
},{
"errorID":DVRCAST_STREAM_INFO_RETRIEVAL_FAILED,
"message":OSMFStrings.DVRCAST_STREAM_INFO_RETRIEVAL_FAILED
},{
"errorID":F4M_FILE_INVALID,
"message":OSMFStrings.F4M_FILE_INVALID
}];
public function MediaErrorCodes()
{
super();
}
internal static function getMessageForErrorID(param1:int) : String
{
var _loc2_:String = "";
var _loc3_:int = 0;
while(_loc3_ < errorMap.length)
{
if(errorMap[_loc3_].errorID == param1)
{
_loc2_ = OSMFStrings.getString(errorMap[_loc3_].message);
break;
}
_loc3_++;
}
return _loc2_;
}
}
}
@@ -0,0 +1,29 @@
package org.osmf.events
{
import flash.events.Event;
public class MediaErrorEvent extends Event
{
public static const MEDIA_ERROR:String = "mediaError";
private var _error:MediaError;
public function MediaErrorEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:MediaError = null)
{
super(param1,param2,param3);
this._error = param4;
}
override public function clone() : Event
{
return new MediaErrorEvent(type,bubbles,cancelable,this.error);
}
public function get error() : MediaError
{
return this._error;
}
}
}
@@ -0,0 +1,43 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.media.MediaElement;
import org.osmf.media.MediaResourceBase;
public class MediaFactoryEvent extends Event
{
public static const PLUGIN_LOAD:String = "pluginLoad";
public static const PLUGIN_LOAD_ERROR:String = "pluginLoadError";
public static const MEDIA_ELEMENT_CREATE:String = "mediaElementCreate";
private var _resource:MediaResourceBase;
private var _mediaElement:MediaElement;
public function MediaFactoryEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:MediaResourceBase = null, param5:MediaElement = null)
{
super(param1,param2,param3);
this._resource = param4;
this._mediaElement = param5;
}
public function get resource() : MediaResourceBase
{
return this._resource;
}
public function get mediaElement() : MediaElement
{
return this._mediaElement;
}
override public function clone() : Event
{
return new MediaFactoryEvent(type,bubbles,cancelable,this._resource,this._mediaElement);
}
}
}
@@ -0,0 +1,45 @@
package org.osmf.events
{
import flash.events.Event;
public class MediaPlayerCapabilityChangeEvent extends Event
{
public static const CAN_PLAY_CHANGE:String = "canPlayChange";
public static const CAN_SEEK_CHANGE:String = "canSeekChange";
public static const TEMPORAL_CHANGE:String = "temporalChange";
public static const HAS_AUDIO_CHANGE:String = "hasAudioChange";
public static const IS_DYNAMIC_STREAM_CHANGE:String = "isDynamicStreamChange";
public static const CAN_LOAD_CHANGE:String = "canLoadChange";
public static const CAN_BUFFER_CHANGE:String = "canBufferChange";
public static const HAS_DRM_CHANGE:String = "hasDRMChange";
public static const HAS_DISPLAY_OBJECT_CHANGE:String = "hasDisplayObjectChange";
private var _enabled:Boolean;
public function MediaPlayerCapabilityChangeEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false)
{
super(param1,param2,param3);
this._enabled = param4;
}
public function get enabled() : Boolean
{
return this._enabled;
}
override public function clone() : Event
{
return new MediaPlayerCapabilityChangeEvent(type,bubbles,cancelable,this._enabled);
}
}
}
@@ -0,0 +1,29 @@
package org.osmf.events
{
import flash.events.Event;
public class MediaPlayerStateChangeEvent extends Event
{
public static const MEDIA_PLAYER_STATE_CHANGE:String = "mediaPlayerStateChange";
private var _state:String;
public function MediaPlayerStateChangeEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:String = null)
{
super(param1,param2,param3);
this._state = param4;
}
public function get state() : String
{
return this._state;
}
override public function clone() : Event
{
return new MediaPlayerStateChangeEvent(type,bubbles,cancelable,this._state);
}
}
}
@@ -0,0 +1,49 @@
package org.osmf.events
{
import flash.events.Event;
public class MetadataEvent extends Event
{
public static const VALUE_ADD:String = "valueAdd";
public static const VALUE_REMOVE:String = "valueRemove";
public static const VALUE_CHANGE:String = "valueChange";
private var _key:String;
private var _value:*;
private var _oldValue:*;
public function MetadataEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:String = null, param5:* = null, param6:* = null)
{
super(param1,param2,param3);
this._key = param4;
this._value = param5;
this._oldValue = param6;
}
public function get key() : String
{
return this._key;
}
public function get value() : *
{
return this._value;
}
public function get oldValue() : *
{
return this._oldValue;
}
override public function clone() : Event
{
return new MetadataEvent(type,bubbles,cancelable,this._key,this._value,this._oldValue);
}
}
}
@@ -0,0 +1,49 @@
package org.osmf.events
{
import flash.events.Event;
import flash.net.NetConnection;
import org.osmf.media.URLResource;
public class NetConnectionFactoryEvent extends Event
{
public static const CREATION_COMPLETE:String = "creationComplete";
public static const CREATION_ERROR:String = "creationError";
private var _netConnection:NetConnection;
private var _resource:URLResource;
private var _mediaError:MediaError;
public function NetConnectionFactoryEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:NetConnection = null, param5:URLResource = null, param6:MediaError = null)
{
super(param1,param2,param3);
this._netConnection = param4;
this._resource = param5;
this._mediaError = param6;
}
public function get netConnection() : NetConnection
{
return this._netConnection;
}
public function get resource() : URLResource
{
return this._resource;
}
public function get mediaError() : MediaError
{
return this._mediaError;
}
override public function clone() : Event
{
return new NetConnectionFactoryEvent(type,bubbles,cancelable,this._netConnection,this._resource,this._mediaError);
}
}
}
@@ -0,0 +1,39 @@
package org.osmf.events
{
import flash.events.Event;
public class PlayEvent extends Event
{
public static const CAN_PAUSE_CHANGE:String = "canPauseChange";
public static const PLAY_STATE_CHANGE:String = "playStateChange";
private var _playState:String;
private var _canPause:Boolean;
public function PlayEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:String = null, param5:Boolean = false)
{
super(param1,param2,param3);
this._playState = param4;
this._canPause = param5;
}
override public function clone() : Event
{
return new PlayEvent(type,bubbles,cancelable,this.playState,this.canPause);
}
public function get playState() : String
{
return this._playState;
}
public function get canPause() : Boolean
{
return this._canPause;
}
}
}
@@ -0,0 +1,32 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.media.MediaResourceBase;
public class PluginManagerEvent extends Event
{
public static const PLUGIN_LOAD:String = "pluginLoad";
public static const PLUGIN_LOAD_ERROR:String = "pluginLoadError";
private var _resource:MediaResourceBase;
public function PluginManagerEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:MediaResourceBase = null)
{
super(param1,param2,param3);
this._resource = param4;
}
public function get resource() : MediaResourceBase
{
return this._resource;
}
override public function clone() : Event
{
return new PluginManagerEvent(type,bubbles,cancelable,this._resource);
}
}
}
@@ -0,0 +1,37 @@
package org.osmf.events
{
import flash.events.Event;
public class SeekEvent extends Event
{
public static const SEEKING_CHANGE:String = "seekingChange";
private var _seeking:Boolean = false;
private var _time:Number;
public function SeekEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Number = NaN)
{
super(param1,param2,param3);
this._seeking = param4;
this._time = param5;
}
public function get seeking() : Boolean
{
return this._seeking;
}
public function get time() : Number
{
return this._time;
}
override public function clone() : Event
{
return new SeekEvent(type,bubbles,cancelable,this._seeking,this._time);
}
}
}
@@ -0,0 +1,33 @@
package org.osmf.events
{
import flash.events.Event;
public class TimeEvent extends Event
{
public static const CURRENT_TIME_CHANGE:String = "currentTimeChange";
public static const DURATION_CHANGE:String = "durationChange";
public static const COMPLETE:String = "complete";
private var _time:Number;
public function TimeEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:Number = NaN)
{
super(param1,param2,param3);
this._time = param4;
}
public function get time() : Number
{
return this._time;
}
override public function clone() : Event
{
return new TimeEvent(type,bubbles,cancelable,this.time);
}
}
}
@@ -0,0 +1,36 @@
package org.osmf.events
{
import flash.events.Event;
import org.osmf.metadata.TimelineMarker;
public class TimelineMetadataEvent extends MetadataEvent
{
public static const MARKER_TIME_REACHED:String = "markerTimeReached";
public static const MARKER_DURATION_REACHED:String = "markerDurationReached";
public static const MARKER_ADD:String = "markerAdd";
public static const MARKER_REMOVE:String = "markerRemove";
private var _marker:TimelineMarker;
public function TimelineMetadataEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:TimelineMarker = null)
{
super(param1,param2,param3,"" + param4.time,param4);
this._marker = param4;
}
public function get marker() : TimelineMarker
{
return this._marker;
}
override public function clone() : Event
{
return new TimelineMetadataEvent(type,bubbles,cancelable,this._marker);
}
}
}
@@ -0,0 +1,120 @@
package org.osmf.layout
{
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.NonSynthesizingMetadata;
internal class AbsoluteLayoutMetadata extends NonSynthesizingMetadata
{
public static const X:String = "x";
public static const Y:String = "y";
public static const WIDTH:String = "width";
public static const HEIGHT:String = "height";
private var _x:Number;
private var _y:Number;
private var _width:Number;
private var _height:Number;
public function AbsoluteLayoutMetadata()
{
super();
}
override public function getValue(param1:String) : *
{
if(param1 == null)
{
return undefined;
}
if(param1 == X)
{
return this.x;
}
if(param1 == Y)
{
return this.y;
}
if(param1 == WIDTH)
{
return this.width;
}
if(param1 == HEIGHT)
{
return this.height;
}
return undefined;
}
public function get x() : Number
{
return this._x;
}
public function set x(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._x != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,X,param1,this._x);
this._x = param1;
dispatchEvent(_loc2_);
}
}
public function get y() : Number
{
return this._y;
}
public function set y(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._y != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,Y,param1,this._y);
this._y = param1;
dispatchEvent(_loc2_);
}
}
public function get width() : Number
{
return this._width;
}
public function set width(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._width != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,WIDTH,param1,this._width);
this._width = param1;
dispatchEvent(_loc2_);
}
}
public function get height() : Number
{
return this._height;
}
public function set height(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._height != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,HEIGHT,param1,this._height);
this._height = param1;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,120 @@
package org.osmf.layout
{
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.NonSynthesizingMetadata;
internal class AnchorLayoutMetadata extends NonSynthesizingMetadata
{
public static const LEFT:String = "left";
public static const TOP:String = "top";
public static const RIGHT:String = "right";
public static const BOTTOM:String = "bottom";
private var _left:Number;
private var _top:Number;
private var _right:Number;
private var _bottom:Number;
public function AnchorLayoutMetadata()
{
super();
}
override public function getValue(param1:String) : *
{
if(param1 == null)
{
return undefined;
}
if(param1 == LEFT)
{
return this.left;
}
if(param1 == TOP)
{
return this.top;
}
if(param1 == RIGHT)
{
return this.right;
}
if(param1 == BOTTOM)
{
return this.bottom;
}
return undefined;
}
public function get left() : Number
{
return this._left;
}
public function set left(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._left != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,LEFT,param1,this._left);
this._left = param1;
dispatchEvent(_loc2_);
}
}
public function get top() : Number
{
return this._top;
}
public function set top(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._top != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,TOP,param1,this._top);
this._top = param1;
dispatchEvent(_loc2_);
}
}
public function get right() : Number
{
return this._right;
}
public function set right(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._right != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,RIGHT,param1,this._right);
this._right = param1;
dispatchEvent(_loc2_);
}
}
public function get bottom() : Number
{
return this._bottom;
}
public function set bottom(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._bottom != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,BOTTOM,param1,this._bottom);
this._bottom = param1;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,43 @@
package org.osmf.layout
{
import org.osmf.utils.OSMFStrings;
internal class BinarySearch
{
public function BinarySearch()
{
super();
}
public static function search(param1:Object, param2:Function, param3:*, param4:int = 0, param5:int = -2147483648) : int
{
var _loc7_:int = 0;
var _loc8_:* = undefined;
if(param1 == null || param2 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
var _loc6_:int = -param4;
param5 = param5 == int.MIN_VALUE ? int(param1.length - 1) : param5;
if(param1.length > 0 && param4 <= param5)
{
_loc7_ = (param4 + param5) / 2;
_loc8_ = param1[_loc7_];
switch(param2(param3,_loc8_))
{
case -1:
_loc6_ = search(param1,param2,param3,param4,_loc7_ - 1);
break;
case 0:
_loc6_ = _loc7_;
break;
case 1:
_loc6_ = search(param1,param2,param3,_loc7_ + 1,param5);
}
}
return _loc6_;
}
}
}
@@ -0,0 +1,74 @@
package org.osmf.layout
{
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.NonSynthesizingMetadata;
internal class BoxAttributesMetadata extends NonSynthesizingMetadata
{
public static const RELATIVE_SUM:String = "relativeSum";
public static const ABSOLUTE_SUM:String = "absoluteSum";
private var _relativeSum:Number;
private var _absoluteSum:Number;
public function BoxAttributesMetadata()
{
super();
this._relativeSum = 0;
this._absoluteSum = 0;
}
override public function getValue(param1:String) : *
{
if(param1 == null)
{
return undefined;
}
if(param1 == RELATIVE_SUM)
{
return this.relativeSum;
}
if(param1 == ABSOLUTE_SUM)
{
return this.absoluteSum;
}
return undefined;
}
public function get relativeSum() : Number
{
return this._relativeSum;
}
public function set relativeSum(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._relativeSum != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,RELATIVE_SUM,param1,this._relativeSum);
this._relativeSum = param1;
dispatchEvent(_loc2_);
}
}
public function get absoluteSum() : Number
{
return this._absoluteSum;
}
public function set absoluteSum(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._absoluteSum != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,ABSOLUTE_SUM,param1,this._absoluteSum);
this._absoluteSum = param1;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.layout
{
public final class HorizontalAlign
{
public static const LEFT:String = "left";
public static const CENTER:String = "center";
public static const RIGHT:String = "right";
public function HorizontalAlign()
{
super();
}
}
}
@@ -0,0 +1,22 @@
package org.osmf.layout
{
import flash.display.DisplayObject;
import flash.events.IEventDispatcher;
public interface ILayoutTarget extends IEventDispatcher
{
function get displayObject() : DisplayObject;
function get layoutMetadata() : LayoutMetadata;
function get measuredWidth() : Number;
function get measuredHeight() : Number;
function measure(param1:Boolean = true) : void;
function layout(param1:Number, param2:Number, param3:Boolean = true) : void;
}
}
@@ -0,0 +1,194 @@
package org.osmf.layout
{
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.NonSynthesizingMetadata;
internal class LayoutAttributesMetadata extends NonSynthesizingMetadata
{
public static const INDEX:String = "index";
public static const SCALE_MODE:String = "scaleMode";
public static const VERTICAL_ALIGN:String = "verticalAlign";
public static const HORIZONTAL_ALIGN:String = "horizontalAlign";
public static const SNAP_TO_PIXEL:String = "snapToPixel";
public static const MODE:String = "layoutMode";
public static const INCLUDE_IN_LAYOUT:String = "includeInLayout";
private var _index:Number = NaN;
private var _scaleMode:String;
private var _verticalAlign:String;
private var _horizontalAlign:String;
private var _snapToPixel:Boolean;
private var _layoutMode:String;
private var _includeInLayout:Boolean;
public function LayoutAttributesMetadata()
{
super();
this._verticalAlign = null;
this._horizontalAlign = null;
this._scaleMode = null;
this._snapToPixel = true;
this._layoutMode = LayoutMode.NONE;
this._includeInLayout = true;
}
override public function getValue(param1:String) : *
{
if(param1 == null)
{
return undefined;
}
if(param1 == INDEX)
{
return this.index;
}
if(param1 == SCALE_MODE)
{
return this.scaleMode;
}
if(param1 == VERTICAL_ALIGN)
{
return this.verticalAlign;
}
if(param1 == HORIZONTAL_ALIGN)
{
return this.horizontalAlign;
}
if(param1 == SNAP_TO_PIXEL)
{
return this.snapToPixel;
}
if(param1 == INCLUDE_IN_LAYOUT)
{
return this.snapToPixel;
}
return undefined;
}
public function get index() : Number
{
return this._index;
}
public function set index(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._index != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,INDEX,param1,this._index);
this._index = param1;
dispatchEvent(_loc2_);
}
}
public function get scaleMode() : String
{
return this._scaleMode;
}
public function set scaleMode(param1:String) : void
{
var _loc2_:MetadataEvent = null;
if(this._scaleMode != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,SCALE_MODE,param1,this._scaleMode);
this._scaleMode = param1;
dispatchEvent(_loc2_);
}
}
public function get verticalAlign() : String
{
return this._verticalAlign;
}
public function set verticalAlign(param1:String) : void
{
var _loc2_:MetadataEvent = null;
if(this._verticalAlign != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,VERTICAL_ALIGN,param1,this._verticalAlign);
this._verticalAlign = param1;
dispatchEvent(_loc2_);
}
}
public function get horizontalAlign() : String
{
return this._horizontalAlign;
}
public function set horizontalAlign(param1:String) : void
{
var _loc2_:MetadataEvent = null;
if(this._horizontalAlign != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,HORIZONTAL_ALIGN,param1,this._horizontalAlign);
this._horizontalAlign = param1;
dispatchEvent(_loc2_);
}
}
public function get snapToPixel() : Boolean
{
return this._snapToPixel;
}
public function set snapToPixel(param1:Boolean) : void
{
var _loc2_:MetadataEvent = null;
if(this._snapToPixel != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,SNAP_TO_PIXEL,param1,this._snapToPixel);
this._snapToPixel = param1;
dispatchEvent(_loc2_);
}
}
public function get layoutMode() : String
{
return this._layoutMode;
}
public function set layoutMode(param1:String) : void
{
var _loc2_:MetadataEvent = null;
if(this._layoutMode != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,MODE,param1,this._layoutMode);
this._layoutMode = param1;
dispatchEvent(_loc2_);
}
}
public function get includeInLayout() : Boolean
{
return this._includeInLayout;
}
public function set includeInLayout(param1:Boolean) : void
{
var _loc2_:MetadataEvent = null;
if(this._includeInLayout != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,INCLUDE_IN_LAYOUT,param1,this._layoutMode);
this._includeInLayout = param1;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,341 @@
package org.osmf.layout
{
import org.osmf.metadata.Metadata;
import org.osmf.metadata.MetadataNamespaces;
import org.osmf.metadata.MetadataSynthesizer;
import org.osmf.metadata.NullMetadataSynthesizer;
public class LayoutMetadata extends Metadata
{
public static const LAYOUT_NAMESPACE:String = "http://www.osmf.org/layout/1.0";
private const SYNTHESIZER:NullMetadataSynthesizer = new NullMetadataSynthesizer();
public function LayoutMetadata()
{
super();
}
public function get index() : Number
{
return this.lazyAttributes ? this.lazyAttributes.index : NaN;
}
public function set index(param1:Number) : void
{
this.eagerAttributes.index = param1;
}
public function get scaleMode() : String
{
return this.lazyAttributes ? this.lazyAttributes.scaleMode : null;
}
public function set scaleMode(param1:String) : void
{
this.eagerAttributes.scaleMode = param1;
}
public function get horizontalAlign() : String
{
return this.lazyAttributes ? this.lazyAttributes.horizontalAlign : null;
}
public function set horizontalAlign(param1:String) : void
{
this.eagerAttributes.horizontalAlign = param1;
}
public function get verticalAlign() : String
{
return this.lazyAttributes ? this.lazyAttributes.verticalAlign : null;
}
public function set verticalAlign(param1:String) : void
{
this.eagerAttributes.verticalAlign = param1;
}
public function get snapToPixel() : Boolean
{
return this.lazyAttributes ? this.lazyAttributes.snapToPixel : true;
}
public function set snapToPixel(param1:Boolean) : void
{
this.eagerAttributes.snapToPixel = param1;
}
public function get layoutMode() : String
{
return this.lazyAttributes ? this.lazyAttributes.layoutMode : LayoutMode.NONE;
}
public function set layoutMode(param1:String) : void
{
this.eagerAttributes.layoutMode = param1;
}
public function get includeInLayout() : Boolean
{
return this.lazyAttributes ? this.lazyAttributes.includeInLayout : true;
}
public function set includeInLayout(param1:Boolean) : void
{
this.eagerAttributes.includeInLayout = param1;
}
public function get x() : Number
{
return this.lazyAbsolute ? this.lazyAbsolute.x : NaN;
}
public function set x(param1:Number) : void
{
this.eagerAbsolute.x = param1;
}
public function get y() : Number
{
return this.lazyAbsolute ? this.lazyAbsolute.y : NaN;
}
public function set y(param1:Number) : void
{
this.eagerAbsolute.y = param1;
}
public function get width() : Number
{
return this.lazyAbsolute ? this.lazyAbsolute.width : NaN;
}
public function set width(param1:Number) : void
{
this.eagerAbsolute.width = param1;
}
public function get height() : Number
{
return this.lazyAbsolute ? this.lazyAbsolute.height : NaN;
}
public function set height(param1:Number) : void
{
this.eagerAbsolute.height = param1;
}
public function get percentX() : Number
{
return this.lazyRelative ? this.lazyRelative.x : NaN;
}
public function set percentX(param1:Number) : void
{
this.eagerRelative.x = param1;
}
public function get percentY() : Number
{
return this.lazyRelative ? this.lazyRelative.y : NaN;
}
public function set percentY(param1:Number) : void
{
this.eagerRelative.y = param1;
}
public function get percentWidth() : Number
{
return this.lazyRelative ? this.lazyRelative.width : NaN;
}
public function set percentWidth(param1:Number) : void
{
this.eagerRelative.width = param1;
}
public function get percentHeight() : Number
{
return this.lazyRelative ? this.lazyRelative.height : NaN;
}
public function set percentHeight(param1:Number) : void
{
this.eagerRelative.height = param1;
}
public function get left() : Number
{
return this.lazyAnchor ? this.lazyAnchor.left : NaN;
}
public function set left(param1:Number) : void
{
this.eagerAnchor.left = param1;
}
public function get top() : Number
{
return this.lazyAnchor ? this.lazyAnchor.top : NaN;
}
public function set top(param1:Number) : void
{
this.eagerAnchor.top = param1;
}
public function get right() : Number
{
return this.lazyAnchor ? this.lazyAnchor.right : NaN;
}
public function set right(param1:Number) : void
{
this.eagerAnchor.right = param1;
}
public function get bottom() : Number
{
return this.lazyAnchor ? this.lazyAnchor.bottom : NaN;
}
public function set bottom(param1:Number) : void
{
this.eagerAnchor.bottom = param1;
}
public function get paddingLeft() : Number
{
return this.lazyPadding ? this.lazyPadding.left : NaN;
}
public function set paddingLeft(param1:Number) : void
{
this.eagerPadding.left = param1;
}
public function get paddingTop() : Number
{
return this.lazyPadding ? this.lazyPadding.top : NaN;
}
public function set paddingTop(param1:Number) : void
{
this.eagerPadding.top = param1;
}
public function get paddingRight() : Number
{
return this.lazyPadding ? this.lazyPadding.right : NaN;
}
public function set paddingRight(param1:Number) : void
{
this.eagerPadding.right = param1;
}
public function get paddingBottom() : Number
{
return this.lazyPadding ? this.lazyPadding.bottom : NaN;
}
public function set paddingBottom(param1:Number) : void
{
this.eagerPadding.bottom = param1;
}
override public function toString() : String
{
return "abs [" + this.x + ", " + this.y + ", " + this.width + ", " + this.height + "] " + "rel [" + this.percentX + ", " + this.percentY + ", " + this.percentWidth + ", " + this.percentHeight + "] " + "anch (" + this.left + ", " + this.top + ")(" + this.right + ", " + this.bottom + ") " + "pad [" + this.paddingLeft + ", " + this.paddingTop + ", " + this.paddingRight + ", " + this.paddingBottom + "] " + "layoutMode: " + this.layoutMode + " " + "index: " + this.index + " " + "scale: " + this.scaleMode + " " + "valign: " + this.verticalAlign + " " + "halign: " + this.horizontalAlign + " " + "snap: " + this.snapToPixel;
}
override public function get synthesizer() : MetadataSynthesizer
{
return this.SYNTHESIZER;
}
private function get lazyAttributes() : LayoutAttributesMetadata
{
return getValue(MetadataNamespaces.LAYOUT_ATTRIBUTES) as LayoutAttributesMetadata;
}
private function get eagerAttributes() : LayoutAttributesMetadata
{
var _loc1_:LayoutAttributesMetadata = this.lazyAttributes;
if(_loc1_ == null)
{
_loc1_ = new LayoutAttributesMetadata();
addValue(MetadataNamespaces.LAYOUT_ATTRIBUTES,_loc1_);
}
return _loc1_;
}
private function get lazyAbsolute() : AbsoluteLayoutMetadata
{
return getValue(MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS) as AbsoluteLayoutMetadata;
}
private function get eagerAbsolute() : AbsoluteLayoutMetadata
{
var _loc1_:AbsoluteLayoutMetadata = this.lazyAbsolute;
if(_loc1_ == null)
{
_loc1_ = new AbsoluteLayoutMetadata();
addValue(MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS,_loc1_);
}
return _loc1_;
}
private function get lazyRelative() : RelativeLayoutMetadata
{
return getValue(MetadataNamespaces.RELATIVE_LAYOUT_PARAMETERS) as RelativeLayoutMetadata;
}
private function get eagerRelative() : RelativeLayoutMetadata
{
var _loc1_:RelativeLayoutMetadata = this.lazyRelative;
if(_loc1_ == null)
{
_loc1_ = new RelativeLayoutMetadata();
addValue(MetadataNamespaces.RELATIVE_LAYOUT_PARAMETERS,_loc1_);
}
return _loc1_;
}
private function get lazyAnchor() : AnchorLayoutMetadata
{
return getValue(MetadataNamespaces.ANCHOR_LAYOUT_PARAMETERS) as AnchorLayoutMetadata;
}
private function get eagerAnchor() : AnchorLayoutMetadata
{
var _loc1_:AnchorLayoutMetadata = this.lazyAnchor;
if(_loc1_ == null)
{
_loc1_ = new AnchorLayoutMetadata();
addValue(MetadataNamespaces.ANCHOR_LAYOUT_PARAMETERS,_loc1_);
}
return _loc1_;
}
private function get lazyPadding() : PaddingLayoutMetadata
{
return getValue(MetadataNamespaces.PADDING_LAYOUT_PARAMETERS) as PaddingLayoutMetadata;
}
private function get eagerPadding() : PaddingLayoutMetadata
{
var _loc1_:PaddingLayoutMetadata = this.lazyPadding;
if(_loc1_ == null)
{
_loc1_ = new PaddingLayoutMetadata();
addValue(MetadataNamespaces.PADDING_LAYOUT_PARAMETERS,_loc1_);
}
return _loc1_;
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.layout
{
public final class LayoutMode
{
public static const NONE:String = "none";
public static const VERTICAL:String = "vertical";
public static const HORIZONTAL:String = "horizontal";
public function LayoutMode()
{
super();
}
}
}
@@ -0,0 +1,443 @@
package org.osmf.layout
{
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.Dictionary;
import org.osmf.metadata.MetadataNamespaces;
import org.osmf.metadata.MetadataWatcher;
public class LayoutRenderer extends LayoutRendererBase
{
private static const USED_METADATAS:Vector.<String> = new Vector.<String>(5,true);
private static const X:int = 1;
private static const Y:int = 2;
private static const WIDTH:int = 4;
private static const HEIGHT:int = 8;
private static const POSITION:int = X + Y;
private static const DIMENSIONS:int = WIDTH + HEIGHT;
private static const ALL:int = POSITION + DIMENSIONS;
USED_METADATAS[0] = MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS;
USED_METADATAS[1] = MetadataNamespaces.RELATIVE_LAYOUT_PARAMETERS;
USED_METADATAS[2] = MetadataNamespaces.ANCHOR_LAYOUT_PARAMETERS;
USED_METADATAS[3] = MetadataNamespaces.PADDING_LAYOUT_PARAMETERS;
USED_METADATAS[4] = MetadataNamespaces.LAYOUT_ATTRIBUTES;
private var layoutMode:String = "none";
private var lastCalculatedBounds:Rectangle;
private var targetMetadataWatchers:Dictionary = new Dictionary();
private var containerAbsoluteWatcher:MetadataWatcher;
private var containerAttributesWatcher:MetadataWatcher;
public function LayoutRenderer()
{
super();
}
override protected function get usedMetadatas() : Vector.<String>
{
return USED_METADATAS;
}
override protected function processContainerChange(param1:ILayoutTarget, param2:ILayoutTarget) : void
{
var oldContainer:ILayoutTarget = param1;
var newContainer:ILayoutTarget = param2;
if(oldContainer)
{
this.containerAbsoluteWatcher.unwatch();
this.containerAttributesWatcher.unwatch();
}
if(newContainer)
{
this.containerAbsoluteWatcher = new MetadataWatcher(newContainer.layoutMetadata,MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS,null,function(... rest):void
{
invalidate();
});
this.containerAbsoluteWatcher.watch();
this.containerAttributesWatcher = new MetadataWatcher(newContainer.layoutMetadata,MetadataNamespaces.LAYOUT_ATTRIBUTES,null,function(param1:LayoutAttributesMetadata):void
{
layoutMode = param1 ? param1.layoutMode : LayoutMode.NONE;
invalidate();
});
this.containerAttributesWatcher.watch();
}
invalidate();
}
override protected function processUpdateMediaDisplayBegin(param1:Vector.<ILayoutTarget>) : void
{
this.lastCalculatedBounds = null;
}
override protected function processUpdateMediaDisplayEnd() : void
{
this.lastCalculatedBounds = null;
}
override protected function processTargetAdded(param1:ILayoutTarget) : void
{
var watcher:MetadataWatcher;
var target:ILayoutTarget = param1;
var attributes:LayoutAttributesMetadata = target.layoutMetadata.getValue(MetadataNamespaces.LAYOUT_ATTRIBUTES) as LayoutAttributesMetadata;
var relative:RelativeLayoutMetadata = target.layoutMetadata.getValue(MetadataNamespaces.RELATIVE_LAYOUT_PARAMETERS) as RelativeLayoutMetadata;
if(this.layoutMode == LayoutMode.NONE && relative == null && attributes == null && target.layoutMetadata.getValue(MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS) == null && target.layoutMetadata.getValue(MetadataNamespaces.ANCHOR_LAYOUT_PARAMETERS) == null)
{
relative = new RelativeLayoutMetadata();
relative.width = 100;
relative.height = 100;
target.layoutMetadata.addValue(MetadataNamespaces.RELATIVE_LAYOUT_PARAMETERS,relative);
attributes = new LayoutAttributesMetadata();
attributes.scaleMode = attributes.scaleMode || ScaleMode.LETTERBOX;
attributes.verticalAlign = attributes.verticalAlign || VerticalAlign.MIDDLE;
attributes.horizontalAlign = attributes.horizontalAlign || HorizontalAlign.CENTER;
target.layoutMetadata.addValue(MetadataNamespaces.LAYOUT_ATTRIBUTES,attributes);
}
watcher = new MetadataWatcher(target.layoutMetadata,MetadataNamespaces.LAYOUT_ATTRIBUTES,LayoutAttributesMetadata.INDEX,function(... rest):void
{
updateTargetOrder(target);
});
watcher.watch();
this.targetMetadataWatchers[target] = watcher;
}
override protected function processTargetRemoved(param1:ILayoutTarget) : void
{
var _loc2_:MetadataWatcher = this.targetMetadataWatchers[param1];
delete this.targetMetadataWatchers[param1];
_loc2_.unwatch();
_loc2_ = null;
}
override protected function compareTargets(param1:ILayoutTarget, param2:ILayoutTarget) : Number
{
var _loc3_:LayoutAttributesMetadata = param1.layoutMetadata.getValue(MetadataNamespaces.LAYOUT_ATTRIBUTES) as LayoutAttributesMetadata;
var _loc4_:LayoutAttributesMetadata = param2.layoutMetadata.getValue(MetadataNamespaces.LAYOUT_ATTRIBUTES) as LayoutAttributesMetadata;
var _loc5_:Number = _loc3_ ? _loc3_.index : NaN;
var _loc6_:Number = _loc4_ ? _loc4_.index : NaN;
if(isNaN(_loc5_) && isNaN(_loc6_))
{
return 1;
}
_loc5_ ||= 0;
_loc6_ ||= 0;
return _loc5_ < _loc6_ ? -1 : (_loc5_ > _loc6_ ? 1 : 0);
}
override protected function calculateTargetBounds(param1:ILayoutTarget, param2:Number, param3:Number) : Rectangle
{
var _loc7_:Number = NaN;
var _loc9_:Number = NaN;
var _loc13_:BoxAttributesMetadata = null;
var _loc14_:RelativeLayoutMetadata = null;
var _loc15_:AnchorLayoutMetadata = null;
var _loc16_:Point = null;
var _loc4_:LayoutAttributesMetadata = param1.layoutMetadata.getValue(MetadataNamespaces.LAYOUT_ATTRIBUTES) as LayoutAttributesMetadata || new LayoutAttributesMetadata();
if(_loc4_.includeInLayout == false)
{
return new Rectangle();
}
var _loc5_:Rectangle = new Rectangle(0,0,param1.measuredWidth,param1.measuredHeight);
var _loc6_:AbsoluteLayoutMetadata = param1.layoutMetadata.getValue(MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS) as AbsoluteLayoutMetadata;
var _loc8_:Number = 0;
var _loc10_:Number = 0;
var _loc11_:int = ALL;
if(_loc6_)
{
if(!isNaN(_loc6_.x))
{
_loc5_.x = _loc6_.x;
_loc11_ ^= X;
}
if(!isNaN(_loc6_.y))
{
_loc5_.y = _loc6_.y;
_loc11_ ^= Y;
}
if(!isNaN(_loc6_.width))
{
_loc5_.width = _loc6_.width;
_loc11_ ^= WIDTH;
}
if(!isNaN(_loc6_.height))
{
_loc5_.height = _loc6_.height;
_loc11_ ^= HEIGHT;
}
}
if(_loc11_ != 0)
{
_loc14_ = param1.layoutMetadata.getValue(MetadataNamespaces.RELATIVE_LAYOUT_PARAMETERS) as RelativeLayoutMetadata;
if(_loc14_)
{
if(Boolean(_loc11_ & X) && !isNaN(_loc14_.x))
{
_loc5_.x = param2 * _loc14_.x / 100 || 0;
_loc11_ ^= X;
}
if(Boolean(_loc11_ & WIDTH) && !isNaN(_loc14_.width))
{
if(this.layoutMode == LayoutMode.HORIZONTAL)
{
_loc13_ = container.layoutMetadata.getValue(MetadataNamespaces.BOX_LAYOUT_ATTRIBUTES) as BoxAttributesMetadata || new BoxAttributesMetadata();
_loc5_.width = Math.max(0,param2 - _loc13_.absoluteSum) * _loc14_.width / _loc13_.relativeSum;
}
else
{
_loc5_.width = param2 * _loc14_.width / 100;
}
_loc11_ ^= WIDTH;
}
if(Boolean(_loc11_ & Y) && !isNaN(_loc14_.y))
{
_loc5_.y = param3 * _loc14_.y / 100 || 0;
_loc11_ ^= Y;
}
if(Boolean(_loc11_ & HEIGHT) && !isNaN(_loc14_.height))
{
if(this.layoutMode == LayoutMode.VERTICAL)
{
_loc13_ = container.layoutMetadata.getValue(MetadataNamespaces.BOX_LAYOUT_ATTRIBUTES) as BoxAttributesMetadata || new BoxAttributesMetadata();
_loc5_.height = Math.max(0,param3 - _loc13_.absoluteSum) * _loc14_.height / _loc13_.relativeSum;
}
else
{
_loc5_.height = param3 * _loc14_.height / 100;
}
_loc11_ ^= HEIGHT;
}
}
}
if(_loc11_ != 0)
{
_loc15_ = param1.layoutMetadata.getValue(MetadataNamespaces.ANCHOR_LAYOUT_PARAMETERS) as AnchorLayoutMetadata;
if(_loc15_)
{
if(Boolean(_loc11_ & X) && !isNaN(_loc15_.left))
{
_loc5_.x = _loc15_.left;
_loc11_ ^= X;
}
if(Boolean(_loc11_ & Y) && !isNaN(_loc15_.top))
{
_loc5_.y = _loc15_.top;
_loc11_ ^= Y;
}
if(!isNaN(_loc15_.right) && Boolean(param2))
{
if(Boolean(_loc11_ & X) && !(_loc11_ & WIDTH))
{
_loc5_.x = Math.max(0,param2 - _loc5_.width - _loc15_.right);
_loc11_ ^= X;
}
else if(Boolean(_loc11_ & WIDTH) && !(_loc11_ & X))
{
_loc5_.width = Math.max(0,param2 - _loc15_.right - _loc5_.x);
_loc11_ ^= WIDTH;
}
else
{
_loc5_.x = Math.max(0,param2 - param1.measuredWidth - _loc15_.right);
_loc11_ ^= X;
}
_loc8_ += _loc15_.right;
}
if(!isNaN(_loc15_.bottom) && Boolean(param3))
{
if(Boolean(_loc11_ & Y) && !(_loc11_ & HEIGHT))
{
_loc5_.y = Math.max(0,param3 - _loc5_.height - _loc15_.bottom);
_loc11_ ^= Y;
}
else if(Boolean(_loc11_ & HEIGHT) && !(_loc11_ & Y))
{
_loc5_.height = Math.max(0,param3 - _loc15_.bottom - _loc5_.y);
_loc11_ ^= HEIGHT;
}
else
{
_loc5_.y = Math.max(0,param3 - param1.measuredHeight - _loc15_.bottom);
_loc11_ ^= Y;
}
_loc10_ += _loc15_.bottom;
}
}
}
var _loc12_:PaddingLayoutMetadata = param1.layoutMetadata.getValue(MetadataNamespaces.PADDING_LAYOUT_PARAMETERS) as PaddingLayoutMetadata;
if(_loc12_)
{
if(!isNaN(_loc12_.left))
{
_loc5_.x += _loc12_.left;
}
if(!isNaN(_loc12_.top))
{
_loc5_.y += _loc12_.top;
}
if(!isNaN(_loc12_.right) && !(_loc11_ & WIDTH))
{
_loc5_.width -= _loc12_.right + (_loc12_.left || 0);
}
if(!isNaN(_loc12_.bottom) && !(_loc11_ & HEIGHT))
{
_loc5_.height -= _loc12_.bottom + (_loc12_.top || 0);
}
}
if(_loc4_.scaleMode)
{
if(Boolean(!(_loc11_ & WIDTH || _loc11_ & HEIGHT)) && Boolean(param1.measuredWidth) && Boolean(param1.measuredHeight))
{
_loc16_ = ScaleModeUtils.getScaledSize(_loc4_.scaleMode,_loc5_.width,_loc5_.height,param1.measuredWidth,param1.measuredHeight);
_loc7_ = _loc5_.width - _loc16_.x;
_loc9_ = _loc5_.height - _loc16_.y;
_loc5_.width = _loc16_.x;
_loc5_.height = _loc16_.y;
}
}
if(this.layoutMode != LayoutMode.HORIZONTAL)
{
_loc7_ ||= param2 - (_loc5_.x || 0) - (_loc5_.width || 0) - _loc8_;
}
if(this.layoutMode != LayoutMode.VERTICAL)
{
_loc9_ ||= param3 - (_loc5_.y || 0) - (_loc5_.height || 0) - _loc10_;
}
if(_loc9_)
{
switch(_loc4_.verticalAlign)
{
case null:
case VerticalAlign.TOP:
break;
case VerticalAlign.MIDDLE:
_loc5_.y += _loc9_ / 2;
break;
case VerticalAlign.BOTTOM:
_loc5_.y += _loc9_;
}
}
if(_loc7_)
{
switch(_loc4_.horizontalAlign)
{
case null:
case HorizontalAlign.LEFT:
break;
case HorizontalAlign.CENTER:
_loc5_.x += _loc7_ / 2;
break;
case HorizontalAlign.RIGHT:
_loc5_.x += _loc7_;
}
}
if(_loc4_.snapToPixel)
{
_loc5_.x = Math.round(_loc5_.x);
_loc5_.y = Math.round(_loc5_.y);
_loc5_.width = Math.round(_loc5_.width);
_loc5_.height = Math.round(_loc5_.height);
}
if(this.layoutMode == LayoutMode.HORIZONTAL || this.layoutMode == LayoutMode.VERTICAL)
{
if(this.lastCalculatedBounds != null)
{
if(this.layoutMode == LayoutMode.HORIZONTAL)
{
_loc5_.x = this.lastCalculatedBounds.x + this.lastCalculatedBounds.width;
}
else
{
_loc5_.y = this.lastCalculatedBounds.y + this.lastCalculatedBounds.height;
}
}
this.lastCalculatedBounds = _loc5_;
}
return _loc5_;
}
override protected function calculateContainerSize(param1:Vector.<ILayoutTarget>) : Point
{
var _loc4_:BoxAttributesMetadata = null;
var _loc5_:Rectangle = null;
var _loc6_:Rectangle = null;
var _loc7_:Rectangle = null;
var _loc8_:ILayoutTarget = null;
var _loc2_:Point = new Point(NaN,NaN);
var _loc3_:AbsoluteLayoutMetadata = container.layoutMetadata.getValue(MetadataNamespaces.ABSOLUTE_LAYOUT_PARAMETERS) as AbsoluteLayoutMetadata;
if(_loc3_)
{
_loc2_.x = _loc3_.width;
_loc2_.y = _loc3_.height;
}
if(this.layoutMode != LayoutMode.NONE)
{
_loc4_ = new BoxAttributesMetadata();
container.layoutMetadata.addValue(MetadataNamespaces.BOX_LAYOUT_ATTRIBUTES,_loc4_);
}
if(isNaN(_loc2_.x) || isNaN(_loc2_.y) || this.layoutMode != LayoutMode.NONE)
{
_loc5_ = new Rectangle();
for each(_loc8_ in param1)
{
if(_loc8_.layoutMetadata.includeInLayout)
{
_loc6_ = this.calculateTargetBounds(_loc8_,_loc2_.x,_loc2_.y);
_loc6_.x = _loc6_.x || 0;
_loc6_.y = _loc6_.y || 0;
_loc6_.width = _loc6_.width || (_loc8_.measuredWidth || 0);
_loc6_.height = _loc6_.height || (_loc8_.measuredHeight || 0);
if(this.layoutMode == LayoutMode.HORIZONTAL)
{
if(!isNaN(_loc8_.layoutMetadata.percentWidth))
{
_loc4_.relativeSum += _loc8_.layoutMetadata.percentWidth;
}
else
{
_loc4_.absoluteSum += _loc6_.width;
}
if(_loc7_)
{
_loc6_.x = _loc7_.x + _loc7_.width;
}
_loc7_ = _loc6_;
}
else if(this.layoutMode == LayoutMode.VERTICAL)
{
if(!isNaN(_loc8_.layoutMetadata.percentHeight))
{
_loc4_.relativeSum += _loc8_.layoutMetadata.percentHeight;
}
else
{
_loc4_.absoluteSum += _loc6_.height;
}
if(_loc7_)
{
_loc6_.y = _loc7_.y + _loc7_.height;
}
_loc7_ = _loc6_;
}
_loc5_ = _loc5_.union(_loc6_);
}
}
_loc2_.x = _loc2_.x || (_loc3_ == null || isNaN(_loc3_.width) ? _loc5_.width : _loc3_.width);
_loc2_.y = _loc2_.y || (_loc3_ == null || isNaN(_loc3_.height) ? _loc5_.height : _loc3_.height);
}
return _loc2_;
}
}
}
@@ -0,0 +1,446 @@
package org.osmf.layout
{
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.utils.Dictionary;
import org.osmf.events.DisplayObjectEvent;
import org.osmf.metadata.Metadata;
import org.osmf.metadata.MetadataWatcher;
import org.osmf.utils.OSMFStrings;
public class LayoutRendererBase extends EventDispatcher
{
private static var cleaningRenderers:Boolean;
private static var dispatcher:DisplayObject = new Sprite();
private static var dirtyRenderers:Vector.<LayoutRendererBase> = new Vector.<LayoutRendererBase>();
private var _parent:LayoutRendererBase;
private var _container:ILayoutTarget;
private var layoutMetadata:LayoutMetadata;
private var layoutTargets:Vector.<ILayoutTarget> = new Vector.<ILayoutTarget>();
private var stagedDisplayObjects:Dictionary = new Dictionary(true);
private var _measuredWidth:Number;
private var _measuredHeight:Number;
private var dirty:Boolean;
private var cleaning:Boolean;
private var metaDataWatchers:Dictionary = new Dictionary();
public function LayoutRendererBase()
{
super();
}
private static function flagDirty(param1:LayoutRendererBase) : void
{
if(param1 == null || dirtyRenderers.indexOf(param1) != -1)
{
return;
}
dirtyRenderers.push(param1);
if(cleaningRenderers == false)
{
dispatcher.addEventListener(Event.EXIT_FRAME,onExitFrame);
}
}
private static function flagClean(param1:LayoutRendererBase) : void
{
var _loc2_:Number = dirtyRenderers.indexOf(param1);
if(_loc2_ != -1)
{
dirtyRenderers.splice(_loc2_,1);
}
}
private static function onExitFrame(param1:Event) : void
{
var _loc2_:LayoutRendererBase = null;
dispatcher.removeEventListener(Event.EXIT_FRAME,onExitFrame);
cleaningRenderers = true;
while(dirtyRenderers.length != 0)
{
_loc2_ = dirtyRenderers.shift();
if(_loc2_.parent == null)
{
_loc2_.validateNow();
}
else
{
_loc2_.dirty = false;
}
}
cleaningRenderers = false;
}
final public function get parent() : LayoutRendererBase
{
return this._parent;
}
final internal function setParent(param1:LayoutRendererBase) : void
{
this._parent = param1;
this.processParentChange(this._parent);
}
final public function get container() : ILayoutTarget
{
return this._container;
}
final public function set container(param1:ILayoutTarget) : void
{
var _loc2_:ILayoutTarget = null;
if(param1 != this._container)
{
_loc2_ = this._container;
if(_loc2_ != null)
{
this.reset();
_loc2_.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.UNSET_AS_LAYOUT_RENDERER_CONTAINER,false,false,this));
_loc2_.removeEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.invalidatingEventHandler);
}
this._container = param1;
if(this._container)
{
this.layoutMetadata = this._container.layoutMetadata;
this._container.addEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.invalidatingEventHandler,false,0,true);
this._container.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.SET_AS_LAYOUT_RENDERER_CONTAINER,false,false,this));
this.invalidate();
}
this.processContainerChange(_loc2_,param1);
}
}
final public function addTarget(param1:ILayoutTarget) : ILayoutTarget
{
var _loc4_:String = null;
var _loc5_:MetadataWatcher = null;
if(param1 == null)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
if(this.layoutTargets.indexOf(param1) != -1)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
param1.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.ADD_TO_LAYOUT_RENDERER,false,false,this));
var _loc2_:int = Math.abs(BinarySearch.search(this.layoutTargets,this.compareTargets,param1));
this.layoutTargets.splice(_loc2_,0,param1);
var _loc3_:Array = this.metaDataWatchers[param1] = new Array();
for each(_loc4_ in this.usedMetadatas)
{
_loc5_ = new MetadataWatcher(param1.layoutMetadata,_loc4_,null,this.targetMetadataChangeCallback);
_loc5_.watch();
_loc3_.push(_loc5_);
}
param1.addEventListener(DisplayObjectEvent.DISPLAY_OBJECT_CHANGE,this.invalidatingEventHandler);
param1.addEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.invalidatingEventHandler);
param1.addEventListener(LayoutTargetEvent.ADD_TO_LAYOUT_RENDERER,this.onTargetAddedToRenderer);
param1.addEventListener(LayoutTargetEvent.SET_AS_LAYOUT_RENDERER_CONTAINER,this.onTargetSetAsContainer);
this.invalidate();
this.processTargetAdded(param1);
return param1;
}
final public function removeTarget(param1:ILayoutTarget) : ILayoutTarget
{
var _loc2_:ILayoutTarget = null;
var _loc4_:MetadataWatcher = null;
if(param1 == null)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
var _loc3_:Number = this.layoutTargets.indexOf(param1);
if(_loc3_ != -1)
{
this.removeFromStage(param1);
_loc2_ = this.layoutTargets.splice(_loc3_,1)[0];
param1.removeEventListener(DisplayObjectEvent.DISPLAY_OBJECT_CHANGE,this.invalidatingEventHandler);
param1.removeEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.invalidatingEventHandler);
param1.removeEventListener(LayoutTargetEvent.ADD_TO_LAYOUT_RENDERER,this.onTargetAddedToRenderer);
param1.removeEventListener(LayoutTargetEvent.SET_AS_LAYOUT_RENDERER_CONTAINER,this.onTargetSetAsContainer);
for each(_loc4_ in this.metaDataWatchers[param1])
{
_loc4_.unwatch();
}
delete this.metaDataWatchers[param1];
this.processTargetRemoved(param1);
param1.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.REMOVE_FROM_LAYOUT_RENDERER,false,false,this));
this.invalidate();
return _loc2_;
}
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
final public function hasTarget(param1:ILayoutTarget) : Boolean
{
return this.layoutTargets.indexOf(param1) != -1;
}
final public function get measuredWidth() : Number
{
return this._measuredWidth;
}
final public function get measuredHeight() : Number
{
return this._measuredHeight;
}
final public function invalidate() : void
{
if(this.cleaning == false && this.dirty == false)
{
this.dirty = true;
if(this._parent != null)
{
this._parent.invalidate();
}
else
{
flagDirty(this);
}
}
}
final public function validateNow() : void
{
if(this._container == null || this.cleaning == true)
{
return;
}
if(this._parent)
{
this._parent.validateNow();
return;
}
this.cleaning = true;
this.measure();
this.layout(this._measuredWidth,this._measuredHeight);
this.cleaning = false;
}
internal function measure() : void
{
var _loc1_:ILayoutTarget = null;
var _loc2_:Point = null;
this.prepareTargets();
for each(_loc1_ in this.layoutTargets)
{
_loc1_.measure(true);
}
_loc2_ = this.calculateContainerSize(this.layoutTargets);
this._measuredWidth = _loc2_.x;
this._measuredHeight = _loc2_.y;
this._container.measure(false);
}
internal function layout(param1:Number, param2:Number) : void
{
var _loc3_:ILayoutTarget = null;
var _loc4_:Rectangle = null;
var _loc5_:DisplayObject = null;
this.processUpdateMediaDisplayBegin(this.layoutTargets);
this._container.layout(param1,param2,false);
for each(_loc3_ in this.layoutTargets)
{
_loc4_ = this.calculateTargetBounds(_loc3_,param1,param2);
_loc3_.layout(_loc4_.width,_loc4_.height,true);
_loc5_ = _loc3_.displayObject;
if(_loc5_)
{
_loc5_.x = _loc4_.x;
_loc5_.y = _loc4_.y;
}
}
this.dirty = false;
this.processUpdateMediaDisplayEnd();
}
protected function get usedMetadatas() : Vector.<String>
{
return new Vector.<String>();
}
protected function compareTargets(param1:ILayoutTarget, param2:ILayoutTarget) : Number
{
return 0;
}
protected function processContainerChange(param1:ILayoutTarget, param2:ILayoutTarget) : void
{
}
protected function processTargetAdded(param1:ILayoutTarget) : void
{
}
protected function processTargetRemoved(param1:ILayoutTarget) : void
{
}
protected function processStagedTarget(param1:ILayoutTarget) : void
{
}
protected function processUnstagedTarget(param1:ILayoutTarget) : void
{
}
protected function processUpdateMediaDisplayBegin(param1:Vector.<ILayoutTarget>) : void
{
}
protected function processUpdateMediaDisplayEnd() : void
{
}
protected function updateTargetOrder(param1:ILayoutTarget) : void
{
var _loc2_:int = this.layoutTargets.indexOf(param1);
if(_loc2_ != -1)
{
this.layoutTargets.splice(_loc2_,1);
_loc2_ = Math.abs(BinarySearch.search(this.layoutTargets,this.compareTargets,param1));
this.layoutTargets.splice(_loc2_,0,param1);
}
}
protected function calculateTargetBounds(param1:ILayoutTarget, param2:Number, param3:Number) : Rectangle
{
return new Rectangle();
}
protected function calculateContainerSize(param1:Vector.<ILayoutTarget>) : Point
{
return new Point();
}
protected function processParentChange(param1:LayoutRendererBase) : void
{
}
private function reset() : void
{
var _loc1_:ILayoutTarget = null;
for each(_loc1_ in this.layoutTargets)
{
this.removeTarget(_loc1_);
}
if(this._container)
{
this._container.removeEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.invalidatingEventHandler);
this.validateNow();
}
this._container = null;
this.layoutMetadata = null;
}
private function targetMetadataChangeCallback(param1:Metadata) : void
{
this.invalidate();
}
private function invalidatingEventHandler(param1:Event) : void
{
this.invalidate();
}
private function onTargetAddedToRenderer(param1:LayoutTargetEvent) : void
{
var _loc2_:ILayoutTarget = null;
if(param1.layoutRenderer != this)
{
_loc2_ = param1.target as ILayoutTarget;
if(this.hasTarget(_loc2_))
{
this.removeTarget(_loc2_);
}
}
}
private function onTargetSetAsContainer(param1:LayoutTargetEvent) : void
{
var _loc2_:ILayoutTarget = null;
if(param1.layoutRenderer != this)
{
_loc2_ = param1.target as ILayoutTarget;
if(this.container == _loc2_)
{
this.container = null;
}
}
}
private function prepareTargets() : void
{
var _loc2_:ILayoutTarget = null;
var _loc3_:DisplayObject = null;
var _loc1_:int = 0;
for each(_loc2_ in this.layoutTargets)
{
_loc3_ = _loc2_.displayObject;
if(_loc3_)
{
this.addToStage(_loc2_,_loc2_.displayObject,_loc1_);
_loc1_++;
}
else
{
this.removeFromStage(_loc2_);
}
}
}
private function addToStage(param1:ILayoutTarget, param2:DisplayObject, param3:Number) : void
{
var _loc4_:DisplayObject = this.stagedDisplayObjects[param1];
if(_loc4_ == param2)
{
this._container.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.SET_CHILD_INDEX,false,false,this,param1,_loc4_,param3));
}
else
{
if(_loc4_ != null)
{
this._container.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.REMOVE_CHILD,false,false,this,param1,_loc4_));
}
this.stagedDisplayObjects[param1] = param2;
this._container.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.ADD_CHILD_AT,false,false,this,param1,param2,param3));
if(_loc4_ == null)
{
this.processStagedTarget(param1);
}
}
}
private function removeFromStage(param1:ILayoutTarget) : void
{
var _loc2_:DisplayObject = this.stagedDisplayObjects[param1];
if(_loc2_ != null)
{
delete this.stagedDisplayObjects[param1];
this._container.dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.REMOVE_CHILD,false,false,this,param1,_loc2_));
}
}
}
}
@@ -0,0 +1,66 @@
package org.osmf.layout
{
import flash.display.DisplayObject;
import flash.events.Event;
public class LayoutTargetEvent extends Event
{
public static const SET_AS_LAYOUT_RENDERER_CONTAINER:String = "setAsLayoutRendererContainer";
public static const UNSET_AS_LAYOUT_RENDERER_CONTAINER:String = "unsetAsLayoutRendererContainer";
public static const ADD_TO_LAYOUT_RENDERER:String = "addToLayoutRenderer";
public static const REMOVE_FROM_LAYOUT_RENDERER:String = "removeFromLayoutRenderer";
public static const ADD_CHILD_AT:String = "addChildAt";
public static const REMOVE_CHILD:String = "removeChild";
public static const SET_CHILD_INDEX:String = "setChildIndex";
private var _layoutRenderer:LayoutRendererBase;
private var _layoutTarget:ILayoutTarget;
private var _displayObject:DisplayObject;
private var _index:int;
public function LayoutTargetEvent(param1:String, param2:Boolean = false, param3:Boolean = false, param4:LayoutRendererBase = null, param5:ILayoutTarget = null, param6:DisplayObject = null, param7:int = -1)
{
this._layoutRenderer = param4;
this._layoutTarget = param5;
this._displayObject = param6;
this._index = param7;
super(param1,param2,param3);
}
public function get layoutRenderer() : LayoutRendererBase
{
return this._layoutRenderer;
}
public function get layoutTarget() : ILayoutTarget
{
return this._layoutTarget;
}
public function get displayObject() : DisplayObject
{
return this._displayObject;
}
public function get index() : int
{
return this._index;
}
override public function clone() : Event
{
return new LayoutTargetEvent(type,bubbles,cancelable,this._layoutRenderer,this._layoutTarget,this._displayObject,this._index);
}
}
}
@@ -0,0 +1,62 @@
package org.osmf.layout
{
internal class LayoutTargetRenderers
{
public var containerRenderer:LayoutRendererBase;
public var parentRenderer:LayoutRendererBase;
public function LayoutTargetRenderers(param1:ILayoutTarget)
{
super();
param1.addEventListener(LayoutTargetEvent.ADD_TO_LAYOUT_RENDERER,this.onAddedToLayoutRenderer);
param1.addEventListener(LayoutTargetEvent.REMOVE_FROM_LAYOUT_RENDERER,this.onRemovedFromLayoutRenderer);
param1.addEventListener(LayoutTargetEvent.SET_AS_LAYOUT_RENDERER_CONTAINER,this.onSetAsLayoutRendererContainer);
param1.addEventListener(LayoutTargetEvent.UNSET_AS_LAYOUT_RENDERER_CONTAINER,this.onUnsetAsLayoutRendererContainer);
}
private function onSetAsLayoutRendererContainer(param1:LayoutTargetEvent) : void
{
if(this.containerRenderer != param1.layoutRenderer)
{
this.containerRenderer = param1.layoutRenderer;
this.containerRenderer.setParent(this.parentRenderer);
}
}
private function onUnsetAsLayoutRendererContainer(param1:LayoutTargetEvent) : void
{
if(this.containerRenderer != null && this.containerRenderer == param1.layoutRenderer)
{
this.containerRenderer.setParent(null);
this.containerRenderer = null;
}
}
private function onAddedToLayoutRenderer(param1:LayoutTargetEvent) : void
{
if(this.parentRenderer != param1.layoutRenderer)
{
this.parentRenderer = param1.layoutRenderer;
if(this.containerRenderer)
{
this.containerRenderer.setParent(this.parentRenderer);
}
}
}
private function onRemovedFromLayoutRenderer(param1:LayoutTargetEvent) : void
{
if(this.parentRenderer == param1.layoutRenderer)
{
this.parentRenderer = null;
if(this.containerRenderer)
{
this.containerRenderer.setParent(null);
}
}
}
}
}
@@ -0,0 +1,134 @@
package org.osmf.layout
{
import flash.display.DisplayObject;
import flash.display.Sprite;
import org.osmf.events.DisplayObjectEvent;
public class LayoutTargetSprite extends Sprite implements ILayoutTarget
{
private var _layoutMetadata:LayoutMetadata;
private var _measuredWidth:Number = NaN;
private var _measuredHeight:Number = NaN;
private var renderers:LayoutTargetRenderers = new LayoutTargetRenderers(this);
public function LayoutTargetSprite(param1:LayoutMetadata = null)
{
this._layoutMetadata = param1 || new LayoutMetadata();
addEventListener(LayoutTargetEvent.ADD_CHILD_AT,this.onAddChildAt);
addEventListener(LayoutTargetEvent.SET_CHILD_INDEX,this.onSetChildIndex);
addEventListener(LayoutTargetEvent.REMOVE_CHILD,this.onRemoveChild);
mouseEnabled = true;
mouseChildren = true;
super();
}
public function get displayObject() : DisplayObject
{
return this;
}
public function get layoutMetadata() : LayoutMetadata
{
return this._layoutMetadata;
}
public function get measuredWidth() : Number
{
return this._measuredWidth;
}
public function get measuredHeight() : Number
{
return this._measuredHeight;
}
public function measure(param1:Boolean = true) : void
{
var _loc2_:Number = NaN;
var _loc3_:Number = NaN;
var _loc4_:DisplayObjectEvent = null;
if(param1 && Boolean(this.renderers.containerRenderer))
{
this.renderers.containerRenderer.measure();
}
if(this.renderers.containerRenderer)
{
_loc2_ = this.renderers.containerRenderer.measuredWidth;
_loc3_ = this.renderers.containerRenderer.measuredHeight;
}
else
{
_loc2_ = super.width / scaleX;
_loc3_ = super.height / scaleY;
}
if(_loc2_ != this._measuredWidth || _loc3_ != this._measuredHeight)
{
_loc4_ = new DisplayObjectEvent(DisplayObjectEvent.MEDIA_SIZE_CHANGE,false,false,null,null,this._measuredWidth,this._measuredHeight,_loc2_,_loc3_);
this._measuredWidth = _loc2_;
this._measuredHeight = _loc3_;
dispatchEvent(_loc4_);
}
}
public function layout(param1:Number, param2:Number, param3:Boolean = true) : void
{
if(this.renderers.containerRenderer == null)
{
super.width = param1;
super.height = param2;
}
else if(param3)
{
this.renderers.containerRenderer.layout(param1,param2);
}
}
public function validateNow() : void
{
if(this.renderers.containerRenderer)
{
this.renderers.containerRenderer.validateNow();
}
}
protected function onAddChildAt(param1:LayoutTargetEvent) : void
{
addChildAt(param1.displayObject,param1.index);
}
protected function onRemoveChild(param1:LayoutTargetEvent) : void
{
removeChild(param1.displayObject);
}
protected function onSetChildIndex(param1:LayoutTargetEvent) : void
{
setChildIndex(param1.displayObject,param1.index);
}
override public function set width(param1:Number) : void
{
this._layoutMetadata.width = param1;
}
override public function get width() : Number
{
return this._measuredWidth;
}
override public function set height(param1:Number) : void
{
this._layoutMetadata.height = param1;
}
override public function get height() : Number
{
return this._measuredHeight;
}
}
}
@@ -0,0 +1,229 @@
package org.osmf.layout
{
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.errors.IllegalOperationError;
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
import org.osmf.events.DisplayObjectEvent;
import org.osmf.events.MediaElementEvent;
import org.osmf.media.MediaElement;
import org.osmf.traits.DisplayObjectTrait;
import org.osmf.traits.MediaTraitType;
import org.osmf.utils.OSMFStrings;
public class MediaElementLayoutTarget extends EventDispatcher implements ILayoutTarget
{
private static const layoutTargets:Dictionary = new Dictionary(true);
private var _mediaElement:MediaElement;
private var _layoutMetadata:LayoutMetadata;
private var displayObjectTrait:DisplayObjectTrait;
private var _displayObject:DisplayObject;
private var renderers:LayoutTargetRenderers;
public function MediaElementLayoutTarget(param1:MediaElement, param2:Class)
{
super();
if(param2 != ConstructorLock)
{
throw new IllegalOperationError(OSMFStrings.getString(OSMFStrings.ILLEGAL_CONSTRUCTOR_INVOCATION));
}
this._mediaElement = param1;
this._mediaElement.addEventListener(MediaElementEvent.TRAIT_ADD,this.onMediaElementTraitsChange);
this._mediaElement.addEventListener(MediaElementEvent.TRAIT_REMOVE,this.onMediaElementTraitsChange);
this._mediaElement.addEventListener(MediaElementEvent.METADATA_ADD,this.onMetadataAdd);
this._mediaElement.addEventListener(MediaElementEvent.METADATA_REMOVE,this.onMetadataRemove);
this.renderers = new LayoutTargetRenderers(this);
this._layoutMetadata = this._mediaElement.getMetadata(LayoutMetadata.LAYOUT_NAMESPACE) as LayoutMetadata;
addEventListener(LayoutTargetEvent.ADD_CHILD_AT,this.onAddChildAt);
addEventListener(LayoutTargetEvent.SET_CHILD_INDEX,this.onSetChildIndex);
addEventListener(LayoutTargetEvent.REMOVE_CHILD,this.onRemoveChild);
this.onMediaElementTraitsChange();
}
public static function getInstance(param1:MediaElement) : MediaElementLayoutTarget
{
var _loc2_:* = undefined;
for(_loc2_ in layoutTargets)
{
if(_loc2_.mediaElement == param1)
{
break;
}
_loc2_ = null;
}
if(_loc2_ == null)
{
_loc2_ = new MediaElementLayoutTarget(param1,ConstructorLock);
layoutTargets[_loc2_] = true;
}
return _loc2_;
}
public function get mediaElement() : MediaElement
{
return this._mediaElement;
}
public function get layoutMetadata() : LayoutMetadata
{
if(this._layoutMetadata == null)
{
this._layoutMetadata = new LayoutMetadata();
this._mediaElement.addMetadata(LayoutMetadata.LAYOUT_NAMESPACE,this._layoutMetadata);
}
return this._layoutMetadata;
}
public function get displayObject() : DisplayObject
{
return this._displayObject;
}
public function get measuredWidth() : Number
{
return this.displayObjectTrait ? this.displayObjectTrait.mediaWidth : NaN;
}
public function get measuredHeight() : Number
{
return this.displayObjectTrait ? this.displayObjectTrait.mediaHeight : NaN;
}
public function measure(param1:Boolean = true) : void
{
if(this._displayObject is ILayoutTarget)
{
ILayoutTarget(this._displayObject).measure(param1);
}
}
public function layout(param1:Number, param2:Number, param3:Boolean = true) : void
{
if(this._displayObject is ILayoutTarget)
{
ILayoutTarget(this._displayObject).layout(param1,param2,param3);
}
else if(this._displayObject != null && this.renderers.containerRenderer == null)
{
this._displayObject.width = param1;
this._displayObject.height = param2;
}
}
private function onMediaElementTraitsChange(param1:MediaElementEvent = null) : void
{
var _loc2_:DisplayObjectTrait = null;
if(param1 == null || Boolean(param1) && Boolean(param1.traitType == MediaTraitType.DISPLAY_OBJECT))
{
_loc2_ = Boolean(param1) && param1.type == MediaElementEvent.TRAIT_REMOVE ? null : this._mediaElement.getTrait(MediaTraitType.DISPLAY_OBJECT) as DisplayObjectTrait;
if(_loc2_ != this.displayObjectTrait)
{
if(this.displayObjectTrait)
{
this.displayObjectTrait.removeEventListener(DisplayObjectEvent.DISPLAY_OBJECT_CHANGE,this.onDisplayObjectTraitDisplayObjecChange);
this.displayObjectTrait.removeEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.onDisplayObjectTraitMediaSizeChange);
}
this.displayObjectTrait = _loc2_;
if(this.displayObjectTrait)
{
this.displayObjectTrait.addEventListener(DisplayObjectEvent.DISPLAY_OBJECT_CHANGE,this.onDisplayObjectTraitDisplayObjecChange);
this.displayObjectTrait.addEventListener(DisplayObjectEvent.MEDIA_SIZE_CHANGE,this.onDisplayObjectTraitMediaSizeChange);
}
this.updateDisplayObject(this.displayObjectTrait ? this.displayObjectTrait.displayObject : null);
}
}
}
private function onMetadataAdd(param1:MediaElementEvent) : void
{
if(param1.namespaceURL == LayoutMetadata.LAYOUT_NAMESPACE)
{
this._layoutMetadata = param1.metadata as LayoutMetadata;
}
}
private function onMetadataRemove(param1:MediaElementEvent) : void
{
if(param1.namespaceURL == LayoutMetadata.LAYOUT_NAMESPACE)
{
this._layoutMetadata = null;
}
}
private function updateDisplayObject(param1:DisplayObject) : void
{
var _loc2_:DisplayObject = this._displayObject;
if(param1 != this.displayObject)
{
this._displayObject = param1;
dispatchEvent(new DisplayObjectEvent(DisplayObjectEvent.DISPLAY_OBJECT_CHANGE,false,false,_loc2_,param1));
}
if(param1 is ILayoutTarget && Boolean(this.renderers.parentRenderer))
{
ILayoutTarget(param1).dispatchEvent(new LayoutTargetEvent(LayoutTargetEvent.ADD_TO_LAYOUT_RENDERER,false,false,this.renderers.parentRenderer));
}
}
private function onDisplayObjectTraitDisplayObjecChange(param1:DisplayObjectEvent) : void
{
this.updateDisplayObject(param1.newDisplayObject);
}
private function onDisplayObjectTraitMediaSizeChange(param1:DisplayObjectEvent) : void
{
dispatchEvent(param1.clone());
}
private function onAddChildAt(param1:LayoutTargetEvent) : void
{
if(this._displayObject is ILayoutTarget)
{
ILayoutTarget(this._displayObject).dispatchEvent(param1.clone());
}
else if(this._displayObject is DisplayObjectContainer)
{
DisplayObjectContainer(this._displayObject).addChildAt(param1.displayObject,param1.index);
}
}
private function onRemoveChild(param1:LayoutTargetEvent) : void
{
if(this._displayObject is ILayoutTarget)
{
ILayoutTarget(this._displayObject).dispatchEvent(param1.clone());
}
else if(this._displayObject is DisplayObjectContainer)
{
DisplayObjectContainer(this._displayObject).removeChild(param1.displayObject);
}
}
private function onSetChildIndex(param1:LayoutTargetEvent) : void
{
if(this._displayObject is ILayoutTarget)
{
ILayoutTarget(this._displayObject).dispatchEvent(param1.clone());
}
else if(this._displayObject is DisplayObjectContainer)
{
DisplayObjectContainer(this._displayObject).setChildIndex(param1.displayObject,param1.index);
}
}
}
}
class ConstructorLock
{
public function ConstructorLock()
{
super();
}
}
@@ -0,0 +1,120 @@
package org.osmf.layout
{
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.NonSynthesizingMetadata;
internal class PaddingLayoutMetadata extends NonSynthesizingMetadata
{
public static const LEFT:String = "left";
public static const TOP:String = "top";
public static const RIGHT:String = "right";
public static const BOTTOM:String = "bottom";
private var _left:Number;
private var _top:Number;
private var _right:Number;
private var _bottom:Number;
public function PaddingLayoutMetadata()
{
super();
}
override public function getValue(param1:String) : *
{
if(param1 == null)
{
return undefined;
}
if(param1 == LEFT)
{
return this.left;
}
if(param1 == TOP)
{
return this.top;
}
if(param1 == RIGHT)
{
return this.right;
}
if(param1 == BOTTOM)
{
return this.bottom;
}
return undefined;
}
public function get left() : Number
{
return this._left;
}
public function set left(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._left != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,LEFT,param1,this._left);
this._left = param1;
dispatchEvent(_loc2_);
}
}
public function get top() : Number
{
return this._top;
}
public function set top(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._top != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,TOP,param1,this._top);
this._top = param1;
dispatchEvent(_loc2_);
}
}
public function get right() : Number
{
return this._right;
}
public function set right(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._right != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,RIGHT,param1,this._right);
this._right = param1;
dispatchEvent(_loc2_);
}
}
public function get bottom() : Number
{
return this._bottom;
}
public function set bottom(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._bottom != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,BOTTOM,param1,this._bottom);
this._bottom = param1;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,120 @@
package org.osmf.layout
{
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.NonSynthesizingMetadata;
internal class RelativeLayoutMetadata extends NonSynthesizingMetadata
{
public static const X:String = "x";
public static const Y:String = "y";
public static const WIDTH:String = "width";
public static const HEIGHT:String = "height";
private var _x:Number;
private var _y:Number;
private var _width:Number;
private var _height:Number;
public function RelativeLayoutMetadata()
{
super();
}
override public function getValue(param1:String) : *
{
if(param1 == null)
{
return undefined;
}
if(param1 == X)
{
return this.x;
}
if(param1 == Y)
{
return this.y;
}
if(param1 == WIDTH)
{
return this.width;
}
if(param1 == HEIGHT)
{
return this.height;
}
return undefined;
}
public function get x() : Number
{
return this._x;
}
public function set x(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._x != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,X,param1,this._x);
this._x = param1;
dispatchEvent(_loc2_);
}
}
public function get y() : Number
{
return this._y;
}
public function set y(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._y != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,Y,param1,this._y);
this._y = param1;
dispatchEvent(_loc2_);
}
}
public function get width() : Number
{
return this._width;
}
public function set width(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._width != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,WIDTH,param1,this._width);
this._width = param1;
dispatchEvent(_loc2_);
}
}
public function get height() : Number
{
return this._height;
}
public function set height(param1:Number) : void
{
var _loc2_:MetadataEvent = null;
if(this._height != param1)
{
_loc2_ = new MetadataEvent(MetadataEvent.VALUE_CHANGE,false,false,HEIGHT,param1,this._height);
this._height = param1;
dispatchEvent(_loc2_);
}
}
}
}
@@ -0,0 +1,20 @@
package org.osmf.layout
{
public final class ScaleMode
{
public static const NONE:String = "none";
public static const STRETCH:String = "stretch";
public static const LETTERBOX:String = "letterbox";
public static const ZOOM:String = "zoom";
public function ScaleMode()
{
super();
}
}
}
@@ -0,0 +1,43 @@
package org.osmf.layout
{
import flash.geom.Point;
internal class ScaleModeUtils
{
public function ScaleModeUtils()
{
super();
}
public static function getScaledSize(param1:String, param2:Number, param3:Number, param4:Number, param5:Number) : Point
{
var _loc6_:Point = null;
var _loc7_:Number = NaN;
var _loc8_:Number = NaN;
switch(param1)
{
case ScaleMode.ZOOM:
case ScaleMode.LETTERBOX:
_loc7_ = param2 / param3;
_loc8_ = (param4 || param2) / (param5 || param3);
if(param1 == ScaleMode.ZOOM && _loc8_ < _loc7_ || param1 == ScaleMode.LETTERBOX && _loc8_ > _loc7_)
{
_loc6_ = new Point(param2,param2 / _loc8_);
}
else
{
_loc6_ = new Point(param3 * _loc8_,param3);
}
break;
case ScaleMode.STRETCH:
_loc6_ = new Point(param2,param3);
break;
case ScaleMode.NONE:
_loc6_ = new Point(param4 || param2,param5 || param3);
}
return _loc6_;
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.layout
{
public final class VerticalAlign
{
public static const TOP:String = "top";
public static const MIDDLE:String = "middle";
public static const BOTTOM:String = "bottom";
public function VerticalAlign()
{
super();
}
}
}
@@ -0,0 +1,99 @@
package org.osmf.media
{
import org.osmf.elements.AudioElement;
import org.osmf.elements.F4MElement;
import org.osmf.elements.F4MLoader;
import org.osmf.elements.ImageElement;
import org.osmf.elements.ImageLoader;
import org.osmf.elements.SWFElement;
import org.osmf.elements.SWFLoader;
import org.osmf.elements.SoundLoader;
import org.osmf.elements.VideoElement;
import org.osmf.net.MulticastNetLoader;
import org.osmf.net.NetLoader;
import org.osmf.net.dvr.DVRCastNetLoader;
import org.osmf.net.httpstreaming.HTTPStreamingNetLoader;
import org.osmf.net.rtmpstreaming.RTMPDynamicStreamingNetLoader;
public class DefaultMediaFactory extends MediaFactory
{
private var rtmpStreamingNetLoader:RTMPDynamicStreamingNetLoader;
private var f4mLoader:F4MLoader;
private var dvrCastLoader:DVRCastNetLoader;
private var netLoader:NetLoader;
private var imageLoader:ImageLoader;
private var swfLoader:SWFLoader;
private var soundLoader:SoundLoader;
private var httpStreamingNetLoader:HTTPStreamingNetLoader;
private var multicastLoader:MulticastNetLoader;
public function DefaultMediaFactory()
{
super();
this.init();
}
private function init() : void
{
this.f4mLoader = new F4MLoader(this);
addItem(new MediaFactoryItem("org.osmf.elements.f4m",this.f4mLoader.canHandleResource,function():MediaElement
{
return new F4MElement(null,f4mLoader);
}));
this.dvrCastLoader = new DVRCastNetLoader();
addItem(new MediaFactoryItem("org.osmf.elements.video.dvr.dvrcast",this.dvrCastLoader.canHandleResource,function():MediaElement
{
return new VideoElement(null,dvrCastLoader);
}));
this.httpStreamingNetLoader = new HTTPStreamingNetLoader();
addItem(new MediaFactoryItem("org.osmf.elements.video.httpstreaming",this.httpStreamingNetLoader.canHandleResource,function():MediaElement
{
return new VideoElement(null,httpStreamingNetLoader);
}));
this.multicastLoader = new MulticastNetLoader();
addItem(new MediaFactoryItem("org.osmf.elements.video.rtmfp.multicast",this.multicastLoader.canHandleResource,function():MediaElement
{
return new VideoElement(null,multicastLoader);
}));
this.rtmpStreamingNetLoader = new RTMPDynamicStreamingNetLoader();
addItem(new MediaFactoryItem("org.osmf.elements.video.rtmpdynamicStreaming",this.rtmpStreamingNetLoader.canHandleResource,function():MediaElement
{
return new VideoElement(null,rtmpStreamingNetLoader);
}));
this.netLoader = new NetLoader();
addItem(new MediaFactoryItem("org.osmf.elements.video",this.netLoader.canHandleResource,function():MediaElement
{
return new VideoElement(null,netLoader);
}));
this.soundLoader = new SoundLoader();
addItem(new MediaFactoryItem("org.osmf.elements.audio",this.soundLoader.canHandleResource,function():MediaElement
{
return new AudioElement(null,soundLoader);
}));
addItem(new MediaFactoryItem("org.osmf.elements.audio.streaming",this.netLoader.canHandleResource,function():MediaElement
{
return new AudioElement(null,netLoader);
}));
this.imageLoader = new ImageLoader();
addItem(new MediaFactoryItem("org.osmf.elements.image",this.imageLoader.canHandleResource,function():MediaElement
{
return new ImageElement(null,imageLoader);
}));
this.swfLoader = new SWFLoader();
addItem(new MediaFactoryItem("org.osmf.elements.swf",this.swfLoader.canHandleResource,function():MediaElement
{
return new SWFElement(null,swfLoader);
}));
}
}
}
@@ -0,0 +1,49 @@
package org.osmf.media
{
import org.osmf.traits.MediaTraitBase;
import org.osmf.utils.OSMFStrings;
public class DefaultTraitResolver extends MediaTraitResolver
{
private var defaultTrait:MediaTraitBase;
private var trait:MediaTraitBase;
public function DefaultTraitResolver(param1:String, param2:MediaTraitBase)
{
super(param1);
if(param2 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
if(param2.traitType != param1)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
this.defaultTrait = param2;
setResolvedTrait(param2);
}
override protected function processAddTrait(param1:MediaTraitBase) : void
{
if(this.trait == null)
{
setResolvedTrait(this.trait = param1);
}
}
override protected function processRemoveTrait(param1:MediaTraitBase) : MediaTraitBase
{
var _loc2_:MediaTraitBase = null;
if(Boolean(param1) && param1 == this.trait)
{
_loc2_ = this.trait;
this.trait = null;
setResolvedTrait(this.defaultTrait);
}
return _loc2_;
}
}
}
@@ -0,0 +1,118 @@
package org.osmf.media
{
import org.osmf.events.LoadEvent;
import org.osmf.traits.LoadState;
import org.osmf.traits.LoadTrait;
import org.osmf.traits.LoaderBase;
import org.osmf.traits.MediaTraitType;
public class LoadableElementBase extends MediaElement
{
private var _loader:LoaderBase;
public function LoadableElementBase(param1:MediaResourceBase = null, param2:LoaderBase = null)
{
super();
this._loader = param2;
this.resource = param1;
}
override public function set resource(param1:MediaResourceBase) : void
{
super.resource = param1;
this.updateLoadTrait();
}
final protected function get loader() : LoaderBase
{
return this._loader;
}
final protected function set loader(param1:LoaderBase) : void
{
this._loader = param1;
}
protected function createLoadTrait(param1:MediaResourceBase, param2:LoaderBase) : LoadTrait
{
return new LoadTrait(this._loader,param1);
}
protected function processLoadingState() : void
{
}
protected function processReadyState() : void
{
}
protected function processUnloadingState() : void
{
}
protected function getLoaderForResource(param1:MediaResourceBase, param2:Vector.<LoaderBase>) : LoaderBase
{
var _loc4_:Boolean = false;
var _loc5_:LoaderBase = null;
var _loc3_:LoaderBase = this.loader;
if(param1 != null && (this.loader == null || this.loader.canHandleResource(param1) == false))
{
_loc4_ = false;
for each(_loc5_ in param2)
{
if(this.loader == null || this.loader != _loc5_)
{
if(_loc5_.canHandleResource(param1))
{
_loc3_ = _loc5_;
break;
}
}
}
if(_loc3_ == null && param2 != null)
{
_loc3_ = param2[param2.length - 1];
}
}
return _loc3_;
}
private function onLoadStateChange(param1:LoadEvent) : void
{
if(param1.loadState == LoadState.LOADING)
{
this.processLoadingState();
}
else if(param1.loadState == LoadState.READY)
{
this.processReadyState();
}
else if(param1.loadState == LoadState.UNLOADING)
{
this.processUnloadingState();
}
}
private function updateLoadTrait() : void
{
var _loc1_:LoadTrait = getTrait(MediaTraitType.LOAD) as LoadTrait;
if(_loc1_ != null)
{
if(_loc1_.loadState == LoadState.READY)
{
_loc1_.unload();
}
_loc1_.removeEventListener(LoadEvent.LOAD_STATE_CHANGE,this.onLoadStateChange);
removeTrait(MediaTraitType.LOAD);
}
if(this.loader != null)
{
_loc1_ = this.createLoadTrait(resource,this.loader);
_loc1_.addEventListener(LoadEvent.LOAD_STATE_CHANGE,this.onLoadStateChange,false,10);
addTrait(MediaTraitType.LOAD,_loc1_);
}
}
}
}
@@ -0,0 +1,282 @@
package org.osmf.media
{
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
import org.osmf.containers.IMediaContainer;
import org.osmf.events.ContainerChangeEvent;
import org.osmf.events.MediaElementEvent;
import org.osmf.events.MediaErrorEvent;
import org.osmf.events.MetadataEvent;
import org.osmf.metadata.Metadata;
import org.osmf.traits.MediaTraitBase;
import org.osmf.utils.OSMFStrings;
public class MediaElement extends EventDispatcher
{
private var traits:Dictionary = new Dictionary();
private var traitResolvers:Dictionary = new Dictionary();
private var unresolvedTraits:Dictionary = new Dictionary();
private var _traitTypes:Vector.<String> = new Vector.<String>();
private var _resource:MediaResourceBase;
private var _metadata:Metadata;
private var _container:IMediaContainer;
public function MediaElement()
{
super();
this._metadata = this.createMetadata();
this._metadata.addEventListener(MetadataEvent.VALUE_ADD,this.onMetadataValueAdd);
this._metadata.addEventListener(MetadataEvent.VALUE_REMOVE,this.onMetadataValueRemove);
this._metadata.addEventListener(MetadataEvent.VALUE_CHANGE,this.onMetadataValueChange);
this.setupTraitResolvers();
this.setupTraits();
addEventListener(ContainerChangeEvent.CONTAINER_CHANGE,this.onContainerChange,false,Number.MAX_VALUE);
}
public function get traitTypes() : Vector.<String>
{
return this._traitTypes.concat();
}
public function hasTrait(param1:String) : Boolean
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this.traits[param1] != null;
}
public function getTrait(param1:String) : MediaTraitBase
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this.traits[param1];
}
public function get resource() : MediaResourceBase
{
return this._resource;
}
public function set resource(param1:MediaResourceBase) : void
{
this._resource = param1;
}
public function get container() : IMediaContainer
{
return this._container;
}
public function addMetadata(param1:String, param2:Metadata) : void
{
if(param1 == null || param2 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
this.metadata.addValue(param1,param2);
}
public function removeMetadata(param1:String) : Metadata
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
return this.metadata.removeValue(param1) as Metadata;
}
public function getMetadata(param1:String) : Metadata
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
return this.metadata.getValue(param1) as Metadata;
}
public function get metadataNamespaceURLs() : Vector.<String>
{
return this.metadata.keys;
}
protected function createMetadata() : Metadata
{
return new Metadata();
}
public function get metadata() : Metadata
{
return this._metadata;
}
protected function addTrait(param1:String, param2:MediaTraitBase) : void
{
if(param1 == null || param2 == null || param1 != param2.traitType)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
var _loc3_:MediaTraitResolver = this.traitResolvers[param1];
if(_loc3_ != null)
{
_loc3_.addTrait(param2);
}
else
{
this.setLocalTrait(param1,param2);
}
}
protected function removeTrait(param1:String) : MediaTraitBase
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
var _loc2_:MediaTraitBase = this.traits[param1];
var _loc3_:MediaTraitResolver = this.traitResolvers[param1];
if(_loc3_ != null)
{
return _loc3_.removeTrait(_loc2_);
}
return this.setLocalTrait(param1,null);
}
final protected function addTraitResolver(param1:String, param2:MediaTraitResolver) : void
{
var _loc3_:MediaTraitBase = null;
if(param2 == null || param2.type != param1)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
if(this.traitResolvers[param1] == null)
{
this.unresolvedTraits[param1] = this.traits[param1];
this.traitResolvers[param1] = param2;
_loc3_ = this.traits[param1];
if(_loc3_)
{
param2.addTrait(_loc3_);
}
this.processResolvedTraitChange(param1,param2.resolvedTrait);
param2.addEventListener(Event.CHANGE,this.onTraitResolverChange);
return;
}
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.TRAIT_RESOLVER_ALREADY_ADDED));
}
final protected function removeTraitResolver(param1:String) : MediaTraitResolver
{
if(param1 == null || this.traitResolvers[param1] == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
var _loc2_:MediaTraitResolver = this.traitResolvers[param1];
_loc2_.removeEventListener(Event.CHANGE,this.onTraitResolverChange);
delete this.traitResolvers[param1];
var _loc3_:MediaTraitBase = this.unresolvedTraits[param1];
if(_loc3_ != this.traits[param1])
{
this.setLocalTrait(param1,_loc3_);
}
delete this.unresolvedTraits[param1];
return _loc2_;
}
final protected function getTraitResolver(param1:String) : MediaTraitResolver
{
return this.traitResolvers[param1];
}
protected function setupTraitResolvers() : void
{
}
protected function setupTraits() : void
{
}
private function onMediaError(param1:MediaErrorEvent) : void
{
dispatchEvent(param1.clone());
}
private function setLocalTrait(param1:String, param2:MediaTraitBase) : MediaTraitBase
{
var _loc3_:MediaTraitBase = this.traits[param1];
if(param2 == null)
{
if(_loc3_ != null)
{
_loc3_.removeEventListener(MediaErrorEvent.MEDIA_ERROR,this.onMediaError);
_loc3_.dispose();
dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_REMOVE,false,false,param1));
this._traitTypes.splice(this._traitTypes.indexOf(param1),1);
delete this.traits[param1];
}
}
else if(_loc3_ == null)
{
this.traits[param1] = _loc3_ = param2;
this._traitTypes.push(param1);
_loc3_.addEventListener(MediaErrorEvent.MEDIA_ERROR,this.onMediaError);
dispatchEvent(new MediaElementEvent(MediaElementEvent.TRAIT_ADD,false,false,param1));
}
else if(_loc3_ != param2)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.TRAIT_INSTANCE_ALREADY_ADDED));
}
return _loc3_;
}
private function onTraitResolverChange(param1:Event) : void
{
var _loc2_:MediaTraitResolver = param1.target as MediaTraitResolver;
this.processResolvedTraitChange(_loc2_.type,_loc2_.resolvedTrait);
}
private function processResolvedTraitChange(param1:String, param2:MediaTraitBase) : void
{
if(param2 != this.traits[param1])
{
this.setLocalTrait(param1,param2);
}
}
private function onContainerChange(param1:ContainerChangeEvent) : void
{
if(this._container == param1.oldContainer && this._container != param1.newContainer)
{
this._container = param1.newContainer;
}
}
private function onMetadataValueAdd(param1:MetadataEvent) : void
{
dispatchEvent(new MediaElementEvent(MediaElementEvent.METADATA_ADD,false,false,null,param1.key,param1.value as Metadata));
}
private function onMetadataValueChange(param1:MetadataEvent) : void
{
dispatchEvent(new MediaElementEvent(MediaElementEvent.METADATA_REMOVE,false,false,null,param1.key,param1.oldValue as Metadata));
dispatchEvent(new MediaElementEvent(MediaElementEvent.METADATA_ADD,false,false,null,param1.key,param1.value as Metadata));
}
private function onMetadataValueRemove(param1:MetadataEvent) : void
{
dispatchEvent(new MediaElementEvent(MediaElementEvent.METADATA_REMOVE,false,false,null,param1.key,param1.value as Metadata));
}
}
}
@@ -0,0 +1,281 @@
package org.osmf.media
{
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
import org.osmf.elements.ProxyElement;
import org.osmf.events.MediaFactoryEvent;
import org.osmf.events.PluginManagerEvent;
import org.osmf.media.pluginClasses.PluginManager;
import org.osmf.utils.OSMFStrings;
public class MediaFactory extends EventDispatcher
{
private var pluginManager:PluginManager;
private var allItems:Dictionary;
public function MediaFactory()
{
super();
this.allItems = new Dictionary();
}
private static function getItemsByResource(param1:MediaResourceBase, param2:Vector.<MediaFactoryItem>) : Vector.<MediaFactoryItem>
{
var _loc4_:MediaFactoryItem = null;
var _loc3_:Vector.<MediaFactoryItem> = new Vector.<MediaFactoryItem>();
for each(_loc4_ in param2)
{
if(_loc4_.canHandleResourceFunction(param1))
{
_loc3_.push(_loc4_);
}
}
return _loc3_;
}
private static function getIndexOfItem(param1:String, param2:Vector.<MediaFactoryItem>) : int
{
var _loc4_:MediaFactoryItem = null;
var _loc3_:int = 0;
while(_loc3_ < param2.length)
{
_loc4_ = param2[_loc3_] as MediaFactoryItem;
if(_loc4_.id == param1)
{
return _loc3_;
}
_loc3_++;
}
return -1;
}
public function addItem(param1:MediaFactoryItem) : void
{
if(param1 == null || param1.id == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
var _loc2_:Vector.<MediaFactoryItem> = this.findOrCreateItems(param1.type);
var _loc3_:int = getIndexOfItem(param1.id,_loc2_);
if(_loc3_ != -1)
{
_loc2_[_loc3_] = param1;
}
else
{
_loc2_.push(param1);
}
}
public function removeItem(param1:MediaFactoryItem) : void
{
var _loc3_:int = 0;
if(param1 == null || param1.id == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
var _loc2_:Vector.<MediaFactoryItem> = this.allItems[param1.type];
if(_loc2_ != null)
{
_loc3_ = _loc2_.indexOf(param1);
if(_loc3_ != -1)
{
_loc2_.splice(_loc3_,1);
}
}
}
public function get numItems() : int
{
var _loc2_:String = null;
var _loc3_:Vector.<MediaFactoryItem> = null;
var _loc1_:int = 0;
for each(_loc2_ in MediaFactoryItemType.ALL_TYPES)
{
_loc3_ = this.allItems[_loc2_];
if(_loc3_ != null)
{
_loc1_ += _loc3_.length;
}
}
return _loc1_;
}
public function getItemAt(param1:int) : MediaFactoryItem
{
var _loc3_:String = null;
var _loc4_:Vector.<MediaFactoryItem> = null;
var _loc2_:MediaFactoryItem = null;
if(param1 >= 0)
{
for each(_loc3_ in MediaFactoryItemType.ALL_TYPES)
{
_loc4_ = this.allItems[_loc3_];
if(_loc4_ != null)
{
if(param1 < _loc4_.length)
{
_loc2_ = _loc4_[param1];
break;
}
param1 -= _loc4_.length;
}
}
}
return _loc2_;
}
public function getItemById(param1:String) : MediaFactoryItem
{
var _loc3_:String = null;
var _loc4_:Vector.<MediaFactoryItem> = null;
var _loc5_:int = 0;
var _loc2_:MediaFactoryItem = null;
for each(_loc3_ in MediaFactoryItemType.ALL_TYPES)
{
_loc4_ = this.allItems[_loc3_];
if(_loc4_ != null)
{
_loc5_ = getIndexOfItem(param1,_loc4_);
if(_loc5_ != -1)
{
_loc2_ = _loc4_[_loc5_];
break;
}
}
}
return _loc2_;
}
public function loadPlugin(param1:MediaResourceBase) : void
{
this.createPluginManager();
this.pluginManager.loadPlugin(param1);
}
public function createMediaElement(param1:MediaResourceBase) : MediaElement
{
var _loc3_:MediaElement = null;
this.createPluginManager();
var _loc2_:MediaElement = this.createMediaElementByResource(param1,MediaFactoryItemType.STANDARD);
if(_loc2_ != null)
{
_loc3_ = this.createMediaElementByResource(_loc2_.resource,MediaFactoryItemType.PROXY,_loc2_);
_loc2_ = _loc3_ != null ? _loc3_ : _loc2_;
dispatchEvent(new MediaFactoryEvent(MediaFactoryEvent.MEDIA_ELEMENT_CREATE,false,false,null,_loc2_));
}
return _loc2_;
}
protected function resolveItems(param1:MediaResourceBase, param2:Vector.<MediaFactoryItem>) : MediaFactoryItem
{
var _loc5_:MediaFactoryItem = null;
if(param1 == null || param2 == null)
{
return null;
}
var _loc3_:MediaFactoryItem = null;
var _loc4_:int = 0;
while(_loc4_ < param2.length)
{
_loc5_ = param2[_loc4_] as MediaFactoryItem;
if(_loc5_.id.indexOf("org.osmf") == -1)
{
return _loc5_;
}
if(_loc3_ == null)
{
_loc3_ = _loc5_;
}
_loc4_++;
}
return _loc3_;
}
private function findOrCreateItems(param1:String) : Vector.<MediaFactoryItem>
{
if(this.allItems[param1] == null)
{
this.allItems[param1] = new Vector.<MediaFactoryItem>();
}
return this.allItems[param1] as Vector.<MediaFactoryItem>;
}
private function createMediaElementByResource(param1:MediaResourceBase, param2:String, param3:MediaElement = null) : MediaElement
{
var _loc6_:MediaFactoryItem = null;
var _loc7_:MediaElement = null;
var _loc8_:* = 0;
var _loc9_:MediaFactoryItem = null;
var _loc10_:ProxyElement = null;
var _loc4_:MediaElement = null;
var _loc5_:Vector.<MediaFactoryItem> = getItemsByResource(param1,this.allItems[param2]);
if(param2 == MediaFactoryItemType.STANDARD)
{
_loc6_ = this.resolveItems(param1,_loc5_) as MediaFactoryItem;
if(_loc6_ != null)
{
_loc4_ = this.invokeMediaElementCreationFunction(_loc6_);
}
}
else if(param2 == MediaFactoryItemType.PROXY)
{
_loc7_ = param3;
_loc8_ = int(_loc5_.length);
while(_loc8_ > 0)
{
_loc9_ = _loc5_[_loc8_ - 1] as MediaFactoryItem;
_loc10_ = this.invokeMediaElementCreationFunction(_loc9_) as ProxyElement;
if(_loc10_ != null)
{
_loc10_.proxiedElement = _loc7_;
_loc7_ = _loc10_;
}
_loc8_--;
}
_loc4_ = _loc7_;
}
if(_loc4_ != null)
{
_loc4_.resource = param1;
}
return _loc4_;
}
private function onPluginLoad(param1:PluginManagerEvent) : void
{
dispatchEvent(new MediaFactoryEvent(MediaFactoryEvent.PLUGIN_LOAD,false,false,param1.resource));
}
private function onPluginLoadError(param1:PluginManagerEvent) : void
{
dispatchEvent(new MediaFactoryEvent(MediaFactoryEvent.PLUGIN_LOAD_ERROR,false,false,param1.resource));
}
private function invokeMediaElementCreationFunction(param1:MediaFactoryItem) : MediaElement
{
var _loc2_:MediaElement = null;
try
{
_loc2_ = param1.mediaElementCreationFunction();
}
catch(error:Error)
{
}
return _loc2_;
}
private function createPluginManager() : void
{
if(this.pluginManager == null)
{
this.pluginManager = new PluginManager(this);
this.pluginManager.addEventListener(PluginManagerEvent.PLUGIN_LOAD,this.onPluginLoad);
this.pluginManager.addEventListener(PluginManagerEvent.PLUGIN_LOAD_ERROR,this.onPluginLoadError);
}
}
}
}
@@ -0,0 +1,51 @@
package org.osmf.media
{
import org.osmf.utils.OSMFStrings;
public class MediaFactoryItem
{
private var _id:String;
private var _canHandleResourceFunction:Function;
private var _mediaElementCreationFunction:Function;
private var _type:String;
public function MediaFactoryItem(param1:String, param2:Function, param3:Function, param4:String = null)
{
super();
if(param1 == null || param2 == null || param3 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
param4 ||= MediaFactoryItemType.STANDARD;
this._id = param1;
this._canHandleResourceFunction = param2;
this._mediaElementCreationFunction = param3;
this._type = param4;
}
public function get id() : String
{
return this._id;
}
public function get canHandleResourceFunction() : Function
{
return this._canHandleResourceFunction;
}
public function get mediaElementCreationFunction() : Function
{
return this._mediaElementCreationFunction;
}
public function get type() : String
{
return this._type;
}
}
}
@@ -0,0 +1,18 @@
package org.osmf.media
{
public class MediaFactoryItemType
{
public static const STANDARD:String = "standard";
public static const PROXY:String = "proxy";
internal static const ALL_TYPES:Array = [STANDARD,PROXY];
public function MediaFactoryItemType()
{
super();
}
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,26 @@
package org.osmf.media
{
public final class MediaPlayerState
{
public static const UNINITIALIZED:String = "uninitialized";
public static const LOADING:String = "loading";
public static const READY:String = "ready";
public static const PLAYING:String = "playing";
public static const PAUSED:String = "paused";
public static const BUFFERING:String = "buffering";
public static const PLAYBACK_ERROR:String = "playbackError";
public function MediaPlayerState()
{
super();
}
}
}
@@ -0,0 +1,84 @@
package org.osmf.media
{
import flash.utils.Dictionary;
public class MediaResourceBase
{
private var _metadata:Dictionary;
private var _mediaType:String;
private var _mimeType:String;
public function MediaResourceBase()
{
super();
}
public function get mediaType() : String
{
return this._mediaType;
}
public function set mediaType(param1:String) : void
{
this._mediaType = param1;
}
public function get mimeType() : String
{
return this._mimeType;
}
public function set mimeType(param1:String) : void
{
this._mimeType = param1;
}
public function get metadataNamespaceURLs() : Vector.<String>
{
var _loc2_:String = null;
var _loc1_:Vector.<String> = new Vector.<String>();
if(this._metadata != null)
{
for(_loc2_ in this._metadata)
{
_loc1_.push(_loc2_);
}
}
return _loc1_;
}
public function addMetadataValue(param1:String, param2:Object) : void
{
if(this._metadata == null)
{
this._metadata = new Dictionary();
}
this._metadata[param1] = param2;
}
public function getMetadataValue(param1:String) : Object
{
if(this._metadata != null)
{
return this._metadata[param1];
}
return null;
}
public function removeMetadataValue(param1:String) : Object
{
var _loc2_:Object = null;
if(this._metadata != null)
{
_loc2_ = this._metadata[param1];
delete this._metadata[param1];
return _loc2_;
}
return null;
}
}
}
@@ -0,0 +1,85 @@
package org.osmf.media
{
import flash.events.Event;
import flash.events.EventDispatcher;
import org.osmf.traits.MediaTraitBase;
import org.osmf.utils.OSMFStrings;
internal class MediaTraitResolver extends EventDispatcher
{
private var _type:String;
private var _resolvedTrait:MediaTraitBase;
public function MediaTraitResolver(param1:String)
{
super();
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
this._type = param1;
}
final public function get type() : String
{
return this._type;
}
final protected function setResolvedTrait(param1:MediaTraitBase) : void
{
if(param1 != this._resolvedTrait)
{
if(this._resolvedTrait)
{
this._resolvedTrait = null;
dispatchEvent(new Event(Event.CHANGE));
}
this._resolvedTrait = param1;
dispatchEvent(new Event(Event.CHANGE));
}
}
final public function get resolvedTrait() : MediaTraitBase
{
return this._resolvedTrait;
}
final public function addTrait(param1:MediaTraitBase) : void
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
if(param1.traitType != this.type)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
this.processAddTrait(param1);
}
final public function removeTrait(param1:MediaTraitBase) : MediaTraitBase
{
if(param1 == null)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.NULL_PARAM));
}
if(param1.traitType != this.type)
{
throw new ArgumentError(OSMFStrings.getString(OSMFStrings.INVALID_PARAM));
}
return this.processRemoveTrait(param1);
}
protected function processAddTrait(param1:MediaTraitBase) : void
{
}
protected function processRemoveTrait(param1:MediaTraitBase) : MediaTraitBase
{
return null;
}
}
}
Loaded 100 of 7925 files, more files were not shown because too many files have changed in this diff. Show more