Parent Directory
| 
Revision Log
�°��ύ
//****************************************************************************
//Copyright (C) 2004-2005 Macromedia, Inc. All Rights Reserved.
//The following is Sample Code and is subject to all restrictions on
//such code as contained in the End User License Agreement accompanying
//this product.
//****************************************************************************
import mx.video.*;
/**
* <p>Event dispatched when a cue point is reached. Event Object has an
* info property that contains the info object received by the
* <code>NetStream.onCuePoint</code> callback for FLV cue points or
* the object passed into the AS cue point APIs for AS cue points.</p>
*
* @tiptext cuePoint event
* @helpid 3483
*/
[Event("cuePoint")]
/**
* <p>CuePointManager manages AS cue points and enabling/disabling FLV
* embedded cue points for the FLVPlayback class.</p>
*
* @author copyright 2004-2005 Macromedia, Inc.
*/
class mx.video.CuePointManager {
private var _owner:FLVPlayback;
private var _metadataLoaded:Boolean;
private var _disabledCuePoints:Array;
private var _disabledCuePointsByNameOnly:Object;
private var _asCuePointIndex:Number;
private var _asCuePointTolerance:Number;
private var _linearSearchTolerance:Number;
private var _id:Number;
private static var DEFAULT_LINEAR_SEARCH_TOLERANCE:Number = 50;
var allCuePoints:Array;
var asCuePoints:Array;
var flvCuePoints:Array;
var navCuePoints:Array;
var eventCuePoints:Array;
//ifdef DEBUG
//private static var _debugSingleton:CuePointManager;
//endif
//
// public APIs
//
/**
* <p>Constructor.</p>
*
* @helpid 0
*/
function CuePointManager(owner:FLVPlayback, id:Number) {
_owner = owner;
_id = id;
reset();
_asCuePointTolerance = _owner.getVideoPlayer(_id).playheadUpdateInterval / 2000;
_linearSearchTolerance = DEFAULT_LINEAR_SEARCH_TOLERANCE;
//ifdef DEBUG
//_debugSingleton = this;
//endif
}
/**
* Reset cue point lists
*/
function reset() {
//ifdef DEBUG
//debugTrace("reset()");
//endif
_metadataLoaded = false;
allCuePoints = null;
asCuePoints = null;
_disabledCuePoints = null;
flvCuePoints = null;
navCuePoints = null;
eventCuePoints = null;
_asCuePointIndex = 0;
}
/**
* read only, has metadata been loaded
*/
function get metadataLoaded():Boolean {
return _metadataLoaded;
}
/**
* <p>Set by FLVPlayback to update _asCuePointTolerance</p>
*
* @private
*/
function set playheadUpdateInterval(aTime:Number):Void {
_asCuePointTolerance = aTime / 2000;
}
/**
* <p>corresponds to _vp and _cpMgr array index in FLVPlayback
*
* @private
*/
function get id():Number {
return _id;
}
/**
* <p>Add an ActionScript cue point.</p>
*
* <p>It is legal to add multiple AS cue points with the same
* name and time. When removeASCuePoint is called with this
* name and time, all will be removed.</p>
*
* @param timeOrCuePoint If Object, then object describing the cue
* point. Must have a name:String and time:Number (in seconds)
* property. May have a parameters:Object property that holds
* name/value pairs. May have type:String set to "actionscript",
* if it is missing or set to something else it will be set
* automatically. If the Object does not conform to these
* conventions, a <code>VideoError</code> will be thrown.
*
* <p>If Number, then time for new cue point to be added
* and name parameter must follow.</p>
* @param name Name for cuePoint if timeOrCuePoint parameter
* is a Number.
* @param parameters Optional parameters for cuePoint if
* timeOrCuePoint parameter is a Number.
* @returns A copy of the cuePoint Object added. The copy has the
* following additional properties:
*
* <ul>
*
* <li><code>array</code> - the array of all AS cue points. Treat
* this array as read only as adding, removing or editing objects
* within it can cause cue points to malfunction.</li>
*
* <li><code>index</code> - the index into the array for the
* returned cuepoint.</li>
*
* </ul>
*
* @throws VideoError if parameters are invalid
* @see #removeASCuePoint()
* @see #getCuePoint()
*/
public function addASCuePoint(timeOrCuePoint:Object, name:String, parameters:Object):Object {
//ifdef DEBUG
//debugTrace("addASCuePoint()");
//endif
// make sense of param
var cuePoint:Object;
if (typeof timeOrCuePoint == "object") {
cuePoint = deepCopyObject(timeOrCuePoint);
} else {
cuePoint = { time:timeOrCuePoint, name:name, parameters:deepCopyObject(parameters) };
}
// sanity check
var timeUndefined:Boolean = (isNaN(cuePoint.time) || cuePoint.time < 0);
if (timeUndefined) throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "time must be number");
var nameUndefined:Boolean = (cuePoint.name == undefined || cuePoint.name == null);
if (nameUndefined) throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "name cannot be undefined or null");
// add cue point to AS cue point array
var index:Number;
cuePoint.type = "actionscript";
if ( asCuePoints == null || asCuePoints == undefined || asCuePoints.length < 1 ) {
index = 0;
asCuePoints = new Array();
asCuePoints.push(cuePoint);
} else {
index = getCuePointIndex(asCuePoints, true, cuePoint.time);
index = (asCuePoints[index].time > cuePoint.time) ? 0 : index + 1;
asCuePoints.splice(index, 0, cuePoint);
}
// add cue point to all cue points array
if ( allCuePoints == null || allCuePoints == undefined || allCuePoints.length < 1 ) {
index = 0;
allCuePoints = new Array();
allCuePoints.push(cuePoint);
} else {
index = getCuePointIndex(allCuePoints, true, cuePoint.time);
index = (allCuePoints[index].time > cuePoint.time) ? 0 : index + 1;
allCuePoints.splice(index, 0, cuePoint);
}
// adjust _asCuePointIndex
var now:Number = _owner.getVideoPlayer(_id).playheadTime;
if (now > 0) {
if (_asCuePointIndex == index) {
if (now > asCuePoints[index].time) {
_asCuePointIndex++;
}
} else if (_asCuePointIndex > index) {
_asCuePointIndex++;
}
} else {
_asCuePointIndex = 0;
}
// return the cue point
var returnObject:Object = deepCopyObject(asCuePoints[index]);
returnObject.array = asCuePoints;
returnObject.index = index;
return returnObject;
}
/**
* <p>Remove an ActionScript cue point from the currently
* loaded FLV. Only the name and time properties are used
* from the cuePoint parameter to find the cue point to be
* removed.</p>
*
* <p>If multiple AS cue points match the search criteria, only
* one will be removed. To remove all, call this function
* repeatedly in a loop with the same parameters until it returns
* <code>null</code>.</p>
*
* @param timeNameOrCuePoint If string, name of cue point to
* remove; remove first cue point with this name. If number, time
* of cue point to remove; remove first cue point at this time.
* If Object, then object with name and time properties, remove
* cue point with both this name and time.
* @returns The cue point that was removed. If there was no
* matching cue point then <code>null</code> is returned.
* @see #addASCuePoint()
* @see #getCuePoint()
*/
public function removeASCuePoint(timeNameOrCuePoint:Object):Object {
//ifdef DEBUG
//debugTrace("removeASCuePoint()");
//endif
// bail if no cue points
if ( asCuePoints == null || asCuePoints == undefined || asCuePoints.length < 1 ) {
return null;
}
// make sense of param
var cuePoint:Object;
switch (typeof timeNameOrCuePoint) {
case "string":
cuePoint = {name:timeNameOrCuePoint};
break;
case "number":
cuePoint = {time:timeNameOrCuePoint};
break;
case "object":
cuePoint = timeNameOrCuePoint;
break;
} // switch
// remove cue point from AS cue point array
var index:Number = getCuePointIndex(asCuePoints, false, cuePoint.time, cuePoint.name);
if (index < 0) return null;
var cuePoint:Object = asCuePoints[index];
asCuePoints.splice(index, 1);
// remove cue point from all cue points array
index = getCuePointIndex(allCuePoints, false, cuePoint.time, cuePoint.name);
if (index > 0) {
allCuePoints.splice(index, 1);
}
// adjust _asCuePointIndex
if (_owner.getVideoPlayer(_id).playheadTime > 0) {
if (_asCuePointIndex > index) {
_asCuePointIndex--;
}
} else {
_asCuePointIndex = 0;
}
// return the cue point
return cuePoint;
}
/**
* <p>Enable or disable one or more FLV cue point. Disabled cue
* points are disabled for being dispatched as events and
* navigating to them with <code>seekToPrevNavCuePoint()</code>,
* <code>seekToNextNavCuePoint()</code> and
* <code>seekToNavCuePoint()</code>.</p>
*
* <p>If this API is called just after setting the
* <code>contentPath</code> property or if no FLV is loaded, then
* the cue point will be enabled or disabled in the FLV to be
* loaded. Otherwise, it will be enabled or disabled in the
* currently loaded FLV (even if it is called immediately before
* setting the <code>contentPath</code> property to load another
* FLV).</p>
*
* <p>Changes caused by calls to this function will not be
* reflected in results returned from
* <code>isFLVCuePointEnabled</code> until
* <code>metadataLoaded</code> is true.</p>
*
* @param enabled whether to enable or disable FLV cue point
* @param timeNameOrCuePoint If string, name of cue point to
* enable/disable. If number, time of cue point to
* enable/disable. If Object, then object with name and time
* properties, enable/disable cue point that matches both name and
* time.
* @returns If <code>metadataLoaded</code> is true, returns number
* of cue points whose enabled state was changed. If
* <code>metadataLoaded</code> is false, always returns -1.
* @see #isFLVCuePointEnabled()
* @see #getCuePoint()
*/
public function setFLVCuePointEnabled(enabled:Boolean, timeNameOrCuePoint:Object):Number {
//ifdef DEBUG
//debugTrace("setFLVCuePointEnabled()");
//endif
var cuePoint:Object;
switch (typeof timeNameOrCuePoint) {
case "string":
cuePoint = {name:timeNameOrCuePoint};
break;
case "number":
cuePoint = {time:timeNameOrCuePoint};
break;
case "object":
cuePoint = timeNameOrCuePoint;
break;
} // switch
// sanity check
var timeUndefined:Boolean = (isNaN(cuePoint.time) || cuePoint.time < 0);
var nameUndefined:Boolean = (cuePoint.name == undefined || cuePoint.name == null);
if (timeUndefined && nameUndefined) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "time must be number and/or name must not be undefined or null");
}
var numChanged:Number = 0;
var matchIndex:Number;
var index:Number
// deal with name only case
if (timeUndefined) {
// if metadata not loaded, save the name in
// _disabledCuePointsByNameOnly to use in
// processFLVCuePoints()
if (!_metadataLoaded) {
// check if already in _disabledCuePointsByNameOnly,
// if so one stop shopping because dupes with specific
// times would have already been removed or never
// would have been inserted
if (_disabledCuePointsByNameOnly[cuePoint.name] == undefined) {
// Still need to weed out specific matches of name AND time
if (!enabled) {
if ( _disabledCuePointsByNameOnly == null ||
_disabledCuePointsByNameOnly == undefined ||
_disabledCuePointsByNameOnly.length < 0 ) {
_disabledCuePointsByNameOnly = new Object();
}
// disable it!
_disabledCuePointsByNameOnly[cuePoint.name] = new Array;
}
} else {
// enable it or already disabled, we are done
if (enabled) {
_disabledCuePointsByNameOnly[cuePoint.name] = undefined;
}
return -1;
}
// remove any matches with specific times (either redudant if enabled == true
// or need to remove them anyways
removeCuePoints(_disabledCuePoints, cuePoint);
return -1;
} // if (!_metadataLoaded)
// if enabled == true, then we are removing from _disabledCuePoints
if (enabled) {
numChanged = removeCuePoints(_disabledCuePoints, cuePoint);
} else {
// if enable == false, we search for matches in
// flvCuePoints to insert into _disabledCuePoints
var matchCuePoint:Object;
for ( matchIndex = getCuePointIndex(flvCuePoints, true, -1, cuePoint.name);
matchIndex >= 0;
matchIndex = getNextCuePointIndexWithName(matchCuePoint.name, flvCuePoints, matchIndex) ) {
matchCuePoint = flvCuePoints[matchIndex];
// look for matching cue point already inserted in disabled array
index = getCuePointIndex(_disabledCuePoints, true, matchCuePoint.time);
if (index < 0 || _disabledCuePoints[index].time != matchCuePoint.time) {
_disabledCuePoints =
insertCuePoint( index, _disabledCuePoints,
{name:matchCuePoint.name, time:matchCuePoint.time} );
numChanged += 1;
}
} // for
} // else if (enabled)
return numChanged;
} // if (timeUndefined)
// deal with time where we are given time
// look for matching cue point already in _disabledCuePoints
matchIndex = getCuePointIndex(_disabledCuePoints, false, cuePoint.time, cuePoint.name);
// if we found a match...
if (matchIndex < 0) {
// if no match and enabled is true, we are done
// since no disabled entry to remove found
if (enabled) {
if (!_metadataLoaded) {
// check for time only match before giving up
matchIndex = getCuePointIndex(_disabledCuePoints, false, cuePoint.time);
if (matchIndex < 0) {
// _disabledCuePointsByNameOnly contains arrays hashed for cue point names
// which are disabled globally. The array has cue point objects which define
// the exception to the global shutdown.
// look for insertion point in diabled array
index = getCuePointIndex(_disabledCuePointsByNameOnly[cuePoint.name], true, cuePoint.time);
// insert it if not there already
if (cuePointCompare(cuePoint.time, null, _disabledCuePointsByNameOnly[cuePoint.name]) != 0) {
_disabledCuePointsByNameOnly[cuePoint.name] =
insertCuePoint(index, _disabledCuePointsByNameOnly[cuePoint.name], cuePoint);
}
} else {
// remove that time only match
_disabledCuePoints.splice(matchIndex, 1);
}
}
return (_metadataLoaded) ? 0 : -1;
}
} else {
// if enabled is true, remove it and done
if (enabled) {
_disabledCuePoints.splice(matchIndex, 1);
numChanged = 1;
} else {
// if enabled is false, then we do not have to add one, still done
numChanged = 0;
}
return (_metadataLoaded) ? numChanged : -1;
}
// might still be looking if enabled == false
// if we have metadata loaded, look for a matching cue point
if (_metadataLoaded) {
// check for match
matchIndex = getCuePointIndex(flvCuePoints, false, cuePoint.time, cuePoint.name);
// no match, return zero cue points disabled
if (matchIndex < 0) return 0;
// if did not specify name, take name from flv cue point array
if (nameUndefined) cuePoint.name = flvCuePoints[matchIndex].name;
}
// need to insert, get pointer into _disabledCuePoints array in right spot
index = getCuePointIndex(_disabledCuePoints, true, cuePoint.time);
_disabledCuePoints = insertCuePoint(index, _disabledCuePoints, cuePoint);
numChanged = 1;
return (_metadataLoaded) ? 1 : -1;
}
/**
* removes enabled cue points from _disabledCuePoints
*
* @private
*/
private function removeCuePoints(cuePointArray:Array, cuePoint:Object):Number {
//ifdef DEBUG
//debugTrace("removeCuePoints()");
//endif
var matchIndex:Number;
var matchCuePoint:Object;
var numChanged:Number = 0;
for ( matchIndex = getCuePointIndex(cuePointArray, true, -1, cuePoint.name);
matchIndex >= 0;
matchIndex = getNextCuePointIndexWithName(matchCuePoint.name, cuePointArray, matchIndex) ) {
// remove match
matchCuePoint = cuePointArray[matchIndex];
cuePointArray.splice(matchIndex, 1);
matchIndex--;
numChanged++;
}
return numChanged;
}
/**
* inserts cue points into array
*
* @private
*/
private function insertCuePoint(insertIndex:Number, cuePointArray:Array, cuePoint:Object):Array {
//ifdef DEBUG
//debugTrace("insertCuePoint()");
//endif
if (insertIndex < 0) {
cuePointArray = new Array();
cuePointArray.push(cuePoint);
} else {
// find insertion point
if (cuePointArray[insertIndex].time > cuePoint.time) {
insertIndex = 0;
} else {
insertIndex++;
}
// insert into sorted cuePointArray
cuePointArray.splice(insertIndex, 0, cuePoint);
}
return cuePointArray;
}
/**
* <p>Returns false if FLV embedded cue point is disabled by
* ActionScript. Cue points are disabled via setting the
* <code>cuePoints</code> property or by calling
* <code>setFLVCuePointEnabled()</code>.</p>
*
* <p>The return value from this function is only meaningful when
* <code>metadata</code> is true. It always returns false
* when it is null.</p>
*
* @param timeNameOrCuePoint If string, name of cue point to
* check; return false only if ALL cue points with this name are
* disabled. If number, time of cue point to check. If Object,
* then object with name and time properties, check cue point that
* matches both name and time.
* @returns false if cue point(s) is found and is disabled, true
* either if no such cue point exists or if it is not disabled.
* If time given is undefined, null or less than 0 then returns
* false only if all cue points with this name are disabled.
*
* <p>The return value from this function is only meaningful when
* <code>metadata</code> is true. It always returns true when it
* is false.</p>
* @see #getCuePoint()
* @see #setFLVCuePointEnabled()
*/
public function isFLVCuePointEnabled(timeNameOrCuePoint:Object):Boolean {
//ifdef DEBUG
//debugTrace("isFLVCuePointEnabled()");
//endif
if (!_metadataLoaded) return true;
var cuePoint:Object;
switch (typeof timeNameOrCuePoint) {
case "string":
cuePoint = {name:timeNameOrCuePoint};
break;
case "number":
cuePoint = {time:timeNameOrCuePoint};
break;
case "object":
cuePoint = timeNameOrCuePoint;
break;
} // switch
// sanity check
var timeUndefined:Boolean = (isNaN(cuePoint.time) || cuePoint.time < 0);
var nameUndefined:Boolean = (cuePoint.name == undefined || cuePoint.name == null);
if (timeUndefined && nameUndefined) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "time must be number and/or name must not be undefined or null");
}
// look to see if ALL cue points with name are disabled
if (timeUndefined) {
var index:Number = getCuePointIndex(flvCuePoints, true, -1, cuePoint.name);
// return true if no cue points with that name at all
if (index < 0) return true;
// check all the cue points, return true if any enabled
while (index >= 0) {
if ( getCuePointIndex( _disabledCuePoints, false,
flvCuePoints[index].time,
flvCuePoints[index].name) < 0 ) {
return true;
}
index = getNextCuePointIndexWithName(cuePoint.name, flvCuePoints, index);
}
return false;
}
// check for match in _disabledCuePoints, return true if no
// match which means not disabled, and may mean does not exist
// at all
return (getCuePointIndex(_disabledCuePoints, false, cuePoint.time, cuePoint.name) < 0);
}
//
// package internal methods, called by FLVPlayback
//
/**
* <p>Called by FLVPlayback on "playheadUpdate" event
* to throw "cuePoint" events when appropriate.</p>
*
* @private
*/
function dispatchASCuePoints():Void {
//ifdef DEBUG
////debugTrace("dispatchASCuePoints()");
//endif
var now:Number = _owner.getVideoPlayer(_id).playheadTime;
if (_owner.getVideoPlayer(_id).stateResponsive && asCuePoints != null && asCuePoints != undefined) {
while ( _asCuePointIndex < asCuePoints.length &&
asCuePoints[_asCuePointIndex].time <= now + _asCuePointTolerance ) {
_owner.dispatchEvent({type:"cuePoint", info:deepCopyObject(asCuePoints[_asCuePointIndex++]), vp:_id});
}
}
}
/**
* When our place in the stream is changed, this is called
* to reset our index into actionscript cue point array.
* Another method is used when AS cue points are added
* are removed.
*
* @private
*/
function resetASCuePointIndex(time:Number):Void {
if (time <= 0 || asCuePoints == null || asCuePoints == undefined) {
_asCuePointIndex = 0;
return;
}
var index:Number = getCuePointIndex(asCuePoints, true, time);
// todo: should we be using the _asCuePointTolerance?
//_asCuePointIndex = (asCuePoints[index].time < time - _asCuePointTolerance) ? index + 1 : index;
_asCuePointIndex = (asCuePoints[index].time < time) ? index + 1 : index;
}
/**
* Called by FLVPlayback "metadataReceived" event handler to process flv
* embedded cue points array.
*
* @private
*/
function processFLVCuePoints(metadataCuePoints:Array):Void {
// metadata was received
_metadataLoaded = true;
// if no flv cue points, bail
if (metadataCuePoints == undefined || metadataCuePoints == null || metadataCuePoints.length < 1) {
flvCuePoints = null;
navCuePoints = null;
eventCuePoints = null;
return;
}
flvCuePoints = metadataCuePoints;
navCuePoints = new Array();
eventCuePoints = new Array();
var index:Number;
var prevTime:Number = -1;
var cuePoint:Object;
var dArray:Array = _disabledCuePoints;
var dArrayIndex:Number = 0;
_disabledCuePoints = new Array();
var i:Number = 0;
while ((cuePoint = flvCuePoints[i++]) != undefined) {
// sanity check
if (prevTime > 0 && prevTime >= cuePoint.time) {
flvCuePoints = null;
navCuePoints = null;
eventCuePoints = null;
_disabledCuePoints = null;
_disabledCuePointsByNameOnly = null;
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "Unsorted cuePoint found after time: " + prevTime);
}
prevTime = cuePoint.time;
// disable cue points
while ( dArrayIndex < dArray.length &&
cuePointCompare(dArray[dArrayIndex].time, null, cuePoint) < 0 ) {
dArrayIndex++;
}
if ( _disabledCuePointsByNameOnly[cuePoint.name] != undefined ||
( dArrayIndex < dArray.length &&
cuePointCompare(dArray[dArrayIndex].time, dArray[dArrayIndex].name, cuePoint) == 0 ) ) {
_disabledCuePoints.push({time:cuePoint.time, name:cuePoint.name});
}
// sort into nav and event arrays
if (cuePoint.type == "navigation") {
// push on nav cue points list
navCuePoints.push(cuePoint);
} else if (cuePoint.type == "event") {
// push on event cue points list
eventCuePoints.push(cuePoint);
}
// add to all cue points array
if ( allCuePoints == null || allCuePoints == undefined || allCuePoints.length < 1 ) {
allCuePoints = new Array();
allCuePoints.push(cuePoint);
} else {
index = getCuePointIndex(allCuePoints, true, cuePoint.time);
index = (allCuePoints[index].time > cuePoint.time) ? 0 : index + 1;
allCuePoints.splice(index, 0, cuePoint);
}
} // while
// clear out old disable cue point stuff
delete _disabledCuePointsByNameOnly;
_disabledCuePointsByNameOnly = null;
delete _disabledCuePointsByNameOnly;
_disabledCuePointsByNameOnly = null;
//ifdef DEBUG
////debugTraceProcessFLVCuePoints();
////debugCuePointSearchSuite();
//endif
}
/**
* <p>Process Array passed into FLVPlayback cuePoints property.
* Array actually holds name value pairs. Each cue point starts
* with 5 pairs: t,time,n,name,t,type,d,disabled,p,numparams.
* time is a Number in milliseconds (e.g. 3000 = 3 seconds), name
* is a String, type is a Number (0 = event, 1 = navigation, 2 =
* actionscript), disabled is a Number (0 for false, 1 for true)
* and numparams is a Number. After this, there are numparams
* name/value pairs which could be any simple type.</p>
*
* <p>Note that all Strings are escaped with html/xml entities for
* ampersand (&), double quote ("), single quote (')
* and comma (,), so must be unescaped.</p>
*
* @see FLVPlayback#cuePoints
* @private
*/
function processCuePointsProperty(cuePoints:Array):Void {
//ifdef DEBUG
//debugTrace("cuePoints = [");
//for (var zzz:Number = 0; zzz < cuePoints.length; zzz+=2) {
// debugTrace(" " + cuePoints[zzz] + ", " + cuePoints[zzz+1]);
//}
//debugTrace("];");
//endif
if (cuePoints == undefined || cuePoints == null || cuePoints.length == 0) {
return;
}
var state:Number = 0;
var numParamsLeft:Number;
var name:String, value:String;
var cuePoint:Object;
var disable:Boolean;
for (var i:Number = 0; i < cuePoints.length - 1; i++) {
switch (state) {
case 6:
// add cuePoint appropriately
addOrDisable(disable, cuePoint);
// reset and process the next
state = 0;
// no break
case 0:
if (cuePoints[i++] != "t") {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "unexpected cuePoint parameter format");
}
if (isNaN(cuePoints[i])) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "time must be number");
}
cuePoint = new Object();
cuePoint.time = cuePoints[i] / 1000;
state++;
break;
case 1:
if (cuePoints[i++] != "n") {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "unexpected cuePoint parameter format");
}
if (cuePoints[i] == undefined || cuePoints[i] == null) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "name cannot be null or undefined");
}
cuePoint.name = unescape(cuePoints[i]);
state++;
break;
case 2:
if (cuePoints[i++] != "t") {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "unexpected cuePoint parameter format");
}
if (isNaN(cuePoints[i])) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "type must be number");
}
switch (cuePoints[i]) {
case 0:
cuePoint.type = "event";
break;
case 1:
cuePoint.type = "navigation";
break;
case 2:
cuePoint.type = "actionscript";
break;
default:
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "type must be 0, 1 or 2");
} // switch
state++;
break;
case 3:
if (cuePoints[i++] != "d") {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "unexpected cuePoint parameter format");
}
if (isNaN(cuePoints[i])) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "disabled must be number");
}
disable = (cuePoints[i] != 0);
state++;
break;
case 4:
if (cuePoints[i++] != "p") {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "unexpected cuePoint parameter format");
}
if (isNaN(cuePoints[i])) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "num params must be number");
}
numParamsLeft = cuePoints[i];
state++;
if (numParamsLeft == 0) {
state++;
} else {
cuePoint.parameters = new Object();
}
break;
case 5:
name = cuePoints[i++];
value = cuePoints[i];
if (typeof name == "string") name = unescape(name);
if (typeof value == "string") value = unescape(value);
cuePoint.parameters[name] = value;
numParamsLeft--;
if (numParamsLeft == 0) state++;
break;
} // switch
} // for
// ended badly, throw error
if (state == 6) {
addOrDisable(disable, cuePoint);
} else {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "unexpected end of cuePoint param string");
}
//ifdef DEBUG
//debugTraceProcessFLVCuePoints();
//endif
}
//
// private functions
//
/**
* Used by processCuePointsProperty
*
* @private
*/
private function addOrDisable(disable:Boolean, cuePoint:Object):Void {
if (disable) {
if (cuePoint.type == "actionscript") {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "Cannot disable actionscript cue points");
}
setFLVCuePointEnabled(false, cuePoint);
} else if (cuePoint.type == "actionscript") {
addASCuePoint(cuePoint);
}
}
private static var cuePointsReplace:Array = [
""", "\"",
"'", "'",
",", ",",
"&", "&"
];
/**
* Used by processCuePointsProperty
*
* @private
*/
private function unescape(origStr:String):String {
var newStr:String = origStr;
for (var i:Number = 0; i < cuePointsReplace.length; i++) {
var broken:Array = newStr.split(cuePointsReplace[i++]);
if (broken.length > 1) {
newStr = broken.join(cuePointsReplace[i]);
}
}
return newStr;
}
/**
* Search for a cue point in an array sorted by time. See
* closeIsOK parameter for search rules.
*
* @param cuePointArray array to search
* @param closeIsOK If true, the behavior differs depending on the
* parameters passed in:
*
* <ul>
*
* <li>If name is null or undefined, then if the specific time is
* not found then the closest time earlier than that is returned.
* If there is no cue point earlier than time, the first cue point
* is returned.</li>
*
* <li>If time is null, undefined or less than 0 then the first
* cue point with the given name is returned.</li>
*
* <li>If time and name are both defined then the closest cue
* point, then if the specific time and name is not found then the
* closest time earlier than that with that name is returned. If
* there is no cue point with that name and with an earlier time,
* then the first cue point with that name is returned. If there
* is no cue point with that name, null is returned.</li>
*
* <li>If time is null, undefined or less than 0 and name is null
* or undefined, a VideoError is thrown.</li>
*
* </ul>
*
* <p>If closeIsOK is false the behavior is:</p>
*
* <ul>
*
* <li>If name is null or undefined and there is a cue point with
* exactly that time, it is returned. Otherwise null is
* returned.</li>
*
* <li>If time is null, undefined or less than 0 then the first
* cue point with the given name is returned.</li>
*
* <li>If time and name are both defined and there is a cue point
* with exactly that time and name, it is returned. Otherwise null
* is returned.</li>
*
* <li>If time is null, undefined or less than 0 and name is null
* or undefined, a VideoError is thrown.</li>
*
* </ul>
* @param time search criteria
* @param name search criteria
* @param start index of first item to be searched, used for
* recursive implementation, defaults to 0 if undefined
* @param len length of array to search, used for recursive
* implementation, defaults to cuePointArray.length if undefined
* @returns index for cue point in given array or -1 if no match found
* @throws VideoError if time and/or name parameters are bad
* @see #cuePointCompare()
* @private
*/
private function getCuePointIndex( cuePointArray:Array, closeIsOK:Boolean,
time:Number, name:String,
start:Number, len:Number):Number {
// sanity checks
if (cuePointArray == null || cuePointArray == undefined || cuePointArray.length < 1) {
return -1;
}
var timeUndefined:Boolean = (isNaN(time) || time < 0);
var nameUndefined:Boolean = (name == undefined || name == null);
if (timeUndefined && nameUndefined) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "time must be number and/or name must not be undefined or null");
}
if (start == undefined || start == null) start = 0;
if (len == undefined || len == null) len = cuePointArray.length;
// name is passed in and time is undefined or closeIsOK is
// true, search for first name starting at either start
// parameter index or index at or after passed in time, respectively
if (!nameUndefined && (closeIsOK || timeUndefined)) {
var firstIndex:Number;
var index:Number;
if (timeUndefined) {
firstIndex = start;
} else {
firstIndex = getCuePointIndex(cuePointArray, closeIsOK, time);
}
for (index = firstIndex; index >= start; index--) {
if (cuePointArray[index].name == name) break;
}
if (index >= start) return index;
for (index = firstIndex + 1; index < len; index++) {
if (cuePointArray[index].name == name) break;
}
if (index < len) return index;
return -1;
}
var result:Number;
// iteratively check if short length
if (len <= _linearSearchTolerance) {
var max:Number = start + len;
for (var i:Number = start; i < max; i++) {
result = cuePointCompare(time, name, cuePointArray[i]);
if (result == 0) return i;
if (result < 0) break;
}
if (closeIsOK) {
if (i > 0) return i - 1;
return 0;
}
return -1;
}
// split list and recurse
var halfLen:Number = Math.floor(len / 2);
var checkIndex:Number = start + halfLen;
result = cuePointCompare(time, name, cuePointArray[checkIndex]);
if (result < 0) {
return getCuePointIndex( cuePointArray, closeIsOK, time, name,
start, halfLen );
}
if (result > 0) {
return getCuePointIndex( cuePointArray, closeIsOK, time, name,
checkIndex + 1, halfLen - 1 + (len % 2) );
}
return checkIndex;
}
/**
* <p>Given a name, array and index, returns the next cue point in
* that array after given index with the same name. Returns null
* if no cue point after that one with that name. Throws
* VideoError if argument is invalid.</p>
*
* @returns index for cue point in given array or -1 if no match found
* @private
*/
private function getNextCuePointIndexWithName(name:String, array:Array, index:Number):Number {
// sanity checks
if (name == undefined || name == null) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "name cannot be undefined or null");
}
if (array == null || array == undefined) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "cuePoint.array undefined");
}
if (isNaN(index) || index < -1 || index >= array.length) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "cuePoint.index must be number between -1 and cuePoint.array.length");
}
// find it
var i;
for (i = index + 1; i < array.length; i++) {
if (array[i].name == name) break;
}
if (i < array.length) return i;
return -1;
}
/**
* Takes two cue point Objects and returns -1 if first sorts
* before second, 1 if second sorts before first and 0 if they are
* equal. First compares times with millisecond precision. If
* they match, compares name if name parameter is not null or undefined.
*
* @private
*/
private static function cuePointCompare(time:Number, name:String, cuePoint:Object):Number {
var compTime1:Number = Math.round(time * 1000);
var compTime2:Number = Math.round(cuePoint.time * 1000);
if (compTime1 < compTime2) return -1;
if (compTime1 > compTime2) return 1;
if (name != null || name != undefined) {
if (name == cuePoint.name) return 0;
if (name < cuePoint.name) return -1;
return 1;
}
return 0;
}
/**
* <p>Search for a cue point in the given array at the given time
* and/or with given name.</p>
*
* @param closeIsOK If true, the behavior differs depending on the
* parameters passed in:
*
* <ul>
*
* <li>If name is null or undefined, then if the specific time is
* not found then the closest time earlier than that is returned.
* If there is no cue point earlier than time, the first cue point
* is returned.</li>
*
* <li>If time is null, undefined or less than 0 then the first
* cue point with the given name is returned.</li>
*
* <li>If time and name are both defined then the closest cue
* point, then if the specific time and name is not found then the
* closest time earlier than that with that name is returned. If
* there is no cue point with that name and with an earlier time,
* then the first cue point with that name is returned. If there
* is no cue point with that name, null is returned.</li>
*
* <li>If time is null, undefined or less than 0 and name is null
* or undefined, a VideoError is thrown.</li>
*
* </ul>
*
* <p>If closeIsOK is false the behavior is:</p>
*
* <ul>
*
* <li>If name is null or undefined and there is a cue point with
* exactly that time, it is returned. Otherwise null is
* returned.</li>
*
* <li>If time is null, undefined or less than 0 then the first
* cue point with the given name is returned.</li>
*
* <li>If time and name are both defined and there is a cue point
* with exactly that time and name, it is returned. Otherwise null
* is returned.</li>
*
* <li>If time is null, undefined or less than 0 and name is null
* or undefined, a VideoError is thrown.</li>
*
* </ul>
* @param timeOrCuePoint If String, then name for search. If
* Number, then time for search. If Object, then cuepoint object
* containing time and/or name parameters for search.
* @returns <code>null</code> if no match was found, otherwise
* copy of cuePoint object with additional properties:
*
* <ul>
*
* <li><code>array</code> - the array that was searched. Treat
* this array as read only as adding, removing or editing objects
* within it can cause cue points to malfunction.</li>
*
* <li><code>index</code> - the index into the array for the
* returned cuepoint.</li>
*
* </ul>
* @see #getCuePointIndex()
* @private
*/
function getCuePoint(cuePointArray:Array, closeIsOK:Boolean, timeNameOrCuePoint:Object):Object {
var cuePoint:Object;
switch (typeof timeNameOrCuePoint) {
case "string":
cuePoint = {name:timeNameOrCuePoint};
break;
case "number":
cuePoint = {time:timeNameOrCuePoint};
break;
case "object":
cuePoint = timeNameOrCuePoint;
break;
} // switch
var index:Number = getCuePointIndex(cuePointArray, closeIsOK, cuePoint.time, cuePoint.name);
if (index < 0) return null;
var cuePoint:Object = deepCopyObject(cuePointArray[index]);
cuePoint.array = cuePointArray;
cuePoint.index = index;
return cuePoint;
}
/**
* <p>Given a cue point object returned from getCuePoint (needs
* the index and array properties added to those cue points),
* returns the next cue point in that array after that one with
* the same name. Returns null if no cue point after that one
* with that name. Throws VideoError if argument is invalid.</p>
*
* @returns <code>null</code> if no match was found, otherwise
* copy of cuePoint object with additional properties:
*
* <ul>
*
* <li><code>array</code> - the array that was searched. Treat
* this array as read only as adding, removing or editing objects
* within it can cause cue points to malfunction.</li>
*
* <li><code>index</code> - the index into the array for the
* returned cuepoint.</li>
*
* </ul>
* @private
*/
function getNextCuePointWithName(cuePoint:Object):Object {
// sanity checks
if (cuePoint == null || cuePoint == undefined) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "cuePoint parameter undefined");
}
if (isNaN(cuePoint.time) || cuePoint.time < 0) {
throw new VideoError(VideoError.ILLEGAL_CUE_POINT, "time must be number");
}
// get index
var index:Number = getNextCuePointIndexWithName(cuePoint.name, cuePoint.array, cuePoint.index);
if (index < 0) return null;
// return copy
var returnCuePoint:Object = deepCopyObject(cuePoint.array[index]);
returnCuePoint.array = cuePoint.array;
returnCuePoint.index = index;
return returnCuePoint;
}
/**
* Used to make copies of cue point objects.
*
* @private
*/
private static function deepCopyObject(obj:Object, recurseLevel:Number):Object {
if (obj == undefined || obj == null || typeof obj != "object") return obj;
if (recurseLevel == undefined) recurseLevel = 0;
var newObj = new Object();
for (var i in obj) {
if (recurseLevel == 0 && (i == "array" || i == "index")) {
// skip it
} else if (typeof obj[i] == "object") {
newObj[i] = deepCopyObject(obj[i], recurseLevel+1);
} else {
newObj[i] = obj[i];
}
}
return newObj;
}
//ifdef DEBUG
//function debugTrace(s:String):Void {
// if (_owner != null && _owner != undefined) {
// _owner.debugTrace(s);
// }
//}
//
//function debugTraceCuePoint(name:String, obj:Object, indent:Number):Void {
// if (!_owner._debuggingOn) return;
// var indentString:String = "";
// for (var j:Number = 0; j < indent; j++) indentString += " ";
// var i;
// debugTrace(indentString + name + ": " + obj.name + " at " + obj.time + " type " + obj.type);
// if (obj.parameters != undefined) {
// debugTrace(indentString + "parameters:");
// for (i in obj.parameters) {
// debugTrace(indentString + " " + i + " = " + obj.parameters[i]);
// }
// }
//}
//function debugTraceProcessFLVCuePoints():Void {
// var i:Number;
// if (flvCuePoints != null && flvCuePoints != undefined && flvCuePoints.length > 0) {
// debugTrace("flvCuePoints:");
// for (i = 0; i < flvCuePoints.length; i++) {
// debugTrace(" flvCuePoints[" + i + "]");
// debugTraceCuePoint("flvCuePoints[" + i + "]", flvCuePoints[i], 2);
// }
// } else {
// debugTrace("No flv cue points!");
// }
// if (navCuePoints != null && navCuePoints != undefined && navCuePoints.length > 0) {
// debugTrace("navCuePoints:");
// for (i = 0; i < flvCuePoints.length; i++) {
// debugTrace(" navCuePoints[" + i + "]");
// debugTraceCuePoint("navCuePoints[" + i + "]", navCuePoints[i], 2);
// }
// } else {
// debugTrace("No nav cue points!");
// }
// if (eventCuePoints != null && eventCuePoints != undefined && eventCuePoints.length > 0) {
// debugTrace("eventCuePoints:");
// for (i = 0; i < eventCuePoints.length; i++) {
// debugTrace(" eventCuePoints[" + i + "]");
// debugTraceCuePoint("eventCuePoints[" + i + "]", eventCuePoints[i], 2);
// }
// } else {
// debugTrace("No event cue points!");
// }
// if (asCuePoints != null && asCuePoints != undefined && asCuePoints.length > 0) {
// debugTrace("asCuePoints:");
// for (i = 0; i < asCuePoints.length; i++) {
// debugTrace(" asCuePoints[" + i + "]");
// debugTraceCuePoint("asCuePoints[" + i + "]", asCuePoints[i], 2);
// }
// } else {
// debugTrace("No AS cue points!");
// }
// if (_disabledCuePoints != null && _disabledCuePoints != undefined && _disabledCuePoints.length > 0) {
// debugTrace("_disabledCuePoints:");
// for (i = 0; i < _disabledCuePoints.length; i++) {
// debugTrace(" _disabledCuePoints[" + i + "]");
// debugTraceCuePoint("_disabledCuePoints[" + i + "]", _disabledCuePoints[i], 2);
// }
// } else {
// debugTrace("No disabled cue points!");
// }
//}
//function debugCuePointSearchSuite():Void {
// if (!_owner._debuggingOn) return;
// debugTrace("Got metadata, doing search for cue points search suite");
// var cp:Object;
// var attempt:Number = 1;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(flvCuePoints, false);
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(flvCuePoints, true);
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(flvCuePoints, false, 15.07);
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(flvCuePoints, true, {time:15.07, name:"odd"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(navCuePoints, true, 15.07);
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(eventCuePoints, false, "e1");
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(flvCuePoints, false, {time:-1, name:"e1"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(navCuePoints, false, {time:20.015, name:"even"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(navCuePoints, true, {time:21, name:"even"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(navCuePoints, true, {time:30, name:"odd"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getNextCuePointWithName(cp);
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(navCuePoints, true, 3);
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(navCuePoints, true, {time:1000, name:"e4"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
// debugTrace("doing " + attempt);
// try {
// cp = getCuePoint(eventCuePoints, true, {time:1000, name:"e3"});
// if (cp == null) { debugTrace("cuePoint == null"); } else { debugTraceCuePoint("cuePoint", cp, 1); }
// } catch (err:Error) {
// debugTrace("Got error! " + err.message);
// }
// attempt++;
//}
//endif
} // class mx.video.CuePointManager
| cvs-admin | ViewVC Help |
| Powered by ViewVC 1.0.0 |