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,77 @@
package org.osmf.net.rtmpstreaming
{
import flash.utils.getTimer;
import org.osmf.net.NetStreamMetricsBase;
import org.osmf.net.SwitchingRuleBase;
public class DroppedFramesRule extends SwitchingRuleBase
{
private static const LOCK_INTERVAL:Number = 30000;
private var downSwitchByOne:int;
private var downSwitchByTwo:int;
private var downSwitchToZero:int;
private var lockLevel:Number;
private var lastLockTime:Number;
public function DroppedFramesRule(param1:NetStreamMetricsBase, param2:int = 10, param3:int = 20, param4:int = 24)
{
super(param1);
this.downSwitchByOne = param2;
this.downSwitchByTwo = param3;
this.downSwitchToZero = param4;
this.lastLockTime = 0;
this.lockLevel = int.MAX_VALUE;
}
override public function getNewIndex() : int
{
var _loc2_:String = null;
var _loc1_:int = -1;
if(metrics.averageDroppedFPS > this.downSwitchToZero)
{
_loc1_ = 0;
_loc2_ = "Average droppedFPS of " + Math.round(metrics.averageDroppedFPS) + " > " + this.downSwitchToZero;
}
else if(metrics.averageDroppedFPS > this.downSwitchByTwo)
{
_loc1_ = metrics.currentIndex - 2 < 0 ? 0 : int(metrics.currentIndex - 2);
_loc2_ = "Average droppedFPS of " + Math.round(metrics.averageDroppedFPS) + " > " + this.downSwitchByTwo;
}
else if(metrics.averageDroppedFPS > this.downSwitchByOne)
{
_loc1_ = metrics.currentIndex - 1 < 0 ? 0 : int(metrics.currentIndex - 1);
_loc2_ = "Average droppedFPS of " + Math.round(metrics.averageDroppedFPS) + " > " + this.downSwitchByOne;
}
if(_loc1_ != -1 && _loc1_ < metrics.currentIndex)
{
this.lockIndex(_loc1_);
}
if(_loc1_ == -1 && this.isLocked(metrics.currentIndex))
{
_loc1_ = metrics.currentIndex;
}
return _loc1_;
}
private function lockIndex(param1:int) : void
{
if(!this.isLocked(param1))
{
this.lockLevel = param1;
this.lastLockTime = getTimer();
}
}
private function isLocked(param1:int) : Boolean
{
return param1 >= this.lockLevel && getTimer() - this.lastLockTime < LOCK_INTERVAL;
}
}
}
@@ -0,0 +1,44 @@
package org.osmf.net.rtmpstreaming
{
import org.osmf.net.SwitchingRuleBase;
public class InsufficientBandwidthRule extends SwitchingRuleBase
{
private var bitrateMultiplier:Number;
public function InsufficientBandwidthRule(param1:RTMPNetStreamMetrics, param2:Number = 1.15)
{
super(param1);
this.bitrateMultiplier = param2;
}
override public function getNewIndex() : int
{
var _loc2_:String = null;
var _loc3_:* = 0;
var _loc1_:int = -1;
if(this.rtmpMetrics.averageMaxBytesPerSecond != 0)
{
_loc3_ = this.rtmpMetrics.currentIndex;
while(_loc3_ >= 0)
{
if(this.rtmpMetrics.averageMaxBytesPerSecond * 8 / 1024 > this.rtmpMetrics.resource.streamItems[_loc3_].bitrate * this.bitrateMultiplier)
{
_loc1_ = _loc3_;
break;
}
_loc3_--;
}
_loc1_ = _loc1_ == this.rtmpMetrics.currentIndex ? -1 : _loc1_;
}
return _loc1_;
}
private function get rtmpMetrics() : RTMPNetStreamMetrics
{
return metrics as RTMPNetStreamMetrics;
}
}
}
@@ -0,0 +1,60 @@
package org.osmf.net.rtmpstreaming
{
import flash.events.NetStatusEvent;
import org.osmf.net.NetStreamCodes;
import org.osmf.net.SwitchingRuleBase;
public class InsufficientBufferRule extends SwitchingRuleBase
{
private var _panic:Boolean;
private var _moreDetail:String;
private var minBufferLength:Number;
public function InsufficientBufferRule(param1:RTMPNetStreamMetrics, param2:Number = 2)
{
super(param1);
this._panic = false;
this.minBufferLength = param2;
param1.netStream.addEventListener(NetStatusEvent.NET_STATUS,this.monitorNetStatus,false,0,true);
}
override public function getNewIndex() : int
{
var _loc1_:int = -1;
if(this._panic || this.rtmpMetrics.netStream.bufferLength < this.minBufferLength && this.rtmpMetrics.netStream.bufferLength > this.rtmpMetrics.netStream.bufferTime)
{
_loc1_ = 0;
}
return _loc1_;
}
private function monitorNetStatus(param1:NetStatusEvent) : void
{
switch(param1.info.code)
{
case NetStreamCodes.NETSTREAM_BUFFER_FULL:
this._panic = false;
break;
case NetStreamCodes.NETSTREAM_BUFFER_EMPTY:
if(Math.round(this.rtmpMetrics.netStream.time) != 0)
{
this._panic = true;
this._moreDetail = "Buffer was empty";
}
break;
case NetStreamCodes.NETSTREAM_PLAY_INSUFFICIENTBW:
this._panic = true;
this._moreDetail = "Stream had insufficient bandwidth";
}
}
private function get rtmpMetrics() : RTMPNetStreamMetrics
{
return metrics as RTMPNetStreamMetrics;
}
}
}
@@ -0,0 +1,76 @@
package org.osmf.net.rtmpstreaming
{
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.NetStreamPlayOptions;
import flash.net.NetStreamPlayTransitions;
import org.osmf.media.MediaResourceBase;
import org.osmf.net.DynamicStreamingItem;
import org.osmf.net.DynamicStreamingResource;
import org.osmf.net.NetConnectionFactoryBase;
import org.osmf.net.NetLoader;
import org.osmf.net.NetStreamLoadTrait;
import org.osmf.net.NetStreamSwitchManager;
import org.osmf.net.NetStreamSwitchManagerBase;
import org.osmf.net.NetStreamUtils;
import org.osmf.net.SwitchingRuleBase;
public class RTMPDynamicStreamingNetLoader extends NetLoader
{
public function RTMPDynamicStreamingNetLoader(param1:NetConnectionFactoryBase = null)
{
super(param1);
}
override public function canHandleResource(param1:MediaResourceBase) : Boolean
{
var _loc2_:DynamicStreamingResource = param1 as DynamicStreamingResource;
return _loc2_ != null && NetStreamUtils.isRTMPStream(_loc2_.host) || Boolean(super.canHandleResource(param1));
}
override protected function createNetStreamSwitchManager(param1:NetConnection, param2:NetStream, param3:DynamicStreamingResource) : NetStreamSwitchManagerBase
{
var _loc4_:RTMPNetStreamMetrics = null;
if(param3 != null)
{
_loc4_ = new RTMPNetStreamMetrics(param2);
return new NetStreamSwitchManager(param1,param2,param3,_loc4_,this.getDefaultSwitchingRules(_loc4_));
}
return null;
}
private function getDefaultSwitchingRules(param1:RTMPNetStreamMetrics) : Vector.<SwitchingRuleBase>
{
var _loc2_:Vector.<SwitchingRuleBase> = new Vector.<SwitchingRuleBase>();
_loc2_.push(new SufficientBandwidthRule(param1));
_loc2_.push(new InsufficientBandwidthRule(param1));
_loc2_.push(new DroppedFramesRule(param1));
_loc2_.push(new InsufficientBufferRule(param1));
return _loc2_;
}
override protected function reconnectStream(param1:NetStreamLoadTrait) : void
{
var _loc3_:NetStreamPlayOptions = null;
var _loc4_:DynamicStreamingItem = null;
var _loc5_:String = null;
var _loc2_:DynamicStreamingResource = param1.resource as DynamicStreamingResource;
if(_loc2_ == null)
{
super.reconnectStream(param1);
}
else
{
_loc3_ = new NetStreamPlayOptions();
param1.netStream.attach(param1.connection);
_loc3_.transition = NetStreamPlayTransitions.RESUME;
_loc4_ = _loc2_.streamItems[param1.switchManager.currentIndex];
_loc5_ = _loc4_.streamName;
_loc3_.streamName = _loc5_;
param1.netStream.play2(_loc3_);
}
}
}
}
@@ -0,0 +1,65 @@
package org.osmf.net.rtmpstreaming
{
import flash.net.NetStream;
import org.osmf.net.NetStreamMetricsBase;
import org.osmf.net.StreamType;
public class RTMPNetStreamMetrics extends NetStreamMetricsBase
{
private static const DEFAULT_AVG_MAX_BYTES_SAMPLE_SIZE:Number = 50;
private var _averageMaxBytesPerSecondArray:Array;
private var _averageMaxBytesPerSecond:Number;
public function RTMPNetStreamMetrics(param1:NetStream)
{
super(param1);
this._averageMaxBytesPerSecondArray = new Array();
}
public function get averageMaxBytesPerSecond() : Number
{
return this._averageMaxBytesPerSecond;
}
override protected function calculateMetrics() : void
{
var maxBytesPerSecond:Number = NaN;
var totalMaxBytesPerSecond:Number = NaN;
var peakMaxBytesPerSecond:Number = NaN;
var b:uint = 0;
super.calculateMetrics();
try
{
maxBytesPerSecond = netStream.info.maxBytesPerSecond;
this._averageMaxBytesPerSecondArray.unshift(maxBytesPerSecond);
if(this._averageMaxBytesPerSecondArray.length > DEFAULT_AVG_MAX_BYTES_SAMPLE_SIZE)
{
this._averageMaxBytesPerSecondArray.pop();
}
totalMaxBytesPerSecond = 0;
peakMaxBytesPerSecond = 0;
b = 0;
while(b < this._averageMaxBytesPerSecondArray.length)
{
totalMaxBytesPerSecond += this._averageMaxBytesPerSecondArray[b];
peakMaxBytesPerSecond = this._averageMaxBytesPerSecondArray[b] > peakMaxBytesPerSecond ? Number(this._averageMaxBytesPerSecondArray[b]) : peakMaxBytesPerSecond;
b++;
}
this._averageMaxBytesPerSecond = this._averageMaxBytesPerSecondArray.length < DEFAULT_AVG_MAX_BYTES_SAMPLE_SIZE ? 0 : (this.isLive ? peakMaxBytesPerSecond : totalMaxBytesPerSecond / this._averageMaxBytesPerSecondArray.length);
}
catch(error:Error)
{
throw error;
}
}
private function get isLive() : Boolean
{
return Boolean(resource) && resource.streamType == StreamType.LIVE;
}
}
}
@@ -0,0 +1,52 @@
package org.osmf.net.rtmpstreaming
{
import org.osmf.net.SwitchingRuleBase;
public class SufficientBandwidthRule extends SwitchingRuleBase
{
private static const BANDWIDTH_SAFETY_MULTIPLE:Number = 1.15;
private static const MIN_DROPPED_FPS:int = 2;
public function SufficientBandwidthRule(param1:RTMPNetStreamMetrics)
{
super(param1);
}
override public function getNewIndex() : int
{
var _loc2_:String = null;
var _loc3_:* = 0;
var _loc1_:int = -1;
if(this.rtmpMetrics.averageMaxBytesPerSecond != 0)
{
_loc3_ = int(this.rtmpMetrics.resource.streamItems.length - 1);
while(_loc3_ >= 0)
{
if(this.rtmpMetrics.averageMaxBytesPerSecond * 8 / 1024 > this.rtmpMetrics.resource.streamItems[_loc3_].bitrate * BANDWIDTH_SAFETY_MULTIPLE)
{
_loc1_ = _loc3_;
break;
}
_loc3_--;
}
if(_loc1_ > this.rtmpMetrics.currentIndex)
{
_loc1_ = this.rtmpMetrics.droppedFPS < MIN_DROPPED_FPS && this.rtmpMetrics.netStream.bufferLength > this.rtmpMetrics.netStream.bufferTime ? _loc1_ : -1;
}
else
{
_loc1_ = -1;
}
}
return _loc1_;
}
private function get rtmpMetrics() : RTMPNetStreamMetrics
{
return metrics as RTMPNetStreamMetrics;
}
}
}