no commit message
This commit is contained in:
niandeng
@@ -0,0 +1,443 @@
|
||||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
package org.mangui.hls.controller {
|
||||
import flash.display.Stage;
|
||||
import org.mangui.hls.constant.HLSLoaderTypes;
|
||||
import org.mangui.hls.constant.HLSMaxLevelCappingMode;
|
||||
import org.mangui.hls.event.HLSEvent;
|
||||
import org.mangui.hls.event.HLSLoadMetrics;
|
||||
import org.mangui.hls.HLS;
|
||||
import org.mangui.hls.HLSSettings;
|
||||
import org.mangui.hls.model.Level;
|
||||
|
||||
CONFIG::LOGGING {
|
||||
import org.mangui.hls.utils.Log;
|
||||
}
|
||||
/** Class that manages auto level selection
|
||||
*
|
||||
* this is an implementation based on Serial segment fetching method from
|
||||
* http://www.cs.tut.fi/~moncef/publications/rate-adaptation-IC-2011.pdf
|
||||
*/
|
||||
public class LevelController {
|
||||
/** Reference to the HLS controller. **/
|
||||
private var _hls : HLS;
|
||||
/** switch up threshold **/
|
||||
private var _switchup : Vector.<Number> = null;
|
||||
/** switch down threshold **/
|
||||
private var _switchdown : Vector.<Number> = null;
|
||||
/** bitrate array **/
|
||||
private var _bitrate : Vector.<uint> = null;
|
||||
/** vector of levels with unique dimension with highest bandwidth **/
|
||||
private var _maxUniqueLevels : Vector.<Level> = null;
|
||||
/** nb level **/
|
||||
private var _nbLevel : int = 0;
|
||||
private var _lastSegmentDuration : Number;
|
||||
private var _lastFetchDuration : Number;
|
||||
private var lastBandwidth : int;
|
||||
private var _autoLevelCapping : int;
|
||||
private var _startLevel : int = -1;
|
||||
private var _fpsController : FPSController;
|
||||
|
||||
/** Create the loader. **/
|
||||
public function LevelController(hls : HLS) : void {
|
||||
_hls = hls;
|
||||
_fpsController = new FPSController(hls);
|
||||
/* low priority listener, so that other listeners with default priority
|
||||
could seamlessly set hls.startLevel in their HLSEvent.MANIFEST_PARSED listener */
|
||||
_hls.addEventListener(HLSEvent.MANIFEST_PARSED, _manifestParsedHandler, false, int.MIN_VALUE);
|
||||
_hls.addEventListener(HLSEvent.MANIFEST_LOADED, _manifestLoadedHandler);
|
||||
_hls.addEventListener(HLSEvent.FRAGMENT_LOADED, _fragmentLoadedHandler);
|
||||
_hls.addEventListener(HLSEvent.FRAGMENT_LOAD_EMERGENCY_ABORTED, _fragmentLoadedHandler);
|
||||
}
|
||||
;
|
||||
|
||||
public function dispose() : void {
|
||||
_fpsController.dispose();
|
||||
_fpsController = null;
|
||||
_hls.removeEventListener(HLSEvent.MANIFEST_PARSED, _manifestParsedHandler);
|
||||
_hls.removeEventListener(HLSEvent.MANIFEST_LOADED, _manifestLoadedHandler);
|
||||
_hls.removeEventListener(HLSEvent.FRAGMENT_LOADED, _fragmentLoadedHandler);
|
||||
_hls.removeEventListener(HLSEvent.FRAGMENT_LOAD_EMERGENCY_ABORTED, _fragmentLoadedHandler);
|
||||
}
|
||||
|
||||
private function _fragmentLoadedHandler(event : HLSEvent) : void {
|
||||
var metrics : HLSLoadMetrics = event.loadMetrics;
|
||||
// only monitor main fragment metrics for level switching
|
||||
if(metrics.type == HLSLoaderTypes.FRAGMENT_MAIN) {
|
||||
lastBandwidth = metrics.bandwidth;
|
||||
_lastSegmentDuration = metrics.duration;
|
||||
_lastFetchDuration = metrics.processing_duration;
|
||||
}
|
||||
}
|
||||
|
||||
private function _manifestParsedHandler(event : HLSEvent) : void {
|
||||
if(HLSSettings.autoStartLoad) {
|
||||
// upon manifest parsed event, trigger a level switch to load startLevel playlist
|
||||
_hls.dispatchEvent(new HLSEvent(HLSEvent.LEVEL_SWITCH, startLevel));
|
||||
}
|
||||
}
|
||||
|
||||
private function _manifestLoadedHandler(event : HLSEvent) : void {
|
||||
var levels : Vector.<Level> = event.levels;
|
||||
var maxswitchup : Number = 0;
|
||||
var minswitchdwown : Number = Number.MAX_VALUE;
|
||||
_nbLevel = levels.length;
|
||||
_bitrate = new Vector.<uint>(_nbLevel, true);
|
||||
_switchup = new Vector.<Number>(_nbLevel, true);
|
||||
_switchdown = new Vector.<Number>(_nbLevel, true);
|
||||
_autoLevelCapping = -1;
|
||||
_lastSegmentDuration = 0;
|
||||
_lastFetchDuration = 0;
|
||||
lastBandwidth = 0;
|
||||
|
||||
var i : int;
|
||||
|
||||
for (i = 0; i < _nbLevel; i++) {
|
||||
_bitrate[i] = levels[i].bitrate;
|
||||
}
|
||||
|
||||
for (i = 0; i < _nbLevel - 1; i++) {
|
||||
_switchup[i] = (_bitrate[i + 1] - _bitrate[i]) / _bitrate[i];
|
||||
maxswitchup = Math.max(maxswitchup, _switchup[i]);
|
||||
}
|
||||
for (i = 0; i < _nbLevel - 1; i++) {
|
||||
_switchup[i] = Math.min(maxswitchup, 2 * _switchup[i]);
|
||||
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("_switchup[" + i + "]=" + _switchup[i]);
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 1; i < _nbLevel; i++) {
|
||||
_switchdown[i] = (_bitrate[i] - _bitrate[i - 1]) / _bitrate[i];
|
||||
minswitchdwown = Math.min(minswitchdwown, _switchdown[i]);
|
||||
}
|
||||
for (i = 1; i < _nbLevel; i++) {
|
||||
_switchdown[i] = Math.max(2 * minswitchdwown, _switchdown[i]);
|
||||
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("_switchdown[" + i + "]=" + _switchdown[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if (HLSSettings.capLevelToStage) {
|
||||
_maxUniqueLevels = _maxLevelsWithUniqueDimensions;
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
public function getAutoStartBestLevel(downloadBandwidth : int, initialDelay : int, lastSegmentDuration : int) : int {
|
||||
var bwFactor : Number;
|
||||
var max_level : int = _maxLevel;
|
||||
// in case initial delay is capped
|
||||
if(HLSSettings.autoStartMaxDuration != -1) {
|
||||
// if we are above initial delay, stick to level 0
|
||||
if(initialDelay >= HLSSettings.autoStartMaxDuration) {
|
||||
return 0;
|
||||
} else {
|
||||
// if we still have some time to load another fragment, determine load factor:
|
||||
// if we have 10000ms fragment, and we have 1000s left, we need a bw 10 times bigger to accomodate
|
||||
bwFactor = lastSegmentDuration/(HLSSettings.autoStartMaxDuration-initialDelay);
|
||||
}
|
||||
} else {
|
||||
bwFactor = 1;
|
||||
}
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("getAutoStartBestLevel,initialDelay/max delay/bwFactor=" + initialDelay + "/" + HLSSettings.autoStartMaxDuration + "/" + bwFactor.toFixed(2));
|
||||
}
|
||||
for (var i : int = max_level; i >= 0; i--) {
|
||||
if (_bitrate[i]*bwFactor <= downloadBandwidth) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
private function get _maxLevelsWithUniqueDimensions() : Vector.<Level> {
|
||||
var filter : Function = function(l : Level, i : int, v : Vector.<Level>) : Boolean {
|
||||
if (l.width > 0 && l.height > 0) {
|
||||
if (i + 1 < v.length) {
|
||||
var nextLevel : Level = v[i + 1];
|
||||
if (l.width != nextLevel.width && l.height != nextLevel.height) {
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
return _hls.levels.filter(filter);
|
||||
}
|
||||
|
||||
|
||||
/** Return the capping/max level value that could be used by automatic level selection algorithm **/
|
||||
public function get autoLevelCapping() : int {
|
||||
return _autoLevelCapping;
|
||||
}
|
||||
|
||||
/** set the capping/max level value that could be used by automatic level selection algorithm **/
|
||||
public function set autoLevelCapping(newLevel : int) : void {
|
||||
_autoLevelCapping = newLevel;
|
||||
}
|
||||
|
||||
private function get _maxLevel() : int {
|
||||
// if set, _autoLevelCapping takes precedence
|
||||
if(_autoLevelCapping >= 0) {
|
||||
return Math.min(_nbLevel - 1, _autoLevelCapping);
|
||||
} else if (HLSSettings.capLevelToStage) {
|
||||
var maxLevelsCount : int = _maxUniqueLevels.length;
|
||||
|
||||
if (_hls.stage && maxLevelsCount) {
|
||||
var maxLevel : Level = this._maxUniqueLevels[0],
|
||||
maxLevelIdx : int = maxLevel.index,
|
||||
stage : Stage = _hls.stage,
|
||||
sWidth : Number = stage.stageWidth,
|
||||
sHeight : Number = stage.stageHeight,
|
||||
lWidth : int,
|
||||
lHeight : int,
|
||||
i : int;
|
||||
|
||||
// retina display support
|
||||
// contentsScaleFactor was added in FP11.5, but this allows us to include the option in all builds
|
||||
try {
|
||||
var contentsScaleFactor : int = stage['contentsScaleFactor'];
|
||||
sWidth*=contentsScaleFactor;
|
||||
sHeight*=contentsScaleFactor;
|
||||
} catch(e : Error) {
|
||||
// Ignore errors, we're running in FP < 11.5
|
||||
}
|
||||
|
||||
|
||||
switch (HLSSettings.maxLevelCappingMode) {
|
||||
case HLSMaxLevelCappingMode.UPSCALE:
|
||||
for (i = maxLevelsCount - 1; i >= 0; i--) {
|
||||
maxLevel = this._maxUniqueLevels[i];
|
||||
maxLevelIdx = maxLevel.index;
|
||||
lWidth = maxLevel.width;
|
||||
lHeight = maxLevel.height;
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("stage size: " + sWidth + "x" + sHeight + " ,level" + maxLevelIdx + " size: " + lWidth + "x" + lHeight);
|
||||
}
|
||||
if (sWidth >= lWidth || sHeight >= lHeight) {
|
||||
break;
|
||||
// from for loop
|
||||
}
|
||||
}
|
||||
break;
|
||||
case HLSMaxLevelCappingMode.DOWNSCALE:
|
||||
for (i = 0; i < maxLevelsCount; i++) {
|
||||
maxLevel = this._maxUniqueLevels[i];
|
||||
maxLevelIdx = maxLevel.index;
|
||||
lWidth = maxLevel.width;
|
||||
lHeight = maxLevel.height;
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("stage size: " + sWidth + "x" + sHeight + " ,level" + maxLevelIdx + " size: " + lWidth + "x" + lHeight);
|
||||
}
|
||||
if (sWidth <= lWidth || sHeight <= lHeight) {
|
||||
break;
|
||||
// from for loop
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("max capped level idx: " + maxLevelIdx);
|
||||
}
|
||||
}
|
||||
return maxLevelIdx;
|
||||
} else {
|
||||
return _nbLevel - 1;
|
||||
}
|
||||
}
|
||||
|
||||
/** Update the quality level for the next fragment load. **/
|
||||
public function getnextlevel(current_level : int, buffer : Number) : int {
|
||||
if (_lastFetchDuration == 0 || _lastSegmentDuration == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* rsft : remaining segment fetch time : available time to fetch next segment
|
||||
it depends on the current playback timestamp , the timestamp of the first frame of the next segment
|
||||
and TBMT, indicating a desired latency between the time instant to receive the last byte of a
|
||||
segment to the playback of the first media frame of a segment
|
||||
buffer is start time of next segment
|
||||
TBMT is the buffer size we need to ensure (we need at least 2 segments buffered */
|
||||
var rsft : Number = 1000 * buffer - 2 * _lastFetchDuration;
|
||||
var sftm : Number = Math.min(_lastSegmentDuration, rsft) / _lastFetchDuration;
|
||||
var max_level : Number = _maxLevel;
|
||||
var switch_to_level : int = current_level;
|
||||
// CONFIG::LOGGING {
|
||||
// Log.info("rsft:" + rsft);
|
||||
// Log.info("sftm:" + sftm);
|
||||
// }
|
||||
// }
|
||||
/* to switch level up :
|
||||
rsft should be greater than switch up condition
|
||||
*/
|
||||
if ((current_level < max_level) && (sftm > (1 + _switchup[current_level]))) {
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("sftm:> 1+_switchup[_level]=" + (1 + _switchup[current_level]));
|
||||
}
|
||||
switch_to_level = current_level + 1;
|
||||
}
|
||||
|
||||
/* to switch level down :
|
||||
rsft should be smaller than switch up condition,
|
||||
or the current level is greater than max level
|
||||
*/ else if ((current_level > max_level && current_level > 0) || (current_level > 0 && (sftm < 1 - _switchdown[current_level]))) {
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("sftm < 1-_switchdown[current_level]=" + _switchdown[current_level]);
|
||||
}
|
||||
var bufferratio : Number = 1000 * buffer / _lastSegmentDuration;
|
||||
/* find suitable level matching current bandwidth, starting from current level
|
||||
when switching level down, we also need to consider that we might need to load two fragments.
|
||||
the condition (bufferratio > 2*_levels[j].bitrate/_lastBandwidth)
|
||||
ensures that buffer time is bigger than than the time to download 2 fragments from level j, if we keep same bandwidth.
|
||||
*/
|
||||
|
||||
for (var j : int = current_level - 1; j >= 0; j--) {
|
||||
if (_bitrate[j] <= lastBandwidth && (bufferratio > 2 * _bitrate[j] / lastBandwidth)) {
|
||||
switch_to_level = j;
|
||||
break;
|
||||
}
|
||||
if (j == 0) {
|
||||
switch_to_level = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Then we should check if selected level is higher than max_level if so, than take the min of those two
|
||||
switch_to_level = Math.min(max_level, switch_to_level);
|
||||
|
||||
CONFIG::LOGGING {
|
||||
if (switch_to_level != current_level) {
|
||||
Log.debug("switch to level " + switch_to_level);
|
||||
}
|
||||
}
|
||||
|
||||
return switch_to_level;
|
||||
}
|
||||
|
||||
// get level index of first level appearing in the manifest
|
||||
public function get firstLevel() : int {
|
||||
var levels : Vector.<Level> = _hls.levels;
|
||||
for (var i : int = 0; i < levels.length; i++) {
|
||||
if (levels[i].manifest_index == 0) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
public function isStartLevelSet() : Boolean {
|
||||
return (_startLevel >=0);
|
||||
}
|
||||
|
||||
/* set the quality level used when starting a fresh playback */
|
||||
public function set startLevel(level : int) : void {
|
||||
_startLevel = level;
|
||||
};
|
||||
|
||||
public function get startLevel() : int {
|
||||
var start_level : int = -1;
|
||||
var levels : Vector.<Level> = _hls.levels;
|
||||
if (levels) {
|
||||
// if set, _startLevel takes precedence
|
||||
if(_startLevel >=0) {
|
||||
return Math.min(levels.length-1,_startLevel);
|
||||
} else if (HLSSettings.startFromLevel === -2) {
|
||||
// playback will start from the first level appearing in Manifest (not sorted by bitrate)
|
||||
return firstLevel;
|
||||
} else if (HLSSettings.startFromLevel === -1 && HLSSettings.startFromBitrate === -1) {
|
||||
/* if startFromLevel is set to -1, it means that effective startup level
|
||||
* will be determined from first segment download bandwidth
|
||||
* let's use lowest bitrate for this download bandwidth assessment
|
||||
* this should speed up playback start time
|
||||
*/
|
||||
return 0;
|
||||
} else {
|
||||
// set up start level as being the lowest non-audio level.
|
||||
for (var i : int = 0; i < levels.length; i++) {
|
||||
if (!levels[i].audio) {
|
||||
start_level = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// in case of audio only playlist, force startLevel to 0
|
||||
if (start_level == -1) {
|
||||
CONFIG::LOGGING {
|
||||
Log.info("playlist is audio-only");
|
||||
}
|
||||
start_level = 0;
|
||||
} else {
|
||||
if (HLSSettings.startFromBitrate > 0) {
|
||||
start_level = findIndexOfClosestLevel(HLSSettings.startFromBitrate);
|
||||
} else if (HLSSettings.startFromLevel > 0) {
|
||||
// adjust start level using a rule by 3
|
||||
start_level += Math.round(HLSSettings.startFromLevel * (levels.length - start_level - 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("start level :" + start_level);
|
||||
}
|
||||
}
|
||||
return start_level;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param desiredBitrate
|
||||
* @return The index of the level that has a bitrate closest to the desired bitrate.
|
||||
*/
|
||||
private function findIndexOfClosestLevel(desiredBitrate : Number) : int {
|
||||
var levelIndex : int = -1;
|
||||
var minDistance : Number = Number.MAX_VALUE;
|
||||
var levels : Vector.<Level> = _hls.levels;
|
||||
|
||||
for (var index : int = 0; index < levels.length; index++) {
|
||||
var level : Level = levels[index];
|
||||
|
||||
var distance : Number = Math.abs(desiredBitrate - level.bitrate);
|
||||
|
||||
if (distance < minDistance) {
|
||||
levelIndex = index;
|
||||
minDistance = distance;
|
||||
}
|
||||
}
|
||||
return levelIndex;
|
||||
}
|
||||
|
||||
public function get seekLevel() : int {
|
||||
var seek_level : int = -1;
|
||||
var levels : Vector.<Level> = _hls.levels;
|
||||
if (HLSSettings.seekFromLevel == -1) {
|
||||
// keep last level, but don't exceed _maxLevel
|
||||
return Math.min(_hls.loadLevel,_maxLevel);
|
||||
}
|
||||
|
||||
// set up seek level as being the lowest non-audio level.
|
||||
for (var i : int = 0; i < levels.length; i++) {
|
||||
if (!levels[i].audio) {
|
||||
seek_level = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// in case of audio only playlist, force seek_level to 0
|
||||
if (seek_level == -1) {
|
||||
seek_level = 0;
|
||||
} else {
|
||||
if (HLSSettings.seekFromLevel > 0) {
|
||||
// adjust start level using a rule by 3
|
||||
seek_level += Math.round(HLSSettings.seekFromLevel * (levels.length - seek_level - 1));
|
||||
}
|
||||
}
|
||||
CONFIG::LOGGING {
|
||||
Log.debug("seek level :" + seek_level);
|
||||
}
|
||||
return seek_level;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user