mirror of https://bitbucket.org/ausocean/av.git
mjpeg-player: adding back files
This commit is contained in:
Trek H
parent
6ed6d1c28b
commit
31dc50a4a2
|
|
@ -0,0 +1,336 @@
|
|||
'use strict';
|
||||
|
||||
var has = Object.prototype.hasOwnProperty
|
||||
, prefix = '~';
|
||||
|
||||
/**
|
||||
* Constructor to create a storage for our `EE` objects.
|
||||
* An `Events` instance is a plain object whose properties are event names.
|
||||
*
|
||||
* @constructor
|
||||
* @private
|
||||
*/
|
||||
function Events() {}
|
||||
|
||||
//
|
||||
// We try to not inherit from `Object.prototype`. In some engines creating an
|
||||
// instance in this way is faster than calling `Object.create(null)` directly.
|
||||
// If `Object.create(null)` is not supported we prefix the event names with a
|
||||
// character to make sure that the built-in object properties are not
|
||||
// overridden or used as an attack vector.
|
||||
//
|
||||
if (Object.create) {
|
||||
Events.prototype = Object.create(null);
|
||||
|
||||
//
|
||||
// This hack is needed because the `__proto__` property is still inherited in
|
||||
// some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
|
||||
//
|
||||
if (!new Events().__proto__) prefix = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Representation of a single event listener.
|
||||
*
|
||||
* @param {Function} fn The listener function.
|
||||
* @param {*} context The context to invoke the listener with.
|
||||
* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
|
||||
* @constructor
|
||||
* @private
|
||||
*/
|
||||
function EE(fn, context, once) {
|
||||
this.fn = fn;
|
||||
this.context = context;
|
||||
this.once = once || false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a listener for a given event.
|
||||
*
|
||||
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @param {Function} fn The listener function.
|
||||
* @param {*} context The context to invoke the listener with.
|
||||
* @param {Boolean} once Specify if the listener is a one-time listener.
|
||||
* @returns {EventEmitter}
|
||||
* @private
|
||||
*/
|
||||
function addListener(emitter, event, fn, context, once) {
|
||||
if (typeof fn !== 'function') {
|
||||
throw new TypeError('The listener must be a function');
|
||||
}
|
||||
|
||||
var listener = new EE(fn, context || emitter, once)
|
||||
, evt = prefix ? prefix + event : event;
|
||||
|
||||
if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
|
||||
else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
|
||||
else emitter._events[evt] = [emitter._events[evt], listener];
|
||||
|
||||
return emitter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear event by name.
|
||||
*
|
||||
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
|
||||
* @param {(String|Symbol)} evt The Event name.
|
||||
* @private
|
||||
*/
|
||||
function clearEvent(emitter, evt) {
|
||||
if (--emitter._eventsCount === 0) emitter._events = new Events();
|
||||
else delete emitter._events[evt];
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimal `EventEmitter` interface that is molded against the Node.js
|
||||
* `EventEmitter` interface.
|
||||
*
|
||||
* @constructor
|
||||
* @public
|
||||
*/
|
||||
function EventEmitter() {
|
||||
this._events = new Events();
|
||||
this._eventsCount = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return an array listing the events for which the emitter has registered
|
||||
* listeners.
|
||||
*
|
||||
* @returns {Array}
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.eventNames = function eventNames() {
|
||||
var names = []
|
||||
, events
|
||||
, name;
|
||||
|
||||
if (this._eventsCount === 0) return names;
|
||||
|
||||
for (name in (events = this._events)) {
|
||||
if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
|
||||
}
|
||||
|
||||
if (Object.getOwnPropertySymbols) {
|
||||
return names.concat(Object.getOwnPropertySymbols(events));
|
||||
}
|
||||
|
||||
return names;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the listeners registered for a given event.
|
||||
*
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @returns {Array} The registered listeners.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.listeners = function listeners(event) {
|
||||
var evt = prefix ? prefix + event : event
|
||||
, handlers = this._events[evt];
|
||||
|
||||
if (!handlers) return [];
|
||||
if (handlers.fn) return [handlers.fn];
|
||||
|
||||
for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
|
||||
ee[i] = handlers[i].fn;
|
||||
}
|
||||
|
||||
return ee;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the number of listeners listening to a given event.
|
||||
*
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @returns {Number} The number of listeners.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.listenerCount = function listenerCount(event) {
|
||||
var evt = prefix ? prefix + event : event
|
||||
, listeners = this._events[evt];
|
||||
|
||||
if (!listeners) return 0;
|
||||
if (listeners.fn) return 1;
|
||||
return listeners.length;
|
||||
};
|
||||
|
||||
/**
|
||||
* Calls each of the listeners registered for a given event.
|
||||
*
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @returns {Boolean} `true` if the event had listeners, else `false`.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
|
||||
var evt = prefix ? prefix + event : event;
|
||||
|
||||
if (!this._events[evt]) return false;
|
||||
|
||||
var listeners = this._events[evt]
|
||||
, len = arguments.length
|
||||
, args
|
||||
, i;
|
||||
|
||||
if (listeners.fn) {
|
||||
if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
|
||||
|
||||
switch (len) {
|
||||
case 1: return listeners.fn.call(listeners.context), true;
|
||||
case 2: return listeners.fn.call(listeners.context, a1), true;
|
||||
case 3: return listeners.fn.call(listeners.context, a1, a2), true;
|
||||
case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
|
||||
case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
|
||||
case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
|
||||
}
|
||||
|
||||
for (i = 1, args = new Array(len -1); i < len; i++) {
|
||||
args[i - 1] = arguments[i];
|
||||
}
|
||||
|
||||
listeners.fn.apply(listeners.context, args);
|
||||
} else {
|
||||
var length = listeners.length
|
||||
, j;
|
||||
|
||||
for (i = 0; i < length; i++) {
|
||||
if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
|
||||
|
||||
switch (len) {
|
||||
case 1: listeners[i].fn.call(listeners[i].context); break;
|
||||
case 2: listeners[i].fn.call(listeners[i].context, a1); break;
|
||||
case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
|
||||
case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
|
||||
default:
|
||||
if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
|
||||
args[j - 1] = arguments[j];
|
||||
}
|
||||
|
||||
listeners[i].fn.apply(listeners[i].context, args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Add a listener for a given event.
|
||||
*
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @param {Function} fn The listener function.
|
||||
* @param {*} [context=this] The context to invoke the listener with.
|
||||
* @returns {EventEmitter} `this`.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.on = function on(event, fn, context) {
|
||||
return addListener(this, event, fn, context, false);
|
||||
};
|
||||
|
||||
/**
|
||||
* Add a one-time listener for a given event.
|
||||
*
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @param {Function} fn The listener function.
|
||||
* @param {*} [context=this] The context to invoke the listener with.
|
||||
* @returns {EventEmitter} `this`.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.once = function once(event, fn, context) {
|
||||
return addListener(this, event, fn, context, true);
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove the listeners of a given event.
|
||||
*
|
||||
* @param {(String|Symbol)} event The event name.
|
||||
* @param {Function} fn Only remove the listeners that match this function.
|
||||
* @param {*} context Only remove the listeners that have this context.
|
||||
* @param {Boolean} once Only remove one-time listeners.
|
||||
* @returns {EventEmitter} `this`.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
|
||||
var evt = prefix ? prefix + event : event;
|
||||
|
||||
if (!this._events[evt]) return this;
|
||||
if (!fn) {
|
||||
clearEvent(this, evt);
|
||||
return this;
|
||||
}
|
||||
|
||||
var listeners = this._events[evt];
|
||||
|
||||
if (listeners.fn) {
|
||||
if (
|
||||
listeners.fn === fn &&
|
||||
(!once || listeners.once) &&
|
||||
(!context || listeners.context === context)
|
||||
) {
|
||||
clearEvent(this, evt);
|
||||
}
|
||||
} else {
|
||||
for (var i = 0, events = [], length = listeners.length; i < length; i++) {
|
||||
if (
|
||||
listeners[i].fn !== fn ||
|
||||
(once && !listeners[i].once) ||
|
||||
(context && listeners[i].context !== context)
|
||||
) {
|
||||
events.push(listeners[i]);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Reset the array, or remove it completely if we have no more listeners.
|
||||
//
|
||||
if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
|
||||
else clearEvent(this, evt);
|
||||
}
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove all listeners, or those of the specified event.
|
||||
*
|
||||
* @param {(String|Symbol)} [event] The event name.
|
||||
* @returns {EventEmitter} `this`.
|
||||
* @public
|
||||
*/
|
||||
EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
|
||||
var evt;
|
||||
|
||||
if (event) {
|
||||
evt = prefix ? prefix + event : event;
|
||||
if (this._events[evt]) clearEvent(this, evt);
|
||||
} else {
|
||||
this._events = new Events();
|
||||
this._eventsCount = 0;
|
||||
}
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
//
|
||||
// Alias methods names because people roll like that.
|
||||
//
|
||||
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
|
||||
EventEmitter.prototype.addListener = EventEmitter.prototype.on;
|
||||
|
||||
//
|
||||
// Expose the prefix.
|
||||
//
|
||||
EventEmitter.prefixed = prefix;
|
||||
|
||||
//
|
||||
// Allow `EventEmitter` to be imported as module namespace.
|
||||
//
|
||||
EventEmitter.EventEmitter = EventEmitter;
|
||||
|
||||
//
|
||||
// Expose the module.
|
||||
//
|
||||
if ('undefined' !== typeof module) {
|
||||
module.exports = EventEmitter;
|
||||
}
|
||||
|
|
@ -0,0 +1,264 @@
|
|||
/**
|
||||
* HLS config
|
||||
*/
|
||||
|
||||
import AbrController from './controller/abr-controller';
|
||||
import BufferController from './controller/buffer-controller';
|
||||
import CapLevelController from './controller/cap-level-controller';
|
||||
import FPSController from './controller/fps-controller';
|
||||
import XhrLoader from './utils/xhr-loader';
|
||||
// import FetchLoader from './utils/fetch-loader';
|
||||
|
||||
import AudioTrackController from './controller/audio-track-controller';
|
||||
import AudioStreamController from './controller/audio-stream-controller';
|
||||
|
||||
import * as Cues from './utils/cues';
|
||||
import TimelineController from './controller/timeline-controller';
|
||||
import SubtitleTrackController from './controller/subtitle-track-controller';
|
||||
import { SubtitleStreamController } from './controller/subtitle-stream-controller';
|
||||
import EMEController from './controller/eme-controller';
|
||||
import { requestMediaKeySystemAccess, MediaKeyFunc } from './utils/mediakeys-helper';
|
||||
|
||||
type ABRControllerConfig = {
|
||||
abrEwmaFastLive: number,
|
||||
abrEwmaSlowLive: number,
|
||||
abrEwmaFastVoD: number,
|
||||
abrEwmaSlowVoD: number,
|
||||
abrEwmaDefaultEstimate: number,
|
||||
abrBandWidthFactor: number,
|
||||
abrBandWidthUpFactor: number,
|
||||
abrMaxWithRealBitrate: boolean,
|
||||
maxStarvationDelay: number,
|
||||
maxLoadingDelay: number,
|
||||
};
|
||||
|
||||
export type BufferControllerConfig = {
|
||||
appendErrorMaxRetry: number,
|
||||
liveDurationInfinity: boolean,
|
||||
liveBackBufferLength: number,
|
||||
};
|
||||
|
||||
type CapLevelControllerConfig = {
|
||||
capLevelToPlayerSize: boolean
|
||||
};
|
||||
|
||||
export type EMEControllerConfig = {
|
||||
licenseXhrSetup?: (xhr: XMLHttpRequest, url: string) => void,
|
||||
emeEnabled: boolean,
|
||||
widevineLicenseUrl?: string,
|
||||
requestMediaKeySystemAccessFunc: MediaKeyFunc | null,
|
||||
};
|
||||
|
||||
type FragmentLoaderConfig = {
|
||||
fLoader: any, // TODO(typescript-loader): Once Loader is typed fill this in
|
||||
|
||||
fragLoadingTimeOut: number,
|
||||
fragLoadingMaxRetry: number,
|
||||
fragLoadingRetryDelay: number,
|
||||
fragLoadingMaxRetryTimeout: number,
|
||||
};
|
||||
|
||||
type FPSControllerConfig = {
|
||||
capLevelOnFPSDrop: boolean,
|
||||
fpsDroppedMonitoringPeriod: number,
|
||||
fpsDroppedMonitoringThreshold: number,
|
||||
};
|
||||
|
||||
type LevelControllerConfig = {
|
||||
startLevel?: number
|
||||
};
|
||||
|
||||
type MP4RemuxerConfig = {
|
||||
stretchShortVideoTrack: boolean,
|
||||
maxAudioFramesDrift: number,
|
||||
};
|
||||
|
||||
type PlaylistLoaderConfig = {
|
||||
pLoader: any, // TODO(typescript-loader): Once Loader is typed fill this in
|
||||
|
||||
manifestLoadingTimeOut: number,
|
||||
manifestLoadingMaxRetry: number,
|
||||
manifestLoadingRetryDelay: number,
|
||||
manifestLoadingMaxRetryTimeout: number,
|
||||
|
||||
levelLoadingTimeOut: number,
|
||||
levelLoadingMaxRetry: number,
|
||||
levelLoadingRetryDelay: number,
|
||||
levelLoadingMaxRetryTimeout: number
|
||||
};
|
||||
|
||||
type StreamControllerConfig = {
|
||||
autoStartLoad: boolean,
|
||||
startPosition: number,
|
||||
defaultAudioCodec?: string,
|
||||
initialLiveManifestSize: number,
|
||||
maxBufferLength: number,
|
||||
maxBufferSize: number,
|
||||
maxBufferHole: number,
|
||||
|
||||
lowBufferWatchdogPeriod: number,
|
||||
highBufferWatchdogPeriod: number,
|
||||
nudgeOffset: number,
|
||||
nudgeMaxRetry: number,
|
||||
maxFragLookUpTolerance: number,
|
||||
liveSyncDurationCount: number,
|
||||
liveMaxLatencyDurationCount: number,
|
||||
liveSyncDuration?: number,
|
||||
liveMaxLatencyDuration?: number,
|
||||
maxMaxBufferLength: number,
|
||||
|
||||
startFragPrefetch: boolean,
|
||||
};
|
||||
|
||||
type TimelineControllerConfig = {
|
||||
cueHandler: any, // TODO(typescript-cues): Type once file is done
|
||||
enableCEA708Captions: boolean,
|
||||
enableWebVTT: boolean,
|
||||
captionsTextTrack1Label: string,
|
||||
captionsTextTrack1LanguageCode: string,
|
||||
captionsTextTrack2Label: string,
|
||||
captionsTextTrack2LanguageCode: string,
|
||||
};
|
||||
|
||||
type TSDemuxerConfig = {
|
||||
forceKeyFrameOnDiscontinuity: boolean,
|
||||
};
|
||||
|
||||
export type HlsConfig =
|
||||
{
|
||||
debug: boolean,
|
||||
enableWorker: boolean,
|
||||
enableSoftwareAES: boolean,
|
||||
minAutoBitrate: number,
|
||||
loader: any, // TODO(typescript-xhrloader): Type once XHR is done
|
||||
xhrSetup?: (xhr: XMLHttpRequest, url: string) => void,
|
||||
|
||||
// Alt Audio
|
||||
audioStreamController?: any, // TODO(typescript-audiostreamcontroller): Type once file is done
|
||||
audioTrackController?: any, // TODO(typescript-audiotrackcontroller): Type once file is done
|
||||
// Subtitle
|
||||
subtitleStreamController?: any, // TODO(typescript-subtitlestreamcontroller): Type once file is done
|
||||
subtitleTrackController?: any, // TODO(typescript-subtitletrackcontroller): Type once file is done
|
||||
timelineController?: any, // TODO(typescript-timelinecontroller): Type once file is done
|
||||
// EME
|
||||
emeController?: typeof EMEController,
|
||||
|
||||
abrController: any, // TODO(typescript-abrcontroller): Type once file is done
|
||||
bufferController: typeof BufferController,
|
||||
capLevelController: any, // TODO(typescript-caplevelcontroller): Type once file is done
|
||||
fpsController: any, // TODO(typescript-fpscontroller): Type once file is done
|
||||
} &
|
||||
ABRControllerConfig &
|
||||
BufferControllerConfig &
|
||||
CapLevelControllerConfig &
|
||||
EMEControllerConfig &
|
||||
FPSControllerConfig &
|
||||
FragmentLoaderConfig &
|
||||
LevelControllerConfig &
|
||||
MP4RemuxerConfig &
|
||||
PlaylistLoaderConfig &
|
||||
StreamControllerConfig &
|
||||
Partial<TimelineControllerConfig> &
|
||||
TSDemuxerConfig;
|
||||
|
||||
// If possible, keep hlsDefaultConfig shallow
|
||||
// It is cloned whenever a new Hls instance is created, by keeping the config
|
||||
// shallow the properties are cloned, and we don't end up manipulating the default
|
||||
export const hlsDefaultConfig: HlsConfig = {
|
||||
autoStartLoad: true, // used by stream-controller
|
||||
startPosition: -1, // used by stream-controller
|
||||
defaultAudioCodec: void 0, // used by stream-controller
|
||||
debug: false, // used by logger
|
||||
capLevelOnFPSDrop: false, // used by fps-controller
|
||||
capLevelToPlayerSize: false, // used by cap-level-controller
|
||||
initialLiveManifestSize: 1, // used by stream-controller
|
||||
maxBufferLength: 30, // used by stream-controller
|
||||
maxBufferSize: 60 * 1000 * 1000, // used by stream-controller
|
||||
maxBufferHole: 0.5, // used by stream-controller
|
||||
|
||||
lowBufferWatchdogPeriod: 0.5, // used by stream-controller
|
||||
highBufferWatchdogPeriod: 3, // used by stream-controller
|
||||
nudgeOffset: 0.1, // used by stream-controller
|
||||
nudgeMaxRetry: 3, // used by stream-controller
|
||||
maxFragLookUpTolerance: 0.25, // used by stream-controller
|
||||
liveSyncDurationCount: 3, // used by stream-controller
|
||||
liveMaxLatencyDurationCount: Infinity, // used by stream-controller
|
||||
liveSyncDuration: void 0, // used by stream-controller
|
||||
liveMaxLatencyDuration: void 0, // used by stream-controller
|
||||
liveDurationInfinity: false, // used by buffer-controller
|
||||
liveBackBufferLength: Infinity, // used by buffer-controller
|
||||
maxMaxBufferLength: 600, // used by stream-controller
|
||||
enableWorker: true, // used by demuxer
|
||||
enableSoftwareAES: true, // used by decrypter
|
||||
manifestLoadingTimeOut: 10000, // used by playlist-loader
|
||||
manifestLoadingMaxRetry: 1, // used by playlist-loader
|
||||
manifestLoadingRetryDelay: 1000, // used by playlist-loader
|
||||
manifestLoadingMaxRetryTimeout: 64000, // used by playlist-loader
|
||||
startLevel: void 0, // used by level-controller
|
||||
levelLoadingTimeOut: 10000, // used by playlist-loader
|
||||
levelLoadingMaxRetry: 4, // used by playlist-loader
|
||||
levelLoadingRetryDelay: 1000, // used by playlist-loader
|
||||
levelLoadingMaxRetryTimeout: 64000, // used by playlist-loader
|
||||
fragLoadingTimeOut: 20000, // used by fragment-loader
|
||||
fragLoadingMaxRetry: 6, // used by fragment-loader
|
||||
fragLoadingRetryDelay: 1000, // used by fragment-loader
|
||||
fragLoadingMaxRetryTimeout: 64000, // used by fragment-loader
|
||||
startFragPrefetch: false, // used by stream-controller
|
||||
fpsDroppedMonitoringPeriod: 5000, // used by fps-controller
|
||||
fpsDroppedMonitoringThreshold: 0.2, // used by fps-controller
|
||||
appendErrorMaxRetry: 3, // used by buffer-controller
|
||||
loader: XhrLoader,
|
||||
// loader: FetchLoader,
|
||||
fLoader: void 0, // used by fragment-loader
|
||||
pLoader: void 0, // used by playlist-loader
|
||||
xhrSetup: void 0, // used by xhr-loader
|
||||
licenseXhrSetup: void 0, // used by eme-controller
|
||||
// fetchSetup: void 0,
|
||||
abrController: AbrController,
|
||||
bufferController: BufferController,
|
||||
capLevelController: CapLevelController,
|
||||
fpsController: FPSController,
|
||||
stretchShortVideoTrack: false, // used by mp4-remuxer
|
||||
maxAudioFramesDrift: 1, // used by mp4-remuxer
|
||||
forceKeyFrameOnDiscontinuity: true, // used by ts-demuxer
|
||||
abrEwmaFastLive: 3, // used by abr-controller
|
||||
abrEwmaSlowLive: 9, // used by abr-controller
|
||||
abrEwmaFastVoD: 3, // used by abr-controller
|
||||
abrEwmaSlowVoD: 9, // used by abr-controller
|
||||
abrEwmaDefaultEstimate: 5e5, // 500 kbps // used by abr-controller
|
||||
abrBandWidthFactor: 0.95, // used by abr-controller
|
||||
abrBandWidthUpFactor: 0.7, // used by abr-controller
|
||||
abrMaxWithRealBitrate: false, // used by abr-controller
|
||||
maxStarvationDelay: 4, // used by abr-controller
|
||||
maxLoadingDelay: 4, // used by abr-controller
|
||||
minAutoBitrate: 0, // used by hls
|
||||
emeEnabled: false, // used by eme-controller
|
||||
widevineLicenseUrl: void 0, // used by eme-controller
|
||||
requestMediaKeySystemAccessFunc: requestMediaKeySystemAccess, // used by eme-controller
|
||||
|
||||
// Dynamic Modules
|
||||
...timelineConfig(),
|
||||
subtitleStreamController: (__USE_SUBTITLES__) ? SubtitleStreamController : void 0,
|
||||
subtitleTrackController: (__USE_SUBTITLES__) ? SubtitleTrackController : void 0,
|
||||
timelineController: (__USE_SUBTITLES__) ? TimelineController : void 0,
|
||||
audioStreamController: (__USE_ALT_AUDIO__) ? AudioStreamController : void 0,
|
||||
audioTrackController: (__USE_ALT_AUDIO__) ? AudioTrackController : void 0,
|
||||
emeController: (__USE_EME_DRM__) ? EMEController : void 0
|
||||
};
|
||||
|
||||
function timelineConfig (): TimelineControllerConfig {
|
||||
if (!__USE_SUBTITLES__) {
|
||||
// intentionally doing this over returning Partial<TimelineControllerConfig> above
|
||||
// this has the added nice property of still requiring the object below to completely define all props.
|
||||
return {} as any;
|
||||
}
|
||||
return {
|
||||
cueHandler: Cues, // used by timeline-controller
|
||||
enableCEA708Captions: true, // used by timeline-controller
|
||||
enableWebVTT: true, // used by timeline-controller
|
||||
captionsTextTrack1Label: 'English', // used by timeline-controller
|
||||
captionsTextTrack1LanguageCode: 'en', // used by timeline-controller
|
||||
captionsTextTrack2Label: 'Spanish', // used by timeline-controller
|
||||
captionsTextTrack2LanguageCode: 'es' // used by timeline-controller
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
*
|
||||
* All objects in the event handling chain should inherit from this class
|
||||
*
|
||||
*/
|
||||
|
||||
import { logger } from './utils/logger';
|
||||
import { ErrorTypes, ErrorDetails } from './errors';
|
||||
import Event from './events';
|
||||
import Hls from './hls';
|
||||
|
||||
const FORBIDDEN_EVENT_NAMES = {
|
||||
'hlsEventGeneric': true,
|
||||
'hlsHandlerDestroying': true,
|
||||
'hlsHandlerDestroyed': true
|
||||
};
|
||||
|
||||
class EventHandler {
|
||||
hls: Hls;
|
||||
handledEvents: any[];
|
||||
useGenericHandler: boolean;
|
||||
|
||||
constructor (hls: Hls, ...events: any[]) {
|
||||
this.hls = hls;
|
||||
this.onEvent = this.onEvent.bind(this);
|
||||
this.handledEvents = events;
|
||||
this.useGenericHandler = true;
|
||||
|
||||
this.registerListeners();
|
||||
}
|
||||
|
||||
destroy () {
|
||||
this.onHandlerDestroying();
|
||||
this.unregisterListeners();
|
||||
this.onHandlerDestroyed();
|
||||
}
|
||||
|
||||
protected onHandlerDestroying () {}
|
||||
protected onHandlerDestroyed () {}
|
||||
|
||||
isEventHandler () {
|
||||
return typeof this.handledEvents === 'object' && this.handledEvents.length && typeof this.onEvent === 'function';
|
||||
}
|
||||
|
||||
registerListeners () {
|
||||
if (this.isEventHandler()) {
|
||||
this.handledEvents.forEach(function (event) {
|
||||
if (FORBIDDEN_EVENT_NAMES[event]) {
|
||||
throw new Error('Forbidden event-name: ' + event);
|
||||
}
|
||||
|
||||
this.hls.on(event, this.onEvent);
|
||||
}, this);
|
||||
}
|
||||
}
|
||||
|
||||
unregisterListeners () {
|
||||
if (this.isEventHandler()) {
|
||||
this.handledEvents.forEach(function (event) {
|
||||
this.hls.off(event, this.onEvent);
|
||||
}, this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* arguments: event (string), data (any)
|
||||
*/
|
||||
onEvent (event: string, data: any) {
|
||||
this.onEventGeneric(event, data);
|
||||
}
|
||||
|
||||
onEventGeneric (event: string, data: any) {
|
||||
let eventToFunction = function (event: string, data: any) {
|
||||
let funcName = 'on' + event.replace('hls', '');
|
||||
if (typeof this[funcName] !== 'function') {
|
||||
throw new Error(`Event ${event} has no generic handler in this ${this.constructor.name} class (tried ${funcName})`);
|
||||
}
|
||||
|
||||
return this[funcName].bind(this, data);
|
||||
};
|
||||
try {
|
||||
eventToFunction.call(this, event, data).call();
|
||||
} catch (err) {
|
||||
logger.error(`An internal error happened while handling event ${event}. Error message: "${err.message}". Here is a stacktrace:`, err);
|
||||
this.hls.trigger(Event.ERROR, { type: ErrorTypes.OTHER_ERROR, details: ErrorDetails.INTERNAL_EXCEPTION, fatal: false, event: event, err: err });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default EventHandler;
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
/**
|
||||
* @readonly
|
||||
* @enum {string}
|
||||
*/
|
||||
const HlsEvents = {
|
||||
// fired before MediaSource is attaching to media element - data: { media }
|
||||
MEDIA_ATTACHING: 'hlsMediaAttaching',
|
||||
// fired when MediaSource has been succesfully attached to media element - data: { }
|
||||
MEDIA_ATTACHED: 'hlsMediaAttached',
|
||||
// fired before detaching MediaSource from media element - data: { }
|
||||
MEDIA_DETACHING: 'hlsMediaDetaching',
|
||||
// fired when MediaSource has been detached from media element - data: { }
|
||||
MEDIA_DETACHED: 'hlsMediaDetached',
|
||||
// fired when we buffer is going to be reset - data: { }
|
||||
BUFFER_RESET: 'hlsBufferReset',
|
||||
// fired when we know about the codecs that we need buffers for to push into - data: {tracks : { container, codec, levelCodec, initSegment, metadata }}
|
||||
BUFFER_CODECS: 'hlsBufferCodecs',
|
||||
// fired when sourcebuffers have been created - data: { tracks : tracks }
|
||||
BUFFER_CREATED: 'hlsBufferCreated',
|
||||
// fired when we append a segment to the buffer - data: { segment: segment object }
|
||||
BUFFER_APPENDING: 'hlsBufferAppending',
|
||||
// fired when we are done with appending a media segment to the buffer - data : { parent : segment parent that triggered BUFFER_APPENDING, pending : nb of segments waiting for appending for this segment parent}
|
||||
BUFFER_APPENDED: 'hlsBufferAppended',
|
||||
// fired when the stream is finished and we want to notify the media buffer that there will be no more data - data: { }
|
||||
BUFFER_EOS: 'hlsBufferEos',
|
||||
// fired when the media buffer should be flushed - data { startOffset, endOffset }
|
||||
BUFFER_FLUSHING: 'hlsBufferFlushing',
|
||||
// fired when the media buffer has been flushed - data: { }
|
||||
BUFFER_FLUSHED: 'hlsBufferFlushed',
|
||||
// fired to signal that a manifest loading starts - data: { url : manifestURL}
|
||||
MANIFEST_LOADING: 'hlsManifestLoading',
|
||||
// fired after manifest has been loaded - data: { levels : [available quality levels], audioTracks : [ available audio tracks], url : manifestURL, stats : { trequest, tfirst, tload, mtime}}
|
||||
MANIFEST_LOADED: 'hlsManifestLoaded',
|
||||
// fired after manifest has been parsed - data: { levels : [available quality levels], firstLevel : index of first quality level appearing in Manifest}
|
||||
MANIFEST_PARSED: 'hlsManifestParsed',
|
||||
// fired when a level switch is requested - data: { level : id of new level }
|
||||
LEVEL_SWITCHING: 'hlsLevelSwitching',
|
||||
// fired when a level switch is effective - data: { level : id of new level }
|
||||
LEVEL_SWITCHED: 'hlsLevelSwitched',
|
||||
// fired when a level playlist loading starts - data: { url : level URL, level : id of level being loaded}
|
||||
LEVEL_LOADING: 'hlsLevelLoading',
|
||||
// fired when a level playlist loading finishes - data: { details : levelDetails object, level : id of loaded level, stats : { trequest, tfirst, tload, mtime} }
|
||||
LEVEL_LOADED: 'hlsLevelLoaded',
|
||||
// fired when a level's details have been updated based on previous details, after it has been loaded - data: { details : levelDetails object, level : id of updated level }
|
||||
LEVEL_UPDATED: 'hlsLevelUpdated',
|
||||
// fired when a level's PTS information has been updated after parsing a fragment - data: { details : levelDetails object, level : id of updated level, drift: PTS drift observed when parsing last fragment }
|
||||
LEVEL_PTS_UPDATED: 'hlsLevelPtsUpdated',
|
||||
// fired to notify that audio track lists has been updated - data: { audioTracks : audioTracks }
|
||||
AUDIO_TRACKS_UPDATED: 'hlsAudioTracksUpdated',
|
||||
// fired when an audio track switching is requested - data: { id : audio track id }
|
||||
AUDIO_TRACK_SWITCHING: 'hlsAudioTrackSwitching',
|
||||
// fired when an audio track switch actually occurs - data: { id : audio track id }
|
||||
AUDIO_TRACK_SWITCHED: 'hlsAudioTrackSwitched',
|
||||
// fired when an audio track loading starts - data: { url : audio track URL, id : audio track id }
|
||||
AUDIO_TRACK_LOADING: 'hlsAudioTrackLoading',
|
||||
// fired when an audio track loading finishes - data: { details : levelDetails object, id : audio track id, stats : { trequest, tfirst, tload, mtime } }
|
||||
AUDIO_TRACK_LOADED: 'hlsAudioTrackLoaded',
|
||||
// fired to notify that subtitle track lists has been updated - data: { subtitleTracks : subtitleTracks }
|
||||
SUBTITLE_TRACKS_UPDATED: 'hlsSubtitleTracksUpdated',
|
||||
// fired when an subtitle track switch occurs - data: { id : subtitle track id }
|
||||
SUBTITLE_TRACK_SWITCH: 'hlsSubtitleTrackSwitch',
|
||||
// fired when a subtitle track loading starts - data: { url : subtitle track URL, id : subtitle track id }
|
||||
SUBTITLE_TRACK_LOADING: 'hlsSubtitleTrackLoading',
|
||||
// fired when a subtitle track loading finishes - data: { details : levelDetails object, id : subtitle track id, stats : { trequest, tfirst, tload, mtime } }
|
||||
SUBTITLE_TRACK_LOADED: 'hlsSubtitleTrackLoaded',
|
||||
// fired when a subtitle fragment has been processed - data: { success : boolean, frag : the processed frag }
|
||||
SUBTITLE_FRAG_PROCESSED: 'hlsSubtitleFragProcessed',
|
||||
// fired when the first timestamp is found - data: { id : demuxer id, initPTS: initPTS, frag : fragment object }
|
||||
INIT_PTS_FOUND: 'hlsInitPtsFound',
|
||||
// fired when a fragment loading starts - data: { frag : fragment object }
|
||||
FRAG_LOADING: 'hlsFragLoading',
|
||||
// fired when a fragment loading is progressing - data: { frag : fragment object, { trequest, tfirst, loaded } }
|
||||
FRAG_LOAD_PROGRESS: 'hlsFragLoadProgress',
|
||||
// Identifier for fragment load aborting for emergency switch down - data: { frag : fragment object }
|
||||
FRAG_LOAD_EMERGENCY_ABORTED: 'hlsFragLoadEmergencyAborted',
|
||||
// fired when a fragment loading is completed - data: { frag : fragment object, payload : fragment payload, stats : { trequest, tfirst, tload, length } }
|
||||
FRAG_LOADED: 'hlsFragLoaded',
|
||||
// fired when a fragment has finished decrypting - data: { id : demuxer id, frag: fragment object, payload : fragment payload, stats : { tstart, tdecrypt } }
|
||||
FRAG_DECRYPTED: 'hlsFragDecrypted',
|
||||
// fired when Init Segment has been extracted from fragment - data: { id : demuxer id, frag: fragment object, moov : moov MP4 box, codecs : codecs found while parsing fragment }
|
||||
FRAG_PARSING_INIT_SEGMENT: 'hlsFragParsingInitSegment',
|
||||
// fired when parsing sei text is completed - data: { id : demuxer id, frag: fragment object, samples : [ sei samples pes ] }
|
||||
FRAG_PARSING_USERDATA: 'hlsFragParsingUserdata',
|
||||
// fired when parsing id3 is completed - data: { id : demuxer id, frag: fragment object, samples : [ id3 samples pes ] }
|
||||
FRAG_PARSING_METADATA: 'hlsFragParsingMetadata',
|
||||
// fired when data have been extracted from fragment - data: { id : demuxer id, frag: fragment object, data1 : moof MP4 box or TS fragments, data2 : mdat MP4 box or null}
|
||||
FRAG_PARSING_DATA: 'hlsFragParsingData',
|
||||
// fired when fragment parsing is completed - data: { id : demuxer id, frag: fragment object }
|
||||
FRAG_PARSED: 'hlsFragParsed',
|
||||
// fired when fragment remuxed MP4 boxes have all been appended into SourceBuffer - data: { id : demuxer id, frag : fragment object, stats : { trequest, tfirst, tload, tparsed, tbuffered, length, bwEstimate } }
|
||||
FRAG_BUFFERED: 'hlsFragBuffered',
|
||||
// fired when fragment matching with current media position is changing - data : { id : demuxer id, frag : fragment object }
|
||||
FRAG_CHANGED: 'hlsFragChanged',
|
||||
// Identifier for a FPS drop event - data: { curentDropped, currentDecoded, totalDroppedFrames }
|
||||
FPS_DROP: 'hlsFpsDrop',
|
||||
// triggered when FPS drop triggers auto level capping - data: { level, droppedlevel }
|
||||
FPS_DROP_LEVEL_CAPPING: 'hlsFpsDropLevelCapping',
|
||||
// Identifier for an error event - data: { type : error type, details : error details, fatal : if true, hls.js cannot/will not try to recover, if false, hls.js will try to recover,other error specific data }
|
||||
ERROR: 'hlsError',
|
||||
// fired when hls.js instance starts destroying. Different from MEDIA_DETACHED as one could want to detach and reattach a media to the instance of hls.js to handle mid-rolls for example - data: { }
|
||||
DESTROYING: 'hlsDestroying',
|
||||
// fired when a decrypt key loading starts - data: { frag : fragment object }
|
||||
KEY_LOADING: 'hlsKeyLoading',
|
||||
// fired when a decrypt key loading is completed - data: { frag : fragment object, payload : key payload, stats : { trequest, tfirst, tload, length } }
|
||||
KEY_LOADED: 'hlsKeyLoaded',
|
||||
// fired upon stream controller state transitions - data: { previousState, nextState }
|
||||
STREAM_STATE_TRANSITION: 'hlsStreamStateTransition'
|
||||
};
|
||||
|
||||
export default HlsEvents;
|
||||
|
|
@ -0,0 +1,674 @@
|
|||
import * as URLToolkit from 'url-toolkit';
|
||||
|
||||
import {
|
||||
ErrorTypes,
|
||||
ErrorDetails
|
||||
} from './errors';
|
||||
|
||||
import PlaylistLoader from './loader/playlist-loader';
|
||||
import FragmentLoader from './loader/fragment-loader';
|
||||
import KeyLoader from './loader/key-loader';
|
||||
|
||||
import { FragmentTracker } from './controller/fragment-tracker';
|
||||
import StreamController from './controller/stream-controller';
|
||||
import LevelController from './controller/level-controller';
|
||||
import ID3TrackController from './controller/id3-track-controller';
|
||||
|
||||
import { isSupported } from './is-supported';
|
||||
import { logger, enableLogs } from './utils/logger';
|
||||
import { hlsDefaultConfig, HlsConfig } from './config';
|
||||
|
||||
import HlsEvents from './events';
|
||||
|
||||
import { Observer } from './observer';
|
||||
|
||||
/**
|
||||
* @module Hls
|
||||
* @class
|
||||
* @constructor
|
||||
*/
|
||||
export default class Hls extends Observer {
|
||||
public static defaultConfig?: HlsConfig;
|
||||
public config: HlsConfig;
|
||||
|
||||
private _autoLevelCapping: number;
|
||||
private abrController: any;
|
||||
private capLevelController: any;
|
||||
private levelController: any;
|
||||
private streamController: any;
|
||||
private networkControllers: any[];
|
||||
private audioTrackController: any;
|
||||
private subtitleTrackController: any;
|
||||
private emeController: any;
|
||||
private coreComponents: any[];
|
||||
private media: HTMLMediaElement | null = null;
|
||||
private url: string | null = null;
|
||||
|
||||
/**
|
||||
* @type {string}
|
||||
*/
|
||||
static get version (): string {
|
||||
return __VERSION__;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {boolean}
|
||||
*/
|
||||
static isSupported (): boolean {
|
||||
return isSupported();
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsEvents}
|
||||
*/
|
||||
static get Events () {
|
||||
return HlsEvents;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsErrorTypes}
|
||||
*/
|
||||
static get ErrorTypes () {
|
||||
return ErrorTypes;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsErrorDetails}
|
||||
*/
|
||||
static get ErrorDetails () {
|
||||
return ErrorDetails;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsConfig}
|
||||
*/
|
||||
static get DefaultConfig (): HlsConfig {
|
||||
if (!Hls.defaultConfig) {
|
||||
return hlsDefaultConfig;
|
||||
}
|
||||
|
||||
return Hls.defaultConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {HlsConfig}
|
||||
*/
|
||||
static set DefaultConfig (defaultConfig: HlsConfig) {
|
||||
Hls.defaultConfig = defaultConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an instance of an HLS client that can attach to exactly one `HTMLMediaElement`.
|
||||
*
|
||||
* @constructs Hls
|
||||
* @param {HlsConfig} config
|
||||
*/
|
||||
constructor (userConfig: Partial<HlsConfig> = {}) {
|
||||
super();
|
||||
|
||||
const defaultConfig = Hls.DefaultConfig;
|
||||
|
||||
if ((userConfig.liveSyncDurationCount || userConfig.liveMaxLatencyDurationCount) && (userConfig.liveSyncDuration || userConfig.liveMaxLatencyDuration)) {
|
||||
throw new Error('Illegal hls.js config: don\'t mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration');
|
||||
}
|
||||
|
||||
// Shallow clone
|
||||
this.config = {
|
||||
...defaultConfig,
|
||||
...userConfig
|
||||
};
|
||||
|
||||
const { config } = this;
|
||||
|
||||
if (config.liveMaxLatencyDurationCount !== void 0 && config.liveMaxLatencyDurationCount <= config.liveSyncDurationCount) {
|
||||
throw new Error('Illegal hls.js config: "liveMaxLatencyDurationCount" must be gt "liveSyncDurationCount"');
|
||||
}
|
||||
|
||||
if (config.liveMaxLatencyDuration !== void 0 && (config.liveSyncDuration === void 0 || config.liveMaxLatencyDuration <= config.liveSyncDuration)) {
|
||||
throw new Error('Illegal hls.js config: "liveMaxLatencyDuration" must be gt "liveSyncDuration"');
|
||||
}
|
||||
|
||||
enableLogs(config.debug);
|
||||
|
||||
this._autoLevelCapping = -1;
|
||||
|
||||
// core controllers and network loaders
|
||||
|
||||
/**
|
||||
* @member {AbrController} abrController
|
||||
*/
|
||||
const abrController = this.abrController = new config.abrController(this); // eslint-disable-line new-cap
|
||||
const bufferController = new config.bufferController(this); // eslint-disable-line new-cap
|
||||
const capLevelController = this.capLevelController = new config.capLevelController(this); // eslint-disable-line new-cap
|
||||
const fpsController = new config.fpsController(this); // eslint-disable-line new-cap
|
||||
const playListLoader = new PlaylistLoader(this);
|
||||
const fragmentLoader = new FragmentLoader(this);
|
||||
const keyLoader = new KeyLoader(this);
|
||||
const id3TrackController = new ID3TrackController(this);
|
||||
|
||||
// network controllers
|
||||
|
||||
/**
|
||||
* @member {LevelController} levelController
|
||||
*/
|
||||
const levelController = this.levelController = new LevelController(this);
|
||||
|
||||
// FIXME: FragmentTracker must be defined before StreamController because the order of event handling is important
|
||||
const fragmentTracker = new FragmentTracker(this);
|
||||
|
||||
/**
|
||||
* @member {StreamController} streamController
|
||||
*/
|
||||
const streamController = this.streamController = new StreamController(this, fragmentTracker);
|
||||
|
||||
let networkControllers = [levelController, streamController];
|
||||
|
||||
// optional audio stream controller
|
||||
/**
|
||||
* @var {ICoreComponent | Controller}
|
||||
*/
|
||||
let Controller = config.audioStreamController;
|
||||
if (Controller) {
|
||||
networkControllers.push(new Controller(this, fragmentTracker));
|
||||
}
|
||||
|
||||
/**
|
||||
* @member {INetworkController[]} networkControllers
|
||||
*/
|
||||
this.networkControllers = networkControllers;
|
||||
|
||||
/**
|
||||
* @var {ICoreComponent[]}
|
||||
*/
|
||||
const coreComponents = [
|
||||
playListLoader,
|
||||
fragmentLoader,
|
||||
keyLoader,
|
||||
abrController,
|
||||
bufferController,
|
||||
capLevelController,
|
||||
fpsController,
|
||||
id3TrackController,
|
||||
fragmentTracker
|
||||
];
|
||||
|
||||
// optional audio track and subtitle controller
|
||||
Controller = config.audioTrackController;
|
||||
if (Controller) {
|
||||
const audioTrackController = new Controller(this);
|
||||
|
||||
/**
|
||||
* @member {AudioTrackController} audioTrackController
|
||||
*/
|
||||
this.audioTrackController = audioTrackController;
|
||||
coreComponents.push(audioTrackController);
|
||||
}
|
||||
|
||||
Controller = config.subtitleTrackController;
|
||||
if (Controller) {
|
||||
const subtitleTrackController = new Controller(this);
|
||||
|
||||
/**
|
||||
* @member {SubtitleTrackController} subtitleTrackController
|
||||
*/
|
||||
this.subtitleTrackController = subtitleTrackController;
|
||||
networkControllers.push(subtitleTrackController);
|
||||
}
|
||||
|
||||
Controller = config.emeController;
|
||||
if (Controller) {
|
||||
const emeController = new Controller(this);
|
||||
|
||||
/**
|
||||
* @member {EMEController} emeController
|
||||
*/
|
||||
this.emeController = emeController;
|
||||
coreComponents.push(emeController);
|
||||
}
|
||||
|
||||
// optional subtitle controllers
|
||||
Controller = config.subtitleStreamController;
|
||||
if (Controller) {
|
||||
networkControllers.push(new Controller(this, fragmentTracker));
|
||||
}
|
||||
Controller = config.timelineController;
|
||||
if (Controller) {
|
||||
coreComponents.push(new Controller(this));
|
||||
}
|
||||
|
||||
/**
|
||||
* @member {ICoreComponent[]}
|
||||
*/
|
||||
this.coreComponents = coreComponents;
|
||||
}
|
||||
|
||||
/**
|
||||
* Dispose of the instance
|
||||
*/
|
||||
destroy () {
|
||||
logger.log('destroy');
|
||||
this.trigger(HlsEvents.DESTROYING);
|
||||
this.detachMedia();
|
||||
this.coreComponents.concat(this.networkControllers).forEach(component => {
|
||||
component.destroy();
|
||||
});
|
||||
this.url = null;
|
||||
this.removeAllListeners();
|
||||
this._autoLevelCapping = -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Attach a media element
|
||||
* @param {HTMLMediaElement} media
|
||||
*/
|
||||
attachMedia (media: HTMLMediaElement) {
|
||||
logger.log('attachMedia');
|
||||
this.media = media;
|
||||
this.trigger(HlsEvents.MEDIA_ATTACHING, { media: media });
|
||||
}
|
||||
|
||||
/**
|
||||
* Detach from the media
|
||||
*/
|
||||
detachMedia () {
|
||||
logger.log('detachMedia');
|
||||
this.trigger(HlsEvents.MEDIA_DETACHING);
|
||||
this.media = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the source URL. Can be relative or absolute.
|
||||
* @param {string} url
|
||||
*/
|
||||
loadSource (url: string) {
|
||||
url = URLToolkit.buildAbsoluteURL(window.location.href, url, { alwaysNormalize: true });
|
||||
logger.log(`loadSource:${url}`);
|
||||
this.url = url;
|
||||
// when attaching to a source URL, trigger a playlist load
|
||||
this.trigger(HlsEvents.MANIFEST_LOADING, { url: url });
|
||||
}
|
||||
|
||||
/**
|
||||
* Start loading data from the stream source.
|
||||
* Depending on default config, client starts loading automatically when a source is set.
|
||||
*
|
||||
* @param {number} startPosition Set the start position to stream from
|
||||
* @default -1 None (from earliest point)
|
||||
*/
|
||||
startLoad (startPosition: number = -1) {
|
||||
logger.log(`startLoad(${startPosition})`);
|
||||
this.networkControllers.forEach(controller => {
|
||||
controller.startLoad(startPosition);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop loading of any stream data.
|
||||
*/
|
||||
stopLoad () {
|
||||
logger.log('stopLoad');
|
||||
this.networkControllers.forEach(controller => {
|
||||
controller.stopLoad();
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
|
||||
*/
|
||||
swapAudioCodec () {
|
||||
logger.log('swapAudioCodec');
|
||||
this.streamController.swapAudioCodec();
|
||||
}
|
||||
|
||||
/**
|
||||
* When the media-element fails, this allows to detach and then re-attach it
|
||||
* as one call (convenience method).
|
||||
*
|
||||
* Automatic recovery of media-errors by this process is configurable.
|
||||
*/
|
||||
recoverMediaError () {
|
||||
logger.log('recoverMediaError');
|
||||
let media = this.media;
|
||||
this.detachMedia();
|
||||
if (media) {
|
||||
this.attachMedia(media);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {QualityLevel[]}
|
||||
*/
|
||||
// todo(typescript-levelController)
|
||||
get levels (): any[] {
|
||||
return this.levelController.levels;
|
||||
}
|
||||
|
||||
/**
|
||||
* Index of quality level currently played
|
||||
* @type {number}
|
||||
*/
|
||||
get currentLevel (): number {
|
||||
return this.streamController.currentLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set quality level index immediately .
|
||||
* This will flush the current buffer to replace the quality asap.
|
||||
* That means playback will interrupt at least shortly to re-buffer and re-sync eventually.
|
||||
* @type {number} -1 for automatic level selection
|
||||
*/
|
||||
set currentLevel (newLevel: number) {
|
||||
logger.log(`set currentLevel:${newLevel}`);
|
||||
this.loadLevel = newLevel;
|
||||
this.streamController.immediateLevelSwitch();
|
||||
}
|
||||
|
||||
/**
|
||||
* Index of next quality level loaded as scheduled by stream controller.
|
||||
* @type {number}
|
||||
*/
|
||||
get nextLevel (): number {
|
||||
return this.streamController.nextLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set quality level index for next loaded data.
|
||||
* This will switch the video quality asap, without interrupting playback.
|
||||
* May abort current loading of data, and flush parts of buffer (outside currently played fragment region).
|
||||
* @type {number} -1 for automatic level selection
|
||||
*/
|
||||
set nextLevel (newLevel: number) {
|
||||
logger.log(`set nextLevel:${newLevel}`);
|
||||
this.levelController.manualLevel = newLevel;
|
||||
this.streamController.nextLevelSwitch();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the quality level of the currently or last (of none is loaded currently) segment
|
||||
* @type {number}
|
||||
*/
|
||||
get loadLevel (): number {
|
||||
return this.levelController.level;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set quality level index for next loaded data in a conservative way.
|
||||
* This will switch the quality without flushing, but interrupt current loading.
|
||||
* Thus the moment when the quality switch will appear in effect will only be after the already existing buffer.
|
||||
* @type {number} newLevel -1 for automatic level selection
|
||||
*/
|
||||
set loadLevel (newLevel: number) {
|
||||
logger.log(`set loadLevel:${newLevel}`);
|
||||
this.levelController.manualLevel = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* get next quality level loaded
|
||||
* @type {number}
|
||||
*/
|
||||
get nextLoadLevel (): number {
|
||||
return this.levelController.nextLoadLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set quality level of next loaded segment in a fully "non-destructive" way.
|
||||
* Same as `loadLevel` but will wait for next switch (until current loading is done).
|
||||
* @type {number} level
|
||||
*/
|
||||
set nextLoadLevel (level: number) {
|
||||
this.levelController.nextLoadLevel = level;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return "first level": like a default level, if not set,
|
||||
* falls back to index of first level referenced in manifest
|
||||
* @type {number}
|
||||
*/
|
||||
get firstLevel (): number {
|
||||
return Math.max(this.levelController.firstLevel, this.minAutoLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets "first-level", see getter.
|
||||
* @type {number}
|
||||
*/
|
||||
set firstLevel (newLevel: number) {
|
||||
logger.log(`set firstLevel:${newLevel}`);
|
||||
this.levelController.firstLevel = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return start level (level of first fragment that will be played back)
|
||||
* if not overrided by user, first level appearing in manifest will be used as start level
|
||||
* if -1 : automatic start level selection, playback will start from level matching download bandwidth
|
||||
* (determined from download of first segment)
|
||||
* @type {number}
|
||||
*/
|
||||
get startLevel (): number {
|
||||
return this.levelController.startLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* set start level (level of first fragment that will be played back)
|
||||
* if not overrided by user, first level appearing in manifest will be used as start level
|
||||
* if -1 : automatic start level selection, playback will start from level matching download bandwidth
|
||||
* (determined from download of first segment)
|
||||
* @type {number} newLevel
|
||||
*/
|
||||
set startLevel (newLevel: number) {
|
||||
logger.log(`set startLevel:${newLevel}`);
|
||||
// if not in automatic start level detection, ensure startLevel is greater than minAutoLevel
|
||||
if (newLevel !== -1) {
|
||||
newLevel = Math.max(newLevel, this.minAutoLevel);
|
||||
}
|
||||
|
||||
this.levelController.startLevel = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* set dynamically set capLevelToPlayerSize against (`CapLevelController`)
|
||||
*
|
||||
* @type {boolean}
|
||||
*/
|
||||
set capLevelToPlayerSize (shouldStartCapping: boolean) {
|
||||
const newCapLevelToPlayerSize = !!shouldStartCapping;
|
||||
|
||||
if (newCapLevelToPlayerSize !== this.config.capLevelToPlayerSize) {
|
||||
if (newCapLevelToPlayerSize) {
|
||||
this.capLevelController.startCapping(); // If capping occurs, nextLevelSwitch will happen based on size.
|
||||
} else {
|
||||
this.capLevelController.stopCapping();
|
||||
this.autoLevelCapping = -1;
|
||||
this.streamController.nextLevelSwitch(); // Now we're uncapped, get the next level asap.
|
||||
}
|
||||
|
||||
this.config.capLevelToPlayerSize = newCapLevelToPlayerSize;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
||||
* @type {number}
|
||||
*/
|
||||
get autoLevelCapping (): number {
|
||||
return this._autoLevelCapping;
|
||||
}
|
||||
|
||||
/**
|
||||
* get bandwidth estimate
|
||||
* @type {number}
|
||||
*/
|
||||
get bandwidthEstimate (): number {
|
||||
const bwEstimator = this.abrController._bwEstimator;
|
||||
return bwEstimator ? bwEstimator.getEstimate() : NaN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
|
||||
* @type {number}
|
||||
*/
|
||||
set autoLevelCapping (newLevel: number) {
|
||||
logger.log(`set autoLevelCapping:${newLevel}`);
|
||||
this._autoLevelCapping = newLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* True when automatic level selection enabled
|
||||
* @type {boolean}
|
||||
*/
|
||||
get autoLevelEnabled (): boolean {
|
||||
return (this.levelController.manualLevel === -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Level set manually (if any)
|
||||
* @type {number}
|
||||
*/
|
||||
get manualLevel (): number {
|
||||
return this.levelController.manualLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* min level selectable in auto mode according to config.minAutoBitrate
|
||||
* @type {number}
|
||||
*/
|
||||
get minAutoLevel (): number {
|
||||
const { levels, config: { minAutoBitrate } } = this;
|
||||
const len = levels ? levels.length : 0;
|
||||
|
||||
for (let i = 0; i < len; i++) {
|
||||
const levelNextBitrate = levels[i].realBitrate
|
||||
? Math.max(levels[i].realBitrate, levels[i].bitrate)
|
||||
: levels[i].bitrate;
|
||||
|
||||
if (levelNextBitrate > minAutoBitrate) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* max level selectable in auto mode according to autoLevelCapping
|
||||
* @type {number}
|
||||
*/
|
||||
get maxAutoLevel (): number {
|
||||
const { levels, autoLevelCapping } = this;
|
||||
|
||||
let maxAutoLevel;
|
||||
if (autoLevelCapping === -1 && levels && levels.length) {
|
||||
maxAutoLevel = levels.length - 1;
|
||||
} else {
|
||||
maxAutoLevel = autoLevelCapping;
|
||||
}
|
||||
|
||||
return maxAutoLevel;
|
||||
}
|
||||
|
||||
/**
|
||||
* next automatically selected quality level
|
||||
* @type {number}
|
||||
*/
|
||||
get nextAutoLevel (): number {
|
||||
// ensure next auto level is between min and max auto level
|
||||
return Math.min(Math.max(this.abrController.nextAutoLevel, this.minAutoLevel), this.maxAutoLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* this setter is used to force next auto level.
|
||||
* this is useful to force a switch down in auto mode:
|
||||
* in case of load error on level N, hls.js can set nextAutoLevel to N-1 for example)
|
||||
* forced value is valid for one fragment. upon succesful frag loading at forced level,
|
||||
* this value will be resetted to -1 by ABR controller.
|
||||
* @type {number}
|
||||
*/
|
||||
set nextAutoLevel (nextLevel: number) {
|
||||
this.abrController.nextAutoLevel = Math.max(this.minAutoLevel, nextLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {AudioTrack[]}
|
||||
*/
|
||||
// todo(typescript-audioTrackController)
|
||||
get audioTracks (): any[] {
|
||||
const audioTrackController = this.audioTrackController;
|
||||
return audioTrackController ? audioTrackController.audioTracks : [];
|
||||
}
|
||||
|
||||
/**
|
||||
* index of the selected audio track (index in audio track lists)
|
||||
* @type {number}
|
||||
*/
|
||||
get audioTrack (): number {
|
||||
const audioTrackController = this.audioTrackController;
|
||||
return audioTrackController ? audioTrackController.audioTrack : -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* selects an audio track, based on its index in audio track lists
|
||||
* @type {number}
|
||||
*/
|
||||
set audioTrack (audioTrackId: number) {
|
||||
const audioTrackController = this.audioTrackController;
|
||||
if (audioTrackController) {
|
||||
audioTrackController.audioTrack = audioTrackId;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {Seconds}
|
||||
*/
|
||||
get liveSyncPosition (): number {
|
||||
return this.streamController.liveSyncPosition;
|
||||
}
|
||||
|
||||
/**
|
||||
* get alternate subtitle tracks list from playlist
|
||||
* @type {SubtitleTrack[]}
|
||||
*/
|
||||
// todo(typescript-subtitleTrackController)
|
||||
get subtitleTracks (): any[] {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
return subtitleTrackController ? subtitleTrackController.subtitleTracks : [];
|
||||
}
|
||||
|
||||
/**
|
||||
* index of the selected subtitle track (index in subtitle track lists)
|
||||
* @type {number}
|
||||
*/
|
||||
get subtitleTrack (): number {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
return subtitleTrackController ? subtitleTrackController.subtitleTrack : -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* select an subtitle track, based on its index in subtitle track lists
|
||||
* @type {number}
|
||||
*/
|
||||
set subtitleTrack (subtitleTrackId: number) {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
if (subtitleTrackController) {
|
||||
subtitleTrackController.subtitleTrack = subtitleTrackId;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {boolean}
|
||||
*/
|
||||
get subtitleDisplay (): boolean {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
return subtitleTrackController ? subtitleTrackController.subtitleDisplay : false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enable/disable subtitle display rendering
|
||||
* @type {boolean}
|
||||
*/
|
||||
set subtitleDisplay (value: boolean) {
|
||||
const subtitleTrackController = this.subtitleTrackController;
|
||||
if (subtitleTrackController) {
|
||||
subtitleTrackController.subtitleDisplay = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
/*
|
||||
* Fragment Loader
|
||||
*/
|
||||
|
||||
import Event from '../events';
|
||||
import EventHandler from '../event-handler';
|
||||
import { ErrorTypes, ErrorDetails } from '../errors';
|
||||
import { logger } from '../utils/logger';
|
||||
|
||||
class FragmentLoader extends EventHandler {
|
||||
constructor (hls) {
|
||||
super(hls, Event.FRAG_LOADING);
|
||||
this.loaders = {};
|
||||
}
|
||||
|
||||
destroy () {
|
||||
let loaders = this.loaders;
|
||||
for (let loaderName in loaders) {
|
||||
let loader = loaders[loaderName];
|
||||
if (loader) {
|
||||
loader.destroy();
|
||||
}
|
||||
}
|
||||
this.loaders = {};
|
||||
|
||||
super.destroy();
|
||||
}
|
||||
|
||||
onFragLoading (data) {
|
||||
const frag = data.frag,
|
||||
type = frag.type,
|
||||
loaders = this.loaders,
|
||||
config = this.hls.config,
|
||||
FragmentILoader = config.fLoader,
|
||||
DefaultILoader = config.loader;
|
||||
|
||||
// reset fragment state
|
||||
frag.loaded = 0;
|
||||
|
||||
let loader = loaders[type];
|
||||
if (loader) {
|
||||
logger.warn(`abort previous fragment loader for type: ${type}`);
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
loader = loaders[type] = frag.loader =
|
||||
config.fLoader ? new FragmentILoader(config) : new DefaultILoader(config);
|
||||
|
||||
let loaderContext, loaderConfig, loaderCallbacks;
|
||||
|
||||
loaderContext = { url: frag.url, frag: frag, responseType: 'arraybuffer', progressData: false };
|
||||
|
||||
let start = frag.byteRangeStartOffset,
|
||||
end = frag.byteRangeEndOffset;
|
||||
|
||||
if (Number.isFinite(start) && Number.isFinite(end)) {
|
||||
loaderContext.rangeStart = start;
|
||||
loaderContext.rangeEnd = end;
|
||||
}
|
||||
|
||||
loaderConfig = {
|
||||
timeout: config.fragLoadingTimeOut,
|
||||
maxRetry: 0,
|
||||
retryDelay: 0,
|
||||
maxRetryDelay: config.fragLoadingMaxRetryTimeout
|
||||
};
|
||||
|
||||
loaderCallbacks = {
|
||||
onSuccess: this.loadsuccess.bind(this),
|
||||
onError: this.loaderror.bind(this),
|
||||
onTimeout: this.loadtimeout.bind(this),
|
||||
onProgress: this.loadprogress.bind(this)
|
||||
};
|
||||
|
||||
loader.load(loaderContext, loaderConfig, loaderCallbacks);
|
||||
}
|
||||
|
||||
loadsuccess (response, stats, context, networkDetails = null) {
|
||||
let payload = response.data, frag = context.frag;
|
||||
// detach fragment loader on load success
|
||||
frag.loader = undefined;
|
||||
this.loaders[frag.type] = undefined;
|
||||
this.hls.trigger(Event.FRAG_LOADED, { payload: payload, frag: frag, stats: stats, networkDetails: networkDetails });
|
||||
}
|
||||
|
||||
loaderror (response, context, networkDetails = null) {
|
||||
const frag = context.frag;
|
||||
let loader = frag.loader;
|
||||
if (loader) {
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
this.loaders[frag.type] = undefined;
|
||||
this.hls.trigger(Event.ERROR, { type: ErrorTypes.NETWORK_ERROR, details: ErrorDetails.FRAG_LOAD_ERROR, fatal: false, frag: context.frag, response: response, networkDetails: networkDetails });
|
||||
}
|
||||
|
||||
loadtimeout (stats, context, networkDetails = null) {
|
||||
const frag = context.frag;
|
||||
let loader = frag.loader;
|
||||
if (loader) {
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
this.loaders[frag.type] = undefined;
|
||||
this.hls.trigger(Event.ERROR, { type: ErrorTypes.NETWORK_ERROR, details: ErrorDetails.FRAG_LOAD_TIMEOUT, fatal: false, frag: context.frag, networkDetails: networkDetails });
|
||||
}
|
||||
|
||||
// data will be used for progressive parsing
|
||||
loadprogress (stats, context, data, networkDetails = null) { // jshint ignore:line
|
||||
let frag = context.frag;
|
||||
frag.loaded = stats.loaded;
|
||||
this.hls.trigger(Event.FRAG_LOAD_PROGRESS, { frag: frag, stats: stats, networkDetails: networkDetails });
|
||||
}
|
||||
}
|
||||
|
||||
export default FragmentLoader;
|
||||
|
|
@ -0,0 +1,201 @@
|
|||
|
||||
import { buildAbsoluteURL } from 'url-toolkit';
|
||||
import { logger } from '../utils/logger';
|
||||
import LevelKey from './level-key';
|
||||
import { PlaylistLevelType } from '../types/loader';
|
||||
|
||||
export enum ElementaryStreamTypes {
|
||||
AUDIO = 'audio',
|
||||
VIDEO = 'video',
|
||||
}
|
||||
|
||||
export default class Fragment {
|
||||
private _url: string | null = null;
|
||||
private _byteRange: number[] | null = null;
|
||||
private _decryptdata: LevelKey | null = null;
|
||||
|
||||
// Holds the types of data this fragment supports
|
||||
private _elementaryStreams: Record<ElementaryStreamTypes, boolean> = {
|
||||
[ElementaryStreamTypes.AUDIO]: false,
|
||||
[ElementaryStreamTypes.VIDEO]: false
|
||||
};
|
||||
|
||||
// deltaPTS tracks the change in presentation timestamp between fragments
|
||||
public deltaPTS: number = 0;
|
||||
|
||||
public rawProgramDateTime: string | null = null;
|
||||
public programDateTime: number | null = null;
|
||||
public title: string | null = null;
|
||||
public tagList: Array<string[]> = [];
|
||||
|
||||
// TODO: Move at least baseurl to constructor.
|
||||
// Currently we do a two-pass construction as use the Fragment class almost like a object for holding parsing state.
|
||||
// It may make more sense to just use a POJO to keep state during the parsing phase.
|
||||
// Have Fragment be the representation once we have a known state?
|
||||
// Something to think on.
|
||||
|
||||
// Discontinuity Counter
|
||||
public cc!: number;
|
||||
|
||||
public type!: PlaylistLevelType;
|
||||
// relurl is the portion of the URL that comes from inside the playlist.
|
||||
public relurl!: string;
|
||||
// baseurl is the URL to the playlist
|
||||
public baseurl!: string;
|
||||
// EXTINF has to be present for a m3u8 to be considered valid
|
||||
public duration!: number;
|
||||
// When this segment starts in the timeline
|
||||
public start!: number;
|
||||
// sn notates the sequence number for a segment, and if set to a string can be 'initSegment'
|
||||
public sn: number | 'initSegment' = 0;
|
||||
|
||||
public urlId: number = 0;
|
||||
// level matches this fragment to a index playlist
|
||||
public level: number = 0;
|
||||
// levelkey is the EXT-X-KEY that applies to this segment for decryption
|
||||
// core difference from the private field _decryptdata is the lack of the initialized IV
|
||||
// _decryptdata will set the IV for this segment based on the segment number in the fragment
|
||||
public levelkey?: LevelKey;
|
||||
|
||||
// TODO(typescript-xhrloader)
|
||||
public loader: any;
|
||||
|
||||
// setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
|
||||
setByteRange (value: string, previousFrag?: Fragment) {
|
||||
const params = value.split('@', 2);
|
||||
const byteRange: number[] = [];
|
||||
if (params.length === 1) {
|
||||
byteRange[0] = previousFrag ? previousFrag.byteRangeEndOffset : 0;
|
||||
} else {
|
||||
byteRange[0] = parseInt(params[1]);
|
||||
}
|
||||
byteRange[1] = parseInt(params[0]) + byteRange[0];
|
||||
this._byteRange = byteRange;
|
||||
}
|
||||
|
||||
get url () {
|
||||
if (!this._url && this.relurl) {
|
||||
this._url = buildAbsoluteURL(this.baseurl, this.relurl, { alwaysNormalize: true });
|
||||
}
|
||||
|
||||
return this._url;
|
||||
}
|
||||
|
||||
set url (value) {
|
||||
this._url = value;
|
||||
}
|
||||
|
||||
get byteRange (): number[] {
|
||||
if (!this._byteRange) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return this._byteRange;
|
||||
}
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
*/
|
||||
get byteRangeStartOffset () {
|
||||
return this.byteRange[0];
|
||||
}
|
||||
|
||||
get byteRangeEndOffset () {
|
||||
return this.byteRange[1];
|
||||
}
|
||||
|
||||
get decryptdata (): LevelKey | null {
|
||||
if (!this.levelkey && !this._decryptdata) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!this._decryptdata && this.levelkey) {
|
||||
let sn = this.sn;
|
||||
if (typeof sn !== 'number') {
|
||||
// We are fetching decryption data for a initialization segment
|
||||
// If the segment was encrypted with AES-128
|
||||
// It must have an IV defined. We cannot substitute the Segment Number in.
|
||||
if (this.levelkey && this.levelkey.method === 'AES-128' && !this.levelkey.iv) {
|
||||
logger.warn(`missing IV for initialization segment with method="${this.levelkey.method}" - compliance issue`);
|
||||
}
|
||||
|
||||
/*
|
||||
Be converted to a Number.
|
||||
'initSegment' will become NaN.
|
||||
NaN, which when converted through ToInt32() -> +0.
|
||||
---
|
||||
Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
|
||||
*/
|
||||
sn = 0;
|
||||
}
|
||||
this._decryptdata = this.setDecryptDataFromLevelKey(this.levelkey, sn);
|
||||
}
|
||||
|
||||
return this._decryptdata;
|
||||
}
|
||||
|
||||
get endProgramDateTime () {
|
||||
if (this.programDateTime === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!Number.isFinite(this.programDateTime)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
let duration = !Number.isFinite(this.duration) ? 0 : this.duration;
|
||||
|
||||
return this.programDateTime + (duration * 1000);
|
||||
}
|
||||
|
||||
get encrypted () {
|
||||
return !!((this.decryptdata && this.decryptdata.uri !== null) && (this.decryptdata.key === null));
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {ElementaryStreamTypes} type
|
||||
*/
|
||||
addElementaryStream (type: ElementaryStreamTypes) {
|
||||
this._elementaryStreams[type] = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {ElementaryStreamTypes} type
|
||||
*/
|
||||
hasElementaryStream (type: ElementaryStreamTypes) {
|
||||
return this._elementaryStreams[type] === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility method for parseLevelPlaylist to create an initialization vector for a given segment
|
||||
* @param {number} segmentNumber - segment number to generate IV with
|
||||
* @returns {Uint8Array}
|
||||
*/
|
||||
createInitializationVector (segmentNumber: number): Uint8Array {
|
||||
let uint8View = new Uint8Array(16);
|
||||
|
||||
for (let i = 12; i < 16; i++) {
|
||||
uint8View[i] = (segmentNumber >> 8 * (15 - i)) & 0xff;
|
||||
}
|
||||
|
||||
return uint8View;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility method for parseLevelPlaylist to get a fragment's decryption data from the currently parsed encryption key data
|
||||
* @param levelkey - a playlist's encryption info
|
||||
* @param segmentNumber - the fragment's segment number
|
||||
* @returns {LevelKey} - an object to be applied as a fragment's decryptdata
|
||||
*/
|
||||
setDecryptDataFromLevelKey (levelkey: LevelKey, segmentNumber: number): LevelKey {
|
||||
let decryptdata = levelkey;
|
||||
|
||||
if (levelkey && levelkey.method && levelkey.uri && !levelkey.iv) {
|
||||
decryptdata = new LevelKey(levelkey.baseuri, levelkey.reluri);
|
||||
decryptdata.method = levelkey.method;
|
||||
decryptdata.iv = this.createInitializationVector(segmentNumber);
|
||||
}
|
||||
|
||||
return decryptdata;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
import { buildAbsoluteURL } from 'url-toolkit';
|
||||
|
||||
export default class LevelKey {
|
||||
private _uri: string | null = null;
|
||||
|
||||
public baseuri: string;
|
||||
public reluri: string;
|
||||
public method: string | null = null;
|
||||
public key: Uint8Array | null = null;
|
||||
public iv: Uint8Array | null = null;
|
||||
|
||||
constructor (baseURI: string, relativeURI: string) {
|
||||
this.baseuri = baseURI;
|
||||
this.reluri = relativeURI;
|
||||
}
|
||||
|
||||
get uri () {
|
||||
if (!this._uri && this.reluri) {
|
||||
this._uri = buildAbsoluteURL(this.baseuri, this.reluri, { alwaysNormalize: true });
|
||||
}
|
||||
|
||||
return this._uri;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,370 @@
|
|||
import * as URLToolkit from 'url-toolkit';
|
||||
|
||||
import Fragment from './fragment';
|
||||
import Level from './level';
|
||||
import LevelKey from './level-key';
|
||||
|
||||
import AttrList from '../utils/attr-list';
|
||||
import { logger } from '../utils/logger';
|
||||
import { isCodecType, CodecType } from '../utils/codecs';
|
||||
import { MediaPlaylist, AudioGroup, MediaPlaylistType } from '../types/media-playlist';
|
||||
import { PlaylistLevelType } from '../types/loader';
|
||||
|
||||
/**
|
||||
* M3U8 parser
|
||||
* @module
|
||||
*/
|
||||
|
||||
// https://regex101.com is your friend
|
||||
const MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\n\r]*)[\r\n]+([^\r\n]+)/g;
|
||||
const MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
|
||||
|
||||
const LEVEL_PLAYLIST_REGEX_FAST = new RegExp([
|
||||
/#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*)\s+)?/.source, // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
|
||||
/|(?!#)([\S+ ?]+)/.source, // segment URI, group 3 => the URI (note newline is not eaten)
|
||||
/|#EXT-X-BYTERANGE:*(.+)/.source, // next segment's byterange, group 4 => range spec (x@y)
|
||||
/|#EXT-X-PROGRAM-DATE-TIME:(.+)/.source, // next segment's program date/time group 5 => the datetime spec
|
||||
/|#.*/.source // All other non-segment oriented tags will match with all groups empty
|
||||
].join(''), 'g');
|
||||
|
||||
const LEVEL_PLAYLIST_REGEX_SLOW = /(?:(?:#(EXTM3U))|(?:#EXT-X-(PLAYLIST-TYPE):(.+))|(?:#EXT-X-(MEDIA-SEQUENCE): *(\d+))|(?:#EXT-X-(TARGETDURATION): *(\d+))|(?:#EXT-X-(KEY):(.+))|(?:#EXT-X-(START):(.+))|(?:#EXT-X-(ENDLIST))|(?:#EXT-X-(DISCONTINUITY-SEQ)UENCE:(\d+))|(?:#EXT-X-(DIS)CONTINUITY))|(?:#EXT-X-(VERSION):(\d+))|(?:#EXT-X-(MAP):(.+))|(?:(#)([^:]*):(.*))|(?:(#)(.*))(?:.*)\r?\n?/;
|
||||
|
||||
const MP4_REGEX_SUFFIX = /\.(mp4|m4s|m4v|m4a)$/i;
|
||||
|
||||
export default class M3U8Parser {
|
||||
static findGroup (groups: Array<AudioGroup>, mediaGroupId: string): AudioGroup | undefined {
|
||||
for (let i = 0; i < groups.length; i++) {
|
||||
const group = groups[i];
|
||||
if (group.id === mediaGroupId) {
|
||||
return group;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static convertAVC1ToAVCOTI (codec) {
|
||||
let avcdata = codec.split('.');
|
||||
let result;
|
||||
if (avcdata.length > 2) {
|
||||
result = avcdata.shift() + '.';
|
||||
result += parseInt(avcdata.shift()).toString(16);
|
||||
result += ('000' + parseInt(avcdata.shift()).toString(16)).substr(-4);
|
||||
} else {
|
||||
result = codec;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static resolve (url, baseUrl) {
|
||||
return URLToolkit.buildAbsoluteURL(baseUrl, url, { alwaysNormalize: true });
|
||||
}
|
||||
|
||||
static parseMasterPlaylist (string: string, baseurl: string) {
|
||||
// TODO(typescript-level)
|
||||
let levels: Array<any> = [];
|
||||
MASTER_PLAYLIST_REGEX.lastIndex = 0;
|
||||
|
||||
// TODO(typescript-level)
|
||||
function setCodecs (codecs: Array<string>, level: any) {
|
||||
['video', 'audio'].forEach((type: CodecType) => {
|
||||
const filtered = codecs.filter((codec) => isCodecType(codec, type));
|
||||
if (filtered.length) {
|
||||
const preferred = filtered.filter((codec) => {
|
||||
return codec.lastIndexOf('avc1', 0) === 0 || codec.lastIndexOf('mp4a', 0) === 0;
|
||||
});
|
||||
level[`${type}Codec`] = preferred.length > 0 ? preferred[0] : filtered[0];
|
||||
|
||||
// remove from list
|
||||
codecs = codecs.filter((codec) => filtered.indexOf(codec) === -1);
|
||||
}
|
||||
});
|
||||
|
||||
level.unknownCodecs = codecs;
|
||||
}
|
||||
|
||||
let result: RegExpExecArray | null;
|
||||
while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) {
|
||||
// TODO(typescript-level)
|
||||
const level: any = {};
|
||||
|
||||
const attrs = level.attrs = new AttrList(result[1]);
|
||||
level.url = M3U8Parser.resolve(result[2], baseurl);
|
||||
|
||||
const resolution = attrs.decimalResolution('RESOLUTION');
|
||||
if (resolution) {
|
||||
level.width = resolution.width;
|
||||
level.height = resolution.height;
|
||||
}
|
||||
level.bitrate = attrs.decimalInteger('AVERAGE-BANDWIDTH') || attrs.decimalInteger('BANDWIDTH');
|
||||
level.name = attrs.NAME;
|
||||
|
||||
setCodecs([].concat((attrs.CODECS || '').split(/[ ,]+/)), level);
|
||||
|
||||
if (level.videoCodec && level.videoCodec.indexOf('avc1') !== -1) {
|
||||
level.videoCodec = M3U8Parser.convertAVC1ToAVCOTI(level.videoCodec);
|
||||
}
|
||||
|
||||
levels.push(level);
|
||||
}
|
||||
return levels;
|
||||
}
|
||||
|
||||
static parseMasterPlaylistMedia (string: string, baseurl: string, type: MediaPlaylistType, audioGroups: Array<AudioGroup> = []): Array<MediaPlaylist> {
|
||||
let result: RegExpExecArray | null;
|
||||
let medias: Array<MediaPlaylist> = [];
|
||||
let id = 0;
|
||||
MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
|
||||
while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
|
||||
const attrs = new AttrList(result[1]);
|
||||
if (attrs.TYPE === type) {
|
||||
const media: MediaPlaylist = {
|
||||
id: id++,
|
||||
groupId: attrs['GROUP-ID'],
|
||||
name: attrs.NAME || attrs.LANGUAGE,
|
||||
type,
|
||||
default: (attrs.DEFAULT === 'YES'),
|
||||
autoselect: (attrs.AUTOSELECT === 'YES'),
|
||||
forced: (attrs.FORCED === 'YES'),
|
||||
lang: attrs.LANGUAGE
|
||||
};
|
||||
|
||||
if (attrs.URI) {
|
||||
media.url = M3U8Parser.resolve(attrs.URI, baseurl);
|
||||
}
|
||||
|
||||
if (audioGroups.length) {
|
||||
// If there are audio groups signalled in the manifest, let's look for a matching codec string for this track
|
||||
const groupCodec = M3U8Parser.findGroup(audioGroups, media.groupId);
|
||||
|
||||
// If we don't find the track signalled, lets use the first audio groups codec we have
|
||||
// Acting as a best guess
|
||||
media.audioCodec = groupCodec ? groupCodec.codec : audioGroups[0].codec;
|
||||
}
|
||||
|
||||
medias.push(media);
|
||||
}
|
||||
}
|
||||
return medias;
|
||||
}
|
||||
|
||||
static parseLevelPlaylist (string: string, baseurl: string, id: number, type: PlaylistLevelType, levelUrlId: number) {
|
||||
let currentSN = 0;
|
||||
let totalduration = 0;
|
||||
let level = new Level(baseurl);
|
||||
let discontinuityCounter = 0;
|
||||
let prevFrag: Fragment | null = null;
|
||||
let frag: Fragment | null = new Fragment();
|
||||
let result: RegExpExecArray | RegExpMatchArray | null;
|
||||
let i: number;
|
||||
let levelkey: LevelKey | undefined;
|
||||
|
||||
let firstPdtIndex = null;
|
||||
|
||||
LEVEL_PLAYLIST_REGEX_FAST.lastIndex = 0;
|
||||
|
||||
while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
|
||||
const duration = result[1];
|
||||
if (duration) { // INF
|
||||
frag.duration = parseFloat(duration);
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
const title = (' ' + result[2]).slice(1);
|
||||
frag.title = title || null;
|
||||
frag.tagList.push(title ? [ 'INF', duration, title ] : [ 'INF', duration ]);
|
||||
} else if (result[3]) { // url
|
||||
if (Number.isFinite(frag.duration)) {
|
||||
const sn = currentSN++;
|
||||
frag.type = type;
|
||||
frag.start = totalduration;
|
||||
if (levelkey) {
|
||||
frag.levelkey = levelkey;
|
||||
}
|
||||
frag.sn = sn;
|
||||
frag.level = id;
|
||||
frag.cc = discontinuityCounter;
|
||||
frag.urlId = levelUrlId;
|
||||
frag.baseurl = baseurl;
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
frag.relurl = (' ' + result[3]).slice(1);
|
||||
assignProgramDateTime(frag, prevFrag);
|
||||
|
||||
level.fragments.push(frag);
|
||||
prevFrag = frag;
|
||||
totalduration += frag.duration;
|
||||
|
||||
frag = new Fragment();
|
||||
}
|
||||
} else if (result[4]) { // X-BYTERANGE
|
||||
const data = (' ' + result[4]).slice(1);
|
||||
if (prevFrag) {
|
||||
frag.setByteRange(data, prevFrag);
|
||||
} else {
|
||||
frag.setByteRange(data);
|
||||
}
|
||||
} else if (result[5]) { // PROGRAM-DATE-TIME
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
frag.rawProgramDateTime = (' ' + result[5]).slice(1);
|
||||
frag.tagList.push(['PROGRAM-DATE-TIME', frag.rawProgramDateTime]);
|
||||
if (firstPdtIndex === null) {
|
||||
firstPdtIndex = level.fragments.length;
|
||||
}
|
||||
} else {
|
||||
result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
|
||||
if (!result) {
|
||||
logger.warn('No matches on slow regex match for level playlist!');
|
||||
continue;
|
||||
}
|
||||
for (i = 1; i < result.length; i++) {
|
||||
if (typeof result[i] !== 'undefined') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
|
||||
const value1 = (' ' + result[i + 1]).slice(1);
|
||||
const value2 = (' ' + result[i + 2]).slice(1);
|
||||
|
||||
switch (result[i]) {
|
||||
case '#':
|
||||
frag.tagList.push(value2 ? [ value1, value2 ] : [ value1 ]);
|
||||
break;
|
||||
case 'PLAYLIST-TYPE':
|
||||
level.type = value1.toUpperCase();
|
||||
break;
|
||||
case 'MEDIA-SEQUENCE':
|
||||
currentSN = level.startSN = parseInt(value1);
|
||||
break;
|
||||
case 'TARGETDURATION':
|
||||
level.targetduration = parseFloat(value1);
|
||||
break;
|
||||
case 'VERSION':
|
||||
level.version = parseInt(value1);
|
||||
break;
|
||||
case 'EXTM3U':
|
||||
break;
|
||||
case 'ENDLIST':
|
||||
level.live = false;
|
||||
break;
|
||||
case 'DIS':
|
||||
discontinuityCounter++;
|
||||
frag.tagList.push(['DIS']);
|
||||
break;
|
||||
case 'DISCONTINUITY-SEQ':
|
||||
discontinuityCounter = parseInt(value1);
|
||||
break;
|
||||
case 'KEY': {
|
||||
// https://tools.ietf.org/html/draft-pantos-http-live-streaming-08#section-3.4.4
|
||||
const decryptparams = value1;
|
||||
const keyAttrs = new AttrList(decryptparams);
|
||||
const decryptmethod = keyAttrs.enumeratedString('METHOD');
|
||||
const decrypturi = keyAttrs.URI;
|
||||
const decryptiv = keyAttrs.hexadecimalInteger('IV');
|
||||
|
||||
if (decryptmethod) {
|
||||
levelkey = new LevelKey(baseurl, decrypturi);
|
||||
if ((decrypturi) && (['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC'].indexOf(decryptmethod) >= 0)) {
|
||||
levelkey.method = decryptmethod;
|
||||
levelkey.key = null;
|
||||
// Initialization Vector (IV)
|
||||
levelkey.iv = decryptiv;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'START': {
|
||||
const startAttrs = new AttrList(value1);
|
||||
const startTimeOffset = startAttrs.decimalFloatingPoint('TIME-OFFSET');
|
||||
// TIME-OFFSET can be 0
|
||||
if (Number.isFinite(startTimeOffset)) {
|
||||
level.startTimeOffset = startTimeOffset;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'MAP': {
|
||||
const mapAttrs = new AttrList(value1);
|
||||
frag.relurl = mapAttrs.URI;
|
||||
if (mapAttrs.BYTERANGE) {
|
||||
frag.setByteRange(mapAttrs.BYTERANGE);
|
||||
}
|
||||
frag.baseurl = baseurl;
|
||||
frag.level = id;
|
||||
frag.type = type;
|
||||
frag.sn = 'initSegment';
|
||||
level.initSegment = frag;
|
||||
frag = new Fragment();
|
||||
frag.rawProgramDateTime = level.initSegment.rawProgramDateTime;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
logger.warn(`line parsed but not handled: ${result}`);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
frag = prevFrag;
|
||||
// logger.log('found ' + level.fragments.length + ' fragments');
|
||||
if (frag && !frag.relurl) {
|
||||
level.fragments.pop();
|
||||
totalduration -= frag.duration;
|
||||
}
|
||||
level.totalduration = totalduration;
|
||||
level.averagetargetduration = totalduration / level.fragments.length;
|
||||
level.endSN = currentSN - 1;
|
||||
level.startCC = level.fragments[0] ? level.fragments[0].cc : 0;
|
||||
level.endCC = discontinuityCounter;
|
||||
|
||||
if (!level.initSegment && level.fragments.length) {
|
||||
// this is a bit lurky but HLS really has no other way to tell us
|
||||
// if the fragments are TS or MP4, except if we download them :/
|
||||
// but this is to be able to handle SIDX.
|
||||
if (level.fragments.every((frag) => MP4_REGEX_SUFFIX.test(frag.relurl))) {
|
||||
logger.warn('MP4 fragments found but no init segment (probably no MAP, incomplete M3U8), trying to fetch SIDX');
|
||||
|
||||
frag = new Fragment();
|
||||
frag.relurl = level.fragments[0].relurl;
|
||||
frag.baseurl = baseurl;
|
||||
frag.level = id;
|
||||
frag.type = type;
|
||||
frag.sn = 'initSegment';
|
||||
|
||||
level.initSegment = frag;
|
||||
level.needSidxRanges = true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Backfill any missing PDT values
|
||||
"If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
|
||||
one or more Media Segment URIs, the client SHOULD extrapolate
|
||||
backward from that tag (using EXTINF durations and/or media
|
||||
timestamps) to associate dates with those segments."
|
||||
* We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
|
||||
* computed.
|
||||
*/
|
||||
if (firstPdtIndex) {
|
||||
backfillProgramDateTimes(level.fragments, firstPdtIndex);
|
||||
}
|
||||
|
||||
return level;
|
||||
}
|
||||
}
|
||||
|
||||
function backfillProgramDateTimes (fragments, startIndex) {
|
||||
let fragPrev = fragments[startIndex];
|
||||
for (let i = startIndex - 1; i >= 0; i--) {
|
||||
const frag = fragments[i];
|
||||
frag.programDateTime = fragPrev.programDateTime - (frag.duration * 1000);
|
||||
fragPrev = frag;
|
||||
}
|
||||
}
|
||||
|
||||
function assignProgramDateTime (frag, prevFrag) {
|
||||
if (frag.rawProgramDateTime) {
|
||||
frag.programDateTime = Date.parse(frag.rawProgramDateTime);
|
||||
} else if (prevFrag && prevFrag.programDateTime) {
|
||||
frag.programDateTime = prevFrag.endProgramDateTime;
|
||||
}
|
||||
|
||||
if (!Number.isFinite(frag.programDateTime)) {
|
||||
frag.programDateTime = null;
|
||||
frag.rawProgramDateTime = null;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,530 @@
|
|||
/**
|
||||
* PlaylistLoader - delegate for media manifest/playlist loading tasks. Takes care of parsing media to internal data-models.
|
||||
*
|
||||
* Once loaded, dispatches events with parsed data-models of manifest/levels/audio/subtitle tracks.
|
||||
*
|
||||
* Uses loader(s) set in config to do actual internal loading of resource tasks.
|
||||
*
|
||||
* @module
|
||||
*
|
||||
*/
|
||||
|
||||
import Event from '../events';
|
||||
import EventHandler from '../event-handler';
|
||||
import { ErrorTypes, ErrorDetails } from '../errors';
|
||||
import { logger } from '../utils/logger';
|
||||
import { Loader, PlaylistContextType, PlaylistLoaderContext, PlaylistLevelType, LoaderCallbacks, LoaderResponse, LoaderStats, LoaderConfiguration } from '../types/loader';
|
||||
import MP4Demuxer from '../demux/mp4demuxer';
|
||||
import M3U8Parser from './m3u8-parser';
|
||||
import { AudioGroup } from '../types/media-playlist';
|
||||
|
||||
const { performance } = window;
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
class PlaylistLoader extends EventHandler {
|
||||
private loaders: Partial<Record<PlaylistContextType, Loader<PlaylistLoaderContext>>> = {};
|
||||
|
||||
/**
|
||||
* @constructs
|
||||
* @param {Hls} hls
|
||||
*/
|
||||
constructor (hls) {
|
||||
super(hls,
|
||||
Event.MANIFEST_LOADING,
|
||||
Event.LEVEL_LOADING,
|
||||
Event.AUDIO_TRACK_LOADING,
|
||||
Event.SUBTITLE_TRACK_LOADING);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {PlaylistContextType} type
|
||||
* @returns {boolean}
|
||||
*/
|
||||
static canHaveQualityLevels (type: PlaylistContextType): boolean {
|
||||
return (type !== PlaylistContextType.AUDIO_TRACK &&
|
||||
type !== PlaylistContextType.SUBTITLE_TRACK);
|
||||
}
|
||||
|
||||
/**
|
||||
* Map context.type to LevelType
|
||||
* @param {PlaylistLoaderContext} context
|
||||
* @returns {LevelType}
|
||||
*/
|
||||
static mapContextToLevelType (context: PlaylistLoaderContext): PlaylistLevelType {
|
||||
const { type } = context;
|
||||
|
||||
switch (type) {
|
||||
case PlaylistContextType.AUDIO_TRACK:
|
||||
return PlaylistLevelType.AUDIO;
|
||||
case PlaylistContextType.SUBTITLE_TRACK:
|
||||
return PlaylistLevelType.SUBTITLE;
|
||||
default:
|
||||
return PlaylistLevelType.MAIN;
|
||||
}
|
||||
}
|
||||
|
||||
static getResponseUrl (response: LoaderResponse, context: PlaylistLoaderContext): string {
|
||||
let url = response.url;
|
||||
// responseURL not supported on some browsers (it is used to detect URL redirection)
|
||||
// data-uri mode also not supported (but no need to detect redirection)
|
||||
if (url === undefined || url.indexOf('data:') === 0) {
|
||||
// fallback to initial URL
|
||||
url = context.url;
|
||||
}
|
||||
return url;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns defaults or configured loader-type overloads (pLoader and loader config params)
|
||||
* Default loader is XHRLoader (see utils)
|
||||
* @param {PlaylistLoaderContext} context
|
||||
* @returns {Loader} or other compatible configured overload
|
||||
*/
|
||||
createInternalLoader (context: PlaylistLoaderContext): Loader<PlaylistLoaderContext> {
|
||||
const config = this.hls.config;
|
||||
const PLoader = config.pLoader;
|
||||
const Loader = config.loader;
|
||||
// TODO(typescript-config): Verify once config is typed that InternalLoader always returns a Loader
|
||||
const InternalLoader = PLoader || Loader;
|
||||
|
||||
const loader = new InternalLoader(config);
|
||||
|
||||
// TODO - Do we really need to assign the instance or if the dep has been lost
|
||||
context.loader = loader;
|
||||
this.loaders[context.type] = loader;
|
||||
|
||||
return loader;
|
||||
}
|
||||
|
||||
getInternalLoader (context: PlaylistLoaderContext): Loader<PlaylistLoaderContext> | undefined {
|
||||
return this.loaders[context.type];
|
||||
}
|
||||
|
||||
resetInternalLoader (contextType: PlaylistContextType) {
|
||||
if (this.loaders[contextType]) {
|
||||
delete this.loaders[contextType];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Call `destroy` on all internal loader instances mapped (one per context type)
|
||||
*/
|
||||
destroyInternalLoaders () {
|
||||
for (let contextType in this.loaders) {
|
||||
let loader = this.loaders[contextType];
|
||||
if (loader) {
|
||||
loader.destroy();
|
||||
}
|
||||
|
||||
this.resetInternalLoader(contextType as PlaylistContextType);
|
||||
}
|
||||
}
|
||||
|
||||
destroy () {
|
||||
this.destroyInternalLoaders();
|
||||
|
||||
super.destroy();
|
||||
}
|
||||
|
||||
onManifestLoading (data: { url: string; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.MANIFEST,
|
||||
level: 0,
|
||||
id: null,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
onLevelLoading (data: { url: string; level: number | null; id: number | null; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.LEVEL,
|
||||
level: data.level,
|
||||
id: data.id,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
onAudioTrackLoading (data: { url: string; id: number | null; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.AUDIO_TRACK,
|
||||
level: null,
|
||||
id: data.id,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
onSubtitleTrackLoading (data: { url: string; id: number | null; }) {
|
||||
this.load({
|
||||
url: data.url,
|
||||
type: PlaylistContextType.SUBTITLE_TRACK,
|
||||
level: null,
|
||||
id: data.id,
|
||||
responseType: 'text'
|
||||
});
|
||||
}
|
||||
|
||||
load (context: PlaylistLoaderContext): boolean {
|
||||
const config = this.hls.config;
|
||||
|
||||
logger.debug(`Loading playlist of type ${context.type}, level: ${context.level}, id: ${context.id}`);
|
||||
|
||||
// Check if a loader for this context already exists
|
||||
let loader = this.getInternalLoader(context);
|
||||
if (loader) {
|
||||
const loaderContext = loader.context;
|
||||
if (loaderContext && loaderContext.url === context.url) { // same URL can't overlap
|
||||
logger.trace('playlist request ongoing');
|
||||
return false;
|
||||
} else {
|
||||
logger.warn(`aborting previous loader for type: ${context.type}`);
|
||||
loader.abort();
|
||||
}
|
||||
}
|
||||
|
||||
let maxRetry: number;
|
||||
let timeout: number;
|
||||
let retryDelay: number;
|
||||
let maxRetryDelay: number;
|
||||
|
||||
// apply different configs for retries depending on
|
||||
// context (manifest, level, audio/subs playlist)
|
||||
switch (context.type) {
|
||||
case PlaylistContextType.MANIFEST:
|
||||
maxRetry = config.manifestLoadingMaxRetry;
|
||||
timeout = config.manifestLoadingTimeOut;
|
||||
retryDelay = config.manifestLoadingRetryDelay;
|
||||
maxRetryDelay = config.manifestLoadingMaxRetryTimeout;
|
||||
break;
|
||||
case PlaylistContextType.LEVEL:
|
||||
// Disable internal loader retry logic, since we are managing retries in Level Controller
|
||||
maxRetry = 0;
|
||||
maxRetryDelay = 0;
|
||||
retryDelay = 0;
|
||||
timeout = config.levelLoadingTimeOut;
|
||||
// TODO Introduce retry settings for audio-track and subtitle-track, it should not use level retry config
|
||||
break;
|
||||
default:
|
||||
maxRetry = config.levelLoadingMaxRetry;
|
||||
timeout = config.levelLoadingTimeOut;
|
||||
retryDelay = config.levelLoadingRetryDelay;
|
||||
maxRetryDelay = config.levelLoadingMaxRetryTimeout;
|
||||
break;
|
||||
}
|
||||
|
||||
loader = this.createInternalLoader(context);
|
||||
|
||||
const loaderConfig: LoaderConfiguration = {
|
||||
timeout,
|
||||
maxRetry,
|
||||
retryDelay,
|
||||
maxRetryDelay
|
||||
};
|
||||
|
||||
const loaderCallbacks: LoaderCallbacks<PlaylistLoaderContext> = {
|
||||
onSuccess: this.loadsuccess.bind(this),
|
||||
onError: this.loaderror.bind(this),
|
||||
onTimeout: this.loadtimeout.bind(this)
|
||||
};
|
||||
|
||||
logger.debug(`Calling internal loader delegate for URL: ${context.url}`);
|
||||
loader.load(context, loaderConfig, loaderCallbacks);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
loadsuccess (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown = null) {
|
||||
if (context.isSidxRequest) {
|
||||
this._handleSidxRequest(response, context);
|
||||
this._handlePlaylistLoaded(response, stats, context, networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
this.resetInternalLoader(context.type);
|
||||
if (typeof response.data !== 'string') {
|
||||
throw new Error('expected responseType of "text" for PlaylistLoader');
|
||||
}
|
||||
|
||||
const string = response.data;
|
||||
|
||||
stats.tload = performance.now();
|
||||
// stats.mtime = new Date(target.getResponseHeader('Last-Modified'));
|
||||
|
||||
// Validate if it is an M3U8 at all
|
||||
if (string.indexOf('#EXTM3U') !== 0) {
|
||||
this._handleManifestParsingError(response, context, 'no EXTM3U delimiter', networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if chunk-list or master. handle empty chunk list case (first EXTINF not signaled, but TARGETDURATION present)
|
||||
if (string.indexOf('#EXTINF:') > 0 || string.indexOf('#EXT-X-TARGETDURATION:') > 0) {
|
||||
this._handleTrackOrLevelPlaylist(response, stats, context, networkDetails);
|
||||
} else {
|
||||
this._handleMasterPlaylist(response, stats, context, networkDetails);
|
||||
}
|
||||
}
|
||||
|
||||
loaderror (response: LoaderResponse, context: PlaylistLoaderContext, networkDetails = null) {
|
||||
this._handleNetworkError(context, networkDetails, false, response);
|
||||
}
|
||||
|
||||
loadtimeout (stats: LoaderStats, context: PlaylistLoaderContext, networkDetails = null) {
|
||||
this._handleNetworkError(context, networkDetails, true);
|
||||
}
|
||||
|
||||
// TODO(typescript-config): networkDetails can currently be a XHR or Fetch impl,
|
||||
// but with custom loaders it could be generic investigate this further when config is typed
|
||||
_handleMasterPlaylist (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown) {
|
||||
const hls = this.hls;
|
||||
const string = response.data as string;
|
||||
|
||||
const url = PlaylistLoader.getResponseUrl(response, context);
|
||||
const levels = M3U8Parser.parseMasterPlaylist(string, url);
|
||||
if (!levels.length) {
|
||||
this._handleManifestParsingError(response, context, 'no level found in manifest', networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
// multi level playlist, parse level info
|
||||
const audioGroups: Array<AudioGroup> = levels.map(level => ({
|
||||
id: level.attrs.AUDIO,
|
||||
codec: level.audioCodec
|
||||
}));
|
||||
|
||||
const audioTracks = M3U8Parser.parseMasterPlaylistMedia(string, url, 'AUDIO', audioGroups);
|
||||
const subtitles = M3U8Parser.parseMasterPlaylistMedia(string, url, 'SUBTITLES');
|
||||
|
||||
if (audioTracks.length) {
|
||||
// check if we have found an audio track embedded in main playlist (audio track without URI attribute)
|
||||
let embeddedAudioFound = false;
|
||||
audioTracks.forEach(audioTrack => {
|
||||
if (!audioTrack.url) {
|
||||
embeddedAudioFound = true;
|
||||
}
|
||||
});
|
||||
|
||||
// if no embedded audio track defined, but audio codec signaled in quality level,
|
||||
// we need to signal this main audio track this could happen with playlists with
|
||||
// alt audio rendition in which quality levels (main)
|
||||
// contains both audio+video. but with mixed audio track not signaled
|
||||
if (embeddedAudioFound === false && levels[0].audioCodec && !levels[0].attrs.AUDIO) {
|
||||
logger.log('audio codec signaled in quality level, but no embedded audio track signaled, create one');
|
||||
audioTracks.unshift({
|
||||
type: 'main',
|
||||
name: 'main',
|
||||
default: false,
|
||||
autoselect: false,
|
||||
forced: false,
|
||||
id: -1
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
hls.trigger(Event.MANIFEST_LOADED, {
|
||||
levels,
|
||||
audioTracks,
|
||||
subtitles,
|
||||
url,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
}
|
||||
|
||||
_handleTrackOrLevelPlaylist (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown) {
|
||||
const hls = this.hls;
|
||||
|
||||
const { id, level, type } = context;
|
||||
|
||||
const url = PlaylistLoader.getResponseUrl(response, context);
|
||||
|
||||
// if the values are null, they will result in the else conditional
|
||||
const levelUrlId = Number.isFinite(id as number) ? id as number : 0;
|
||||
const levelId = Number.isFinite(level as number) ? level as number : levelUrlId;
|
||||
|
||||
const levelType = PlaylistLoader.mapContextToLevelType(context);
|
||||
const levelDetails = M3U8Parser.parseLevelPlaylist(response.data as string, url, levelId, levelType, levelUrlId);
|
||||
|
||||
// set stats on level structure
|
||||
// TODO(jstackhouse): why? mixing concerns, is it just treated as value bag?
|
||||
(levelDetails as any).tload = stats.tload;
|
||||
|
||||
// We have done our first request (Manifest-type) and receive
|
||||
// not a master playlist but a chunk-list (track/level)
|
||||
// We fire the manifest-loaded event anyway with the parsed level-details
|
||||
// by creating a single-level structure for it.
|
||||
if (type === PlaylistContextType.MANIFEST) {
|
||||
const singleLevel = {
|
||||
url,
|
||||
details: levelDetails
|
||||
};
|
||||
|
||||
hls.trigger(Event.MANIFEST_LOADED, {
|
||||
levels: [singleLevel],
|
||||
audioTracks: [],
|
||||
url,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
}
|
||||
|
||||
// save parsing time
|
||||
stats.tparsed = performance.now();
|
||||
|
||||
// in case we need SIDX ranges
|
||||
// return early after calling load for
|
||||
// the SIDX box.
|
||||
if (levelDetails.needSidxRanges) {
|
||||
const sidxUrl = levelDetails.initSegment.url;
|
||||
this.load({
|
||||
url: sidxUrl,
|
||||
isSidxRequest: true,
|
||||
type,
|
||||
level,
|
||||
levelDetails,
|
||||
id,
|
||||
rangeStart: 0,
|
||||
rangeEnd: 2048,
|
||||
responseType: 'arraybuffer'
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// extend the context with the new levelDetails property
|
||||
context.levelDetails = levelDetails;
|
||||
|
||||
this._handlePlaylistLoaded(response, stats, context, networkDetails);
|
||||
}
|
||||
|
||||
_handleSidxRequest (response: LoaderResponse, context: PlaylistLoaderContext) {
|
||||
if (typeof response.data === 'string') {
|
||||
throw new Error('sidx request must be made with responseType of array buffer');
|
||||
}
|
||||
|
||||
const sidxInfo = MP4Demuxer.parseSegmentIndex(new Uint8Array(response.data));
|
||||
// if provided fragment does not contain sidx, early return
|
||||
if (!sidxInfo) {
|
||||
return;
|
||||
}
|
||||
const sidxReferences = sidxInfo.references;
|
||||
const levelDetails = context.levelDetails;
|
||||
sidxReferences.forEach((segmentRef, index) => {
|
||||
const segRefInfo = segmentRef.info;
|
||||
if (!levelDetails) {
|
||||
return;
|
||||
}
|
||||
const frag = levelDetails.fragments[index];
|
||||
if (frag.byteRange.length === 0) {
|
||||
frag.setByteRange(String(1 + segRefInfo.end - segRefInfo.start) + '@' + String(segRefInfo.start));
|
||||
}
|
||||
});
|
||||
|
||||
if (levelDetails) {
|
||||
levelDetails.initSegment.setByteRange(String(sidxInfo.moovEndOffset) + '@0');
|
||||
}
|
||||
}
|
||||
|
||||
_handleManifestParsingError (response: LoaderResponse, context: PlaylistLoaderContext, reason: string, networkDetails: unknown) {
|
||||
this.hls.trigger(Event.ERROR, {
|
||||
type: ErrorTypes.NETWORK_ERROR,
|
||||
details: ErrorDetails.MANIFEST_PARSING_ERROR,
|
||||
fatal: true,
|
||||
url: response.url,
|
||||
reason,
|
||||
networkDetails
|
||||
});
|
||||
}
|
||||
|
||||
_handleNetworkError (context: PlaylistLoaderContext, networkDetails: unknown, timeout: boolean = false, response: LoaderResponse | null = null) {
|
||||
logger.info(`A network error occured while loading a ${context.type}-type playlist`);
|
||||
|
||||
let details;
|
||||
let fatal;
|
||||
|
||||
const loader = this.getInternalLoader(context);
|
||||
|
||||
switch (context.type) {
|
||||
case PlaylistContextType.MANIFEST:
|
||||
details = (timeout ? ErrorDetails.MANIFEST_LOAD_TIMEOUT : ErrorDetails.MANIFEST_LOAD_ERROR);
|
||||
fatal = true;
|
||||
break;
|
||||
case PlaylistContextType.LEVEL:
|
||||
details = (timeout ? ErrorDetails.LEVEL_LOAD_TIMEOUT : ErrorDetails.LEVEL_LOAD_ERROR);
|
||||
fatal = false;
|
||||
break;
|
||||
case PlaylistContextType.AUDIO_TRACK:
|
||||
details = (timeout ? ErrorDetails.AUDIO_TRACK_LOAD_TIMEOUT : ErrorDetails.AUDIO_TRACK_LOAD_ERROR);
|
||||
fatal = false;
|
||||
break;
|
||||
default:
|
||||
// details = ...?
|
||||
fatal = false;
|
||||
}
|
||||
|
||||
if (loader) {
|
||||
loader.abort();
|
||||
this.resetInternalLoader(context.type);
|
||||
}
|
||||
|
||||
// TODO(typescript-events): when error events are handled, type this
|
||||
let errorData: any = {
|
||||
type: ErrorTypes.NETWORK_ERROR,
|
||||
details,
|
||||
fatal,
|
||||
url: context.url,
|
||||
loader,
|
||||
context,
|
||||
networkDetails
|
||||
};
|
||||
|
||||
if (response) {
|
||||
errorData.response = response;
|
||||
}
|
||||
|
||||
this.hls.trigger(Event.ERROR, errorData);
|
||||
}
|
||||
|
||||
_handlePlaylistLoaded (response: LoaderResponse, stats: LoaderStats, context: PlaylistLoaderContext, networkDetails: unknown) {
|
||||
const { type, level, id, levelDetails } = context;
|
||||
|
||||
if (!levelDetails || !levelDetails.targetduration) {
|
||||
this._handleManifestParsingError(response, context, 'invalid target duration', networkDetails);
|
||||
return;
|
||||
}
|
||||
|
||||
const canHaveLevels = PlaylistLoader.canHaveQualityLevels(context.type);
|
||||
if (canHaveLevels) {
|
||||
this.hls.trigger(Event.LEVEL_LOADED, {
|
||||
details: levelDetails,
|
||||
level: level || 0,
|
||||
id: id || 0,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
} else {
|
||||
switch (type) {
|
||||
case PlaylistContextType.AUDIO_TRACK:
|
||||
this.hls.trigger(Event.AUDIO_TRACK_LOADED, {
|
||||
details: levelDetails,
|
||||
id,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
break;
|
||||
case PlaylistContextType.SUBTITLE_TRACK:
|
||||
this.hls.trigger(Event.SUBTITLE_TRACK_LOADED, {
|
||||
details: levelDetails,
|
||||
id,
|
||||
stats,
|
||||
networkDetails
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default PlaylistLoader;
|
||||
|
|
@ -0,0 +1,383 @@
|
|||
/*
|
||||
NAME
|
||||
mts-demuxer.js
|
||||
|
||||
AUTHOR
|
||||
Trek Hopton <trek@ausocean.org>
|
||||
|
||||
LICENSE
|
||||
This file is Copyright (C) 2019 the Australian Ocean Lab (AusOcean)
|
||||
|
||||
It is free software: you can redistribute it and/or modify them
|
||||
under the terms of the GNU General Public License as published by the
|
||||
Free Software Foundation, either version 3 of the License, or (at your
|
||||
option) any later version.
|
||||
|
||||
It is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License in gpl.txt.
|
||||
If not, see http://www.gnu.org/licenses.
|
||||
|
||||
For hls.js Copyright notice and license, see LICENSE file.
|
||||
*/
|
||||
|
||||
// MTSDemuxer demultiplexes an MPEG-TS stream into its individual streams.
|
||||
// While it is possible that the MPEG-TS stream may contain many streams,
|
||||
// this demuxer will result in at most one stream of each type ie. video, audio, id3 metadata.
|
||||
class MTSDemuxer {
|
||||
constructor() {
|
||||
this.init();
|
||||
}
|
||||
|
||||
// init initialises MTSDemuxer's state. It can be used to reset an MTSDemuxer instance.
|
||||
init() {
|
||||
this.pmtParsed = false;
|
||||
this._pmtId = -1;
|
||||
|
||||
this._videoTrack = MTSDemuxer.createTrack('video');
|
||||
this._audioTrack = MTSDemuxer.createTrack('audio');
|
||||
this._id3Track = MTSDemuxer.createTrack('id3');
|
||||
}
|
||||
|
||||
// createTrack creates and returns a track model.
|
||||
/**
|
||||
* @param {string} type 'audio' | 'video' | 'id3' | 'text'
|
||||
* @return {object} MTSDemuxer's internal track model.
|
||||
*/
|
||||
static createTrack(type) {
|
||||
return {
|
||||
type,
|
||||
pid: -1,
|
||||
data: [] // This will contain Uint8Arrays representing each PES packet's payload for this track.
|
||||
};
|
||||
}
|
||||
|
||||
// _getTracks returns this MTSDemuxer's tracks.
|
||||
_getTracks() {
|
||||
return {
|
||||
video: this._videoTrack,
|
||||
audio: this._audioTrack,
|
||||
id3: this._id3Track
|
||||
};
|
||||
}
|
||||
|
||||
// _syncOffset scans the first 'maxScanWindow' bytes and returns an offset to the beginning of the first three MTS packets,
|
||||
// or -1 if three are not found.
|
||||
// A TS fragment should contain at least 3 TS packets, a PAT, a PMT, and one PID, each starting with 0x47.
|
||||
static _syncOffset(data) {
|
||||
const maxScanWindow = 1000; // 1000 is a reasonable number of bytes to search for the first MTS packets.
|
||||
const scanWindow = Math.min(maxScanWindow, data.length - 3 * 188);
|
||||
let i = 0;
|
||||
while (i < scanWindow) {
|
||||
if (data[i] === 0x47 && data[i + 188] === 0x47 && data[i + 2 * 188] === 0x47) {
|
||||
return i;
|
||||
} else {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
append(data) {
|
||||
let start, len = data.length, pusi, pid, afc, offset, pes,
|
||||
unknownPIDs = false;
|
||||
let pmtParsed = this.pmtParsed,
|
||||
videoTrack = this._videoTrack,
|
||||
audioTrack = this._audioTrack,
|
||||
id3Track = this._id3Track,
|
||||
videoId = videoTrack.pid,
|
||||
audioId = audioTrack.pid,
|
||||
id3Id = id3Track.pid,
|
||||
pmtId = this._pmtId,
|
||||
videoData = videoTrack.pesData,
|
||||
audioData = audioTrack.pesData,
|
||||
id3Data = id3Track.pesData,
|
||||
parsePAT = this._parsePAT,
|
||||
parsePMT = this._parsePMT,
|
||||
parsePES = this._parsePES;
|
||||
|
||||
const syncOffset = MTSDemuxer._syncOffset(data);
|
||||
|
||||
// Don't parse last TS packet if incomplete.
|
||||
len -= (len + syncOffset) % 188;
|
||||
|
||||
// Loop through TS packets.
|
||||
for (start = syncOffset; start < len; start += 188) {
|
||||
if (data[start] === 0x47) {
|
||||
pusi = !!(data[start + 1] & 0x40);
|
||||
// pid is a 13-bit field starting at the last bit of TS[1].
|
||||
pid = ((data[start + 1] & 0x1f) << 8) + data[start + 2];
|
||||
afc = (data[start + 3] & 0x30) >> 4;
|
||||
// If an adaption field is present, its length is specified by the fifth byte of the TS packet header.
|
||||
if (afc > 1) {
|
||||
offset = start + 5 + data[start + 4];
|
||||
// Continue if there is only adaptation field.
|
||||
if (offset === (start + 188)) {
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
offset = start + 4;
|
||||
}
|
||||
switch (pid) {
|
||||
case videoId:
|
||||
if (pusi) {
|
||||
if (videoData && (pes = parsePES(videoData)) && pes.pts !== undefined) {
|
||||
videoTrack.data.push(pes.data);
|
||||
// TODO: here pes contains data, pts, dts and len. Are all these needed?
|
||||
}
|
||||
videoData = { data: [], size: 0 };
|
||||
}
|
||||
if (videoData) {
|
||||
videoData.data.push(data.subarray(offset, start + 188));
|
||||
videoData.size += start + 188 - offset;
|
||||
}
|
||||
break;
|
||||
case audioId:
|
||||
if (pusi) {
|
||||
if (audioData && (pes = parsePES(audioData)) && pes.pts !== undefined) {
|
||||
audioTrack.data.push(pes.data);
|
||||
}
|
||||
audioData = { data: [], size: 0 };
|
||||
}
|
||||
if (audioData) {
|
||||
audioData.data.push(data.subarray(offset, start + 188));
|
||||
audioData.size += start + 188 - offset;
|
||||
}
|
||||
break;
|
||||
case id3Id:
|
||||
if (pusi) {
|
||||
if (id3Data && (pes = parsePES(id3Data)) && pes.pts !== undefined) {
|
||||
id3Track.data.push(pes.data);
|
||||
}
|
||||
id3Data = { data: [], size: 0 };
|
||||
}
|
||||
if (id3Data) {
|
||||
id3Data.data.push(data.subarray(offset, start + 188));
|
||||
id3Data.size += start + 188 - offset;
|
||||
}
|
||||
break;
|
||||
case 0:
|
||||
if (pusi) {
|
||||
offset += data[offset] + 1;
|
||||
}
|
||||
|
||||
pmtId = this._pmtId = parsePAT(data, offset);
|
||||
break;
|
||||
case pmtId:
|
||||
if (pusi) {
|
||||
offset += data[offset] + 1;
|
||||
}
|
||||
|
||||
let parsedPIDs = parsePMT(data, offset);
|
||||
|
||||
// Only update track id if track PID found while parsing PMT.
|
||||
// This is to avoid resetting the PID to -1 in case track PID transiently disappears from the stream,
|
||||
// this could happen in case of transient missing audio samples for example.
|
||||
videoId = parsedPIDs.video;
|
||||
if (videoId > 0) {
|
||||
videoTrack.pid = videoId;
|
||||
}
|
||||
audioId = parsedPIDs.audio;
|
||||
if (audioId > 0) {
|
||||
audioTrack.pid = audioId;
|
||||
}
|
||||
id3Id = parsedPIDs.id3;
|
||||
if (id3Id > 0) {
|
||||
id3Track.pid = id3Id;
|
||||
}
|
||||
|
||||
if (unknownPIDs && !pmtParsed) {
|
||||
// Reparse from beginning.
|
||||
unknownPIDs = false;
|
||||
// We set it to -188, the += 188 in the for loop will reset start to 0.
|
||||
start = syncOffset - 188;
|
||||
}
|
||||
pmtParsed = this.pmtParsed = true;
|
||||
break;
|
||||
default:
|
||||
unknownPIDs = true;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
console.error('TS packet did not start with 0x47');
|
||||
}
|
||||
}
|
||||
|
||||
// Try to parse last PES packets.
|
||||
if (videoData && (pes = parsePES(videoData)) && pes.pts !== undefined) {
|
||||
videoTrack.data.push(pes.data);
|
||||
videoTrack.pesData = null;
|
||||
} else {
|
||||
// Either pesPkts null or PES truncated, keep it for next frag parsing.
|
||||
videoTrack.pesData = videoData;
|
||||
}
|
||||
|
||||
if (audioData && (pes = parsePES(audioData)) && pes.pts !== undefined) {
|
||||
audioTrack.data.push(pes.data);
|
||||
audioTrack.pesData = null;
|
||||
} else {
|
||||
// Either pesPkts null or PES truncated, keep it for next frag parsing.
|
||||
audioTrack.pesData = audioData;
|
||||
}
|
||||
|
||||
if (id3Data && (pes = parsePES(id3Data)) && pes.pts !== undefined) {
|
||||
id3Track.data.push(pes.data);
|
||||
id3Track.pesData = null;
|
||||
} else {
|
||||
// Either pesPkts null or PES truncated, keep it for next frag parsing.
|
||||
id3Track.pesData = id3Data;
|
||||
}
|
||||
}
|
||||
|
||||
_parsePAT(data, offset) {
|
||||
// Skip the PSI header and parse the first PMT entry.
|
||||
return (data[offset + 10] & 0x1F) << 8 | data[offset + 11];
|
||||
// console.log('PMT PID:' + this._pmtId);
|
||||
}
|
||||
|
||||
_parsePMT(data, offset) {
|
||||
let programInfoLength, pid, result = { audio: -1, video: -1, id3: -1 },
|
||||
sectionLength = (data[offset + 1] & 0x0f) << 8 | data[offset + 2],
|
||||
tableEnd = offset + 3 + sectionLength - 4;
|
||||
// To determine where the table is, we have to figure out how
|
||||
// long the program info descriptors are.
|
||||
programInfoLength = (data[offset + 10] & 0x0f) << 8 | data[offset + 11];
|
||||
// Advance the offset to the first entry in the mapping table.
|
||||
offset += 12 + programInfoLength;
|
||||
while (offset < tableEnd) {
|
||||
pid = (data[offset + 1] & 0x1F) << 8 | data[offset + 2];
|
||||
switch (data[offset]) {
|
||||
case 0x1c: // MJPEG
|
||||
case 0xdb: // SAMPLE-AES AVC.
|
||||
case 0x1b: // ITU-T Rec. H.264 and ISO/IEC 14496-10 (lower bit-rate video).
|
||||
if (result.video === -1) {
|
||||
result.video = pid;
|
||||
}
|
||||
break;
|
||||
case 0xcf: // SAMPLE-AES AAC.
|
||||
case 0x0f: // ISO/IEC 13818-7 ADTS AAC (MPEG-2 lower bit-rate audio).
|
||||
case 0xd2: // ADPCM audio.
|
||||
case 0x03: // ISO/IEC 11172-3 (MPEG-1 audio).
|
||||
case 0x24:
|
||||
// console.warn('HEVC stream type found, not supported for now');
|
||||
case 0x04: // or ISO/IEC 13818-3 (MPEG-2 halved sample rate audio).
|
||||
if (result.audio === -1) {
|
||||
result.audio = pid;
|
||||
}
|
||||
break;
|
||||
case 0x15: // Packetized metadata (ID3)
|
||||
// console.log('ID3 PID:' + pid);
|
||||
if (result.id3 === -1) {
|
||||
result.id3 = pid;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
// console.log('unknown stream type:' + data[offset]);
|
||||
break;
|
||||
}
|
||||
// Move to the next table entry, skip past the elementary stream descriptors, if present.
|
||||
offset += ((data[offset + 3] & 0x0F) << 8 | data[offset + 4]) + 5;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
_parsePES(stream) {
|
||||
let i = 0, frag, pesFlags, pesPrefix, pesLen, pesHdrLen, pesData, pesPts, pesDts, payloadStartOffset, data = stream.data;
|
||||
// Safety check.
|
||||
if (!stream || stream.size === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// We might need up to 19 bytes to read PES header.
|
||||
// If first chunk of data is less than 19 bytes, let's merge it with following ones until we get 19 bytes.
|
||||
// Usually only one merge is needed (and this is rare ...).
|
||||
while (data[0].length < 19 && data.length > 1) {
|
||||
let newData = new Uint8Array(data[0].length + data[1].length);
|
||||
newData.set(data[0]);
|
||||
newData.set(data[1], data[0].length);
|
||||
data[0] = newData;
|
||||
data.splice(1, 1);
|
||||
}
|
||||
// Retrieve PTS/DTS from first fragment.
|
||||
frag = data[0];
|
||||
pesPrefix = (frag[0] << 16) + (frag[1] << 8) + frag[2];
|
||||
if (pesPrefix === 1) {
|
||||
pesLen = (frag[4] << 8) + frag[5];
|
||||
// If PES parsed length is not zero and greater than total received length, stop parsing. PES might be truncated.
|
||||
// Minus 6 : PES header size.
|
||||
if (pesLen && pesLen > stream.size - 6) {
|
||||
return null;
|
||||
}
|
||||
|
||||
pesFlags = frag[7];
|
||||
if (pesFlags & 0xC0) {
|
||||
// PES header described here : http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
|
||||
// As PTS / DTS is 33 bit we cannot use bitwise operator in JS,
|
||||
// as Bitwise operators treat their operands as a sequence of 32 bits.
|
||||
pesPts = (frag[9] & 0x0E) * 536870912 +// 1 << 29
|
||||
(frag[10] & 0xFF) * 4194304 +// 1 << 22
|
||||
(frag[11] & 0xFE) * 16384 +// 1 << 14
|
||||
(frag[12] & 0xFF) * 128 +// 1 << 7
|
||||
(frag[13] & 0xFE) / 2;
|
||||
// Check if greater than 2^32 -1.
|
||||
if (pesPts > 4294967295) {
|
||||
// Decrement 2^33.
|
||||
pesPts -= 8589934592;
|
||||
}
|
||||
if (pesFlags & 0x40) {
|
||||
pesDts = (frag[14] & 0x0E) * 536870912 +// 1 << 29
|
||||
(frag[15] & 0xFF) * 4194304 +// 1 << 22
|
||||
(frag[16] & 0xFE) * 16384 +// 1 << 14
|
||||
(frag[17] & 0xFF) * 128 +// 1 << 7
|
||||
(frag[18] & 0xFE) / 2;
|
||||
// Check if greater than 2^32 -1.
|
||||
if (pesDts > 4294967295) {
|
||||
// Decrement 2^33.
|
||||
pesDts -= 8589934592;
|
||||
}
|
||||
if (pesPts - pesDts > 60 * 90000) {
|
||||
// console.warn(`${Math.round((pesPts - pesDts) / 90000)}s delta between PTS and DTS, align them`);
|
||||
pesPts = pesDts;
|
||||
}
|
||||
} else {
|
||||
pesDts = pesPts;
|
||||
}
|
||||
}
|
||||
pesHdrLen = frag[8];
|
||||
// 9 bytes : 6 bytes for PES header + 3 bytes for PES extension.
|
||||
payloadStartOffset = pesHdrLen + 9;
|
||||
|
||||
stream.size -= payloadStartOffset;
|
||||
// Reassemble PES packet.
|
||||
pesData = new Uint8Array(stream.size);
|
||||
for (let j = 0, dataLen = data.length; j < dataLen; j++) {
|
||||
frag = data[j];
|
||||
let len = frag.byteLength;
|
||||
if (payloadStartOffset) {
|
||||
if (payloadStartOffset > len) {
|
||||
// Trim full frag if PES header bigger than frag.
|
||||
payloadStartOffset -= len;
|
||||
continue;
|
||||
} else {
|
||||
// Trim partial frag if PES header smaller than frag.
|
||||
frag = frag.subarray(payloadStartOffset);
|
||||
len -= payloadStartOffset;
|
||||
payloadStartOffset = 0;
|
||||
}
|
||||
}
|
||||
pesData.set(frag, i);
|
||||
i += len;
|
||||
}
|
||||
if (pesLen) {
|
||||
// Payload size : remove PES header + PES extension.
|
||||
pesLen -= pesHdrLen + 3;
|
||||
}
|
||||
return { data: pesData, pts: pesPts, dts: pesDts, len: pesLen };
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
import { EventEmitter } from 'eventemitter3';
|
||||
|
||||
/**
|
||||
* Simple adapter sub-class of Nodejs-like EventEmitter.
|
||||
*/
|
||||
export class Observer extends EventEmitter {
|
||||
/**
|
||||
* We simply want to pass along the event-name itself
|
||||
* in every call to a handler, which is the purpose of our `trigger` method
|
||||
* extending the standard API.
|
||||
*/
|
||||
trigger (event: string, ...data: Array<any>): void {
|
||||
this.emit(event, event, ...data);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
import Level from '../loader/level';
|
||||
|
||||
export interface LoaderContext {
|
||||
// target URL
|
||||
url: string
|
||||
// loader response type (arraybuffer or default response type for playlist)
|
||||
responseType: string
|
||||
// start byte range offset
|
||||
rangeStart?: number
|
||||
// end byte range offset
|
||||
rangeEnd?: number
|
||||
// true if onProgress should report partial chunk of loaded content
|
||||
progressData?: boolean
|
||||
}
|
||||
|
||||
export interface LoaderConfiguration {
|
||||
// Max number of load retries
|
||||
maxRetry: number
|
||||
// Timeout after which `onTimeOut` callback will be triggered
|
||||
// (if loading is still not finished after that delay)
|
||||
timeout: number
|
||||
// Delay between an I/O error and following connection retry (ms).
|
||||
// This to avoid spamming the server
|
||||
retryDelay: number
|
||||
// max connection retry delay (ms)
|
||||
maxRetryDelay: number
|
||||
}
|
||||
|
||||
export interface LoaderResponse {
|
||||
url: string,
|
||||
// TODO(jstackhouse): SharedArrayBuffer, es2017 extension to TS
|
||||
data: string | ArrayBuffer
|
||||
}
|
||||
|
||||
export interface LoaderStats {
|
||||
// performance.now() just after load() has been called
|
||||
trequest: number
|
||||
// performance.now() of first received byte
|
||||
tfirst: number
|
||||
// performance.now() on load complete
|
||||
tload: number
|
||||
// performance.now() on parse completion
|
||||
tparsed: number
|
||||
// number of loaded bytes
|
||||
loaded: number
|
||||
// total number of bytes
|
||||
total: number
|
||||
}
|
||||
|
||||
type LoaderOnSuccess < T extends LoaderContext > = (
|
||||
response: LoaderResponse,
|
||||
stats: LoaderStats,
|
||||
context: T,
|
||||
networkDetails: any
|
||||
) => void;
|
||||
|
||||
type LoaderOnProgress < T extends LoaderContext > = (
|
||||
stats: LoaderStats,
|
||||
context: T,
|
||||
data: string | ArrayBuffer,
|
||||
networkDetails: any,
|
||||
) => void;
|
||||
|
||||
type LoaderOnError < T extends LoaderContext > = (
|
||||
error: {
|
||||
// error status code
|
||||
code: number,
|
||||
// error description
|
||||
text: string,
|
||||
},
|
||||
context: T,
|
||||
networkDetails: any,
|
||||
) => void;
|
||||
|
||||
type LoaderOnTimeout < T extends LoaderContext > = (
|
||||
stats: LoaderStats,
|
||||
context: T,
|
||||
) => void;
|
||||
|
||||
export interface LoaderCallbacks<T extends LoaderContext>{
|
||||
onSuccess: LoaderOnSuccess<T>,
|
||||
onError: LoaderOnError<T>,
|
||||
onTimeout: LoaderOnTimeout<T>,
|
||||
onProgress?: LoaderOnProgress<T>,
|
||||
}
|
||||
|
||||
export interface Loader<T extends LoaderContext> {
|
||||
destroy(): void
|
||||
abort(): void
|
||||
load(
|
||||
context: LoaderContext,
|
||||
config: LoaderConfiguration,
|
||||
callbacks: LoaderCallbacks<T>,
|
||||
): void
|
||||
|
||||
context: T
|
||||
}
|
||||
|
||||
/**
|
||||
* `type` property values for this loaders' context object
|
||||
* @enum
|
||||
*
|
||||
*/
|
||||
export enum PlaylistContextType {
|
||||
MANIFEST = 'manifest',
|
||||
LEVEL = 'level',
|
||||
AUDIO_TRACK = 'audioTrack',
|
||||
SUBTITLE_TRACK= 'subtitleTrack'
|
||||
}
|
||||
|
||||
/**
|
||||
* @enum {string}
|
||||
*/
|
||||
export enum PlaylistLevelType {
|
||||
MAIN = 'main',
|
||||
AUDIO = 'audio',
|
||||
SUBTITLE = 'subtitle'
|
||||
}
|
||||
|
||||
export interface PlaylistLoaderContext extends LoaderContext {
|
||||
loader?: Loader<PlaylistLoaderContext>
|
||||
|
||||
type: PlaylistContextType
|
||||
// the level index to load
|
||||
level: number | null
|
||||
// TODO: what is id?
|
||||
id: number | null
|
||||
// defines if the loader is handling a sidx request for the playlist
|
||||
isSidxRequest?: boolean
|
||||
// internal reprsentation of a parsed m3u8 level playlist
|
||||
levelDetails?: Level
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
// from http://mp4ra.org/codecs.html
|
||||
const sampleEntryCodesISO = {
|
||||
audio: {
|
||||
'a3ds': true,
|
||||
'ac-3': true,
|
||||
'ac-4': true,
|
||||
'alac': true,
|
||||
'alaw': true,
|
||||
'dra1': true,
|
||||
'dts+': true,
|
||||
'dts-': true,
|
||||
'dtsc': true,
|
||||
'dtse': true,
|
||||
'dtsh': true,
|
||||
'ec-3': true,
|
||||
'enca': true,
|
||||
'g719': true,
|
||||
'g726': true,
|
||||
'm4ae': true,
|
||||
'mha1': true,
|
||||
'mha2': true,
|
||||
'mhm1': true,
|
||||
'mhm2': true,
|
||||
'mlpa': true,
|
||||
'mp4a': true,
|
||||
'raw ': true,
|
||||
'Opus': true,
|
||||
'samr': true,
|
||||
'sawb': true,
|
||||
'sawp': true,
|
||||
'sevc': true,
|
||||
'sqcp': true,
|
||||
'ssmv': true,
|
||||
'twos': true,
|
||||
'ulaw': true
|
||||
},
|
||||
video: {
|
||||
'avc1': true,
|
||||
'avc2': true,
|
||||
'avc3': true,
|
||||
'avc4': true,
|
||||
'avcp': true,
|
||||
'drac': true,
|
||||
'dvav': true,
|
||||
'dvhe': true,
|
||||
'encv': true,
|
||||
'hev1': true,
|
||||
'hvc1': true,
|
||||
'mjp2': true,
|
||||
'mp4v': true,
|
||||
'mvc1': true,
|
||||
'mvc2': true,
|
||||
'mvc3': true,
|
||||
'mvc4': true,
|
||||
'resv': true,
|
||||
'rv60': true,
|
||||
's263': true,
|
||||
'svc1': true,
|
||||
'svc2': true,
|
||||
'vc-1': true,
|
||||
'vp08': true,
|
||||
'vp09': true
|
||||
}
|
||||
};
|
||||
|
||||
export type CodecType = 'audio' | 'video';
|
||||
|
||||
function isCodecType (codec: string, type: CodecType): boolean {
|
||||
const typeCodes = sampleEntryCodesISO[type];
|
||||
return !!typeCodes && typeCodes[codec.slice(0, 4)] === true;
|
||||
}
|
||||
|
||||
function isCodecSupportedInMp4 (codec: string, type: CodecType): boolean {
|
||||
return MediaSource.isTypeSupported(`${type || 'video'}/mp4;codecs="${codec}"`);
|
||||
}
|
||||
|
||||
export { isCodecType, isCodecSupportedInMp4 };
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
/**
|
||||
* XHR based logger
|
||||
*/
|
||||
|
||||
import { logger } from '../utils/logger';
|
||||
|
||||
const { performance, XMLHttpRequest } = window;
|
||||
|
||||
class XhrLoader {
|
||||
constructor (config) {
|
||||
if (config && config.xhrSetup) {
|
||||
this.xhrSetup = config.xhrSetup;
|
||||
}
|
||||
}
|
||||
|
||||
destroy () {
|
||||
this.abort();
|
||||
this.loader = null;
|
||||
}
|
||||
|
||||
abort () {
|
||||
let loader = this.loader;
|
||||
if (loader && loader.readyState !== 4) {
|
||||
this.stats.aborted = true;
|
||||
loader.abort();
|
||||
}
|
||||
|
||||
window.clearTimeout(this.requestTimeout);
|
||||
this.requestTimeout = null;
|
||||
window.clearTimeout(this.retryTimeout);
|
||||
this.retryTimeout = null;
|
||||
}
|
||||
|
||||
load (context, config, callbacks) {
|
||||
this.context = context;
|
||||
this.config = config;
|
||||
this.callbacks = callbacks;
|
||||
this.stats = { trequest: performance.now(), retry: 0 };
|
||||
this.retryDelay = config.retryDelay;
|
||||
this.loadInternal();
|
||||
}
|
||||
|
||||
loadInternal () {
|
||||
let xhr, context = this.context;
|
||||
xhr = this.loader = new XMLHttpRequest();
|
||||
|
||||
let stats = this.stats;
|
||||
stats.tfirst = 0;
|
||||
stats.loaded = 0;
|
||||
const xhrSetup = this.xhrSetup;
|
||||
|
||||
try {
|
||||
if (xhrSetup) {
|
||||
try {
|
||||
xhrSetup(xhr, context.url);
|
||||
} catch (e) {
|
||||
// fix xhrSetup: (xhr, url) => {xhr.setRequestHeader("Content-Language", "test");}
|
||||
// not working, as xhr.setRequestHeader expects xhr.readyState === OPEN
|
||||
xhr.open('GET', context.url, true);
|
||||
xhrSetup(xhr, context.url);
|
||||
}
|
||||
}
|
||||
if (!xhr.readyState) {
|
||||
xhr.open('GET', context.url, true);
|
||||
}
|
||||
} catch (e) {
|
||||
// IE11 throws an exception on xhr.open if attempting to access an HTTP resource over HTTPS
|
||||
this.callbacks.onError({ code: xhr.status, text: e.message }, context, xhr);
|
||||
return;
|
||||
}
|
||||
|
||||
if (context.rangeEnd) {
|
||||
xhr.setRequestHeader('Range', 'bytes=' + context.rangeStart + '-' + (context.rangeEnd - 1));
|
||||
}
|
||||
|
||||
xhr.onreadystatechange = this.readystatechange.bind(this);
|
||||
xhr.onprogress = this.loadprogress.bind(this);
|
||||
xhr.responseType = context.responseType;
|
||||
|
||||
// setup timeout before we perform request
|
||||
this.requestTimeout = window.setTimeout(this.loadtimeout.bind(this), this.config.timeout);
|
||||
xhr.send();
|
||||
}
|
||||
|
||||
readystatechange (event) {
|
||||
let xhr = event.currentTarget,
|
||||
readyState = xhr.readyState,
|
||||
stats = this.stats,
|
||||
context = this.context,
|
||||
config = this.config;
|
||||
|
||||
// don't proceed if xhr has been aborted
|
||||
if (stats.aborted) {
|
||||
return;
|
||||
}
|
||||
|
||||
// >= HEADERS_RECEIVED
|
||||
if (readyState >= 2) {
|
||||
// clear xhr timeout and rearm it if readyState less than 4
|
||||
window.clearTimeout(this.requestTimeout);
|
||||
if (stats.tfirst === 0) {
|
||||
stats.tfirst = Math.max(performance.now(), stats.trequest);
|
||||
}
|
||||
|
||||
if (readyState === 4) {
|
||||
let status = xhr.status;
|
||||
// http status between 200 to 299 are all successful
|
||||
if (status >= 200 && status < 300) {
|
||||
stats.tload = Math.max(stats.tfirst, performance.now());
|
||||
let data, len;
|
||||
if (context.responseType === 'arraybuffer') {
|
||||
data = xhr.response;
|
||||
len = data.byteLength;
|
||||
} else {
|
||||
data = xhr.responseText;
|
||||
len = data.length;
|
||||
}
|
||||
stats.loaded = stats.total = len;
|
||||
let response = { url: xhr.responseURL, data: data };
|
||||
this.callbacks.onSuccess(response, stats, context, xhr);
|
||||
} else {
|
||||
// if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
|
||||
if (stats.retry >= config.maxRetry || (status >= 400 && status < 499)) {
|
||||
logger.error(`${status} while loading ${context.url}`);
|
||||
this.callbacks.onError({ code: status, text: xhr.statusText }, context, xhr);
|
||||
} else {
|
||||
// retry
|
||||
logger.warn(`${status} while loading ${context.url}, retrying in ${this.retryDelay}...`);
|
||||
// aborts and resets internal state
|
||||
this.destroy();
|
||||
// schedule retry
|
||||
this.retryTimeout = window.setTimeout(this.loadInternal.bind(this), this.retryDelay);
|
||||
// set exponential backoff
|
||||
this.retryDelay = Math.min(2 * this.retryDelay, config.maxRetryDelay);
|
||||
stats.retry++;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// readyState >= 2 AND readyState !==4 (readyState = HEADERS_RECEIVED || LOADING) rearm timeout as xhr not finished yet
|
||||
this.requestTimeout = window.setTimeout(this.loadtimeout.bind(this), config.timeout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
loadtimeout () {
|
||||
logger.warn(`timeout while loading ${this.context.url}`);
|
||||
this.callbacks.onTimeout(this.stats, this.context, null);
|
||||
}
|
||||
|
||||
loadprogress (event) {
|
||||
let xhr = event.currentTarget,
|
||||
stats = this.stats;
|
||||
|
||||
stats.loaded = event.loaded;
|
||||
if (event.lengthComputable) {
|
||||
stats.total = event.total;
|
||||
}
|
||||
|
||||
let onProgress = this.callbacks.onProgress;
|
||||
if (onProgress) {
|
||||
// third arg is to provide on progress data
|
||||
onProgress(stats, this.context, null, xhr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default XhrLoader;
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<title>Mjpeg Player</title>
|
||||
<script type="text/javascript" src="main.js"></script>
|
||||
<script type="module" src="player.js"></script>
|
||||
</head>
|
||||
|
||||
<body style="height: 100%">
|
||||
<div class="card m-auto" style="width: 40rem;">
|
||||
<div class="card-body">
|
||||
<div class="container-fluid">
|
||||
<div class="form-group">
|
||||
<input class="form-control-file" type="file" id="fileinput" onchange="play();">
|
||||
</div>
|
||||
</div>
|
||||
<div class="container-fluid">
|
||||
Frame Rate: <input type="text" id="rate" class="mb-3 mx-3" value="30"> fps
|
||||
</div>
|
||||
<div class="container-fluid">
|
||||
<img src="" id="viewer" style="max-width:100%; height:auto;">
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<footer id="sticky-footer" class="footer fixed-bottom py-4 bg-dark text-white-50" style="width: 100%;">
|
||||
<div class="container text-center">
|
||||
<small>©2019 Australian Ocean Laboratory Limited (AusOcean) (<a rel="license" href="https://www.ausocean.org/license">License</a>)</small>
|
||||
</div>
|
||||
</footer>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
/*
|
||||
NAME
|
||||
main.js
|
||||
|
||||
AUTHOR
|
||||
Trek Hopton <trek@ausocean.org>
|
||||
|
||||
LICENSE
|
||||
This file is Copyright (C) 2019 the Australian Ocean Lab (AusOcean)
|
||||
|
||||
It is free software: you can redistribute it and/or modify them
|
||||
under the terms of the GNU General Public License as published by the
|
||||
Free Software Foundation, either version 3 of the License, or (at your
|
||||
option) any later version.
|
||||
|
||||
It is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License in gpl.txt.
|
||||
If not, see http://www.gnu.org/licenses.
|
||||
*/
|
||||
|
||||
// play will process and play the chosen target file.
|
||||
function play() {
|
||||
const viewer = document.getElementById('viewer');
|
||||
const input = event.target.files[0];
|
||||
const reader = new FileReader();
|
||||
|
||||
reader.onload = event => {
|
||||
const player = new Worker("player.js");
|
||||
|
||||
let rate = document.getElementById('rate');
|
||||
if (rate.value && rate.value > 0) {
|
||||
player.postMessage({ msg: "setFrameRate", data: rate.value });
|
||||
}
|
||||
|
||||
player.onmessage = e => {
|
||||
switch (e.data.msg) {
|
||||
case "frame":
|
||||
const blob = new Blob([new Uint8Array(e.data.data)], {
|
||||
type: 'video/x-motion-jpeg'
|
||||
});
|
||||
const url = URL.createObjectURL(blob);
|
||||
viewer.src = url;
|
||||
break;
|
||||
case "log":
|
||||
console.log(e.data.data);
|
||||
break;
|
||||
case "stop":
|
||||
break;
|
||||
default:
|
||||
console.error("unknown message from player");
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
switch (input.name.split('.')[1]) {
|
||||
case "mjpeg":
|
||||
case "mjpg":
|
||||
player.postMessage({ msg: "loadMjpeg", data: event.target.result }, [event.target.result]);
|
||||
break;
|
||||
case "ts":
|
||||
player.postMessage({ msg: "loadMtsMjpeg", data: event.target.result }, [event.target.result]);
|
||||
break;
|
||||
default:
|
||||
console.error("unknown file format");
|
||||
break;
|
||||
}
|
||||
};
|
||||
reader.onerror = error => reject(error);
|
||||
reader.readAsArrayBuffer(input);
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
/*
|
||||
NAME
|
||||
player.js
|
||||
|
||||
AUTHOR
|
||||
Trek Hopton <trek@ausocean.org>
|
||||
|
||||
LICENSE
|
||||
This file is Copyright (C) 2019 the Australian Ocean Lab (AusOcean)
|
||||
|
||||
It is free software: you can redistribute it and/or modify them
|
||||
under the terms of the GNU General Public License as published by the
|
||||
Free Software Foundation, either version 3 of the License, or (at your
|
||||
option) any later version.
|
||||
|
||||
It is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License in gpl.txt.
|
||||
If not, see http://www.gnu.org/licenses.
|
||||
*/
|
||||
|
||||
let frameRate = 30;
|
||||
|
||||
onmessage = e => {
|
||||
switch (e.data.msg) {
|
||||
case "setFrameRate":
|
||||
frameRate = e.data.data;
|
||||
break;
|
||||
case "loadMjpeg":
|
||||
self.importScripts('./lex-mjpeg.js');
|
||||
let mjpeg = new Uint8Array(e.data.data);
|
||||
let lex = new MJPEGLexer(mjpeg);
|
||||
player = new Player(lex);
|
||||
player.setFrameRate(frameRate);
|
||||
player.start();
|
||||
break;
|
||||
case "loadMtsMjpeg":
|
||||
self.importScripts('./hlsjs/mts-demuxer.js');
|
||||
let mtsMjpeg = new Uint8Array(e.data.data);
|
||||
let demux = new MTSDemuxer();
|
||||
let tracks = demux._getTracks();
|
||||
demux.append(mtsMjpeg);
|
||||
buf = new FrameBuffer(tracks.video.data);
|
||||
player = new Player(buf);
|
||||
player.setFrameRate(frameRate); //TODO: read frame rate from metadata.
|
||||
player.start();
|
||||
break;
|
||||
default:
|
||||
console.error("unknown message from main thread");
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
class Player {
|
||||
constructor(buffer) {
|
||||
this.buffer = buffer;
|
||||
this.frameRate = frameRate;
|
||||
}
|
||||
|
||||
setFrameRate(rate) {
|
||||
this.frameRate = rate;
|
||||
}
|
||||
|
||||
start() {
|
||||
let frame = this.buffer.read();
|
||||
if (frame != null) {
|
||||
postMessage({ msg: "frame", data: frame.buffer }, [frame.buffer]);
|
||||
setTimeout(() => { this.start(); }, 1000 / this.frameRate);
|
||||
} else {
|
||||
postMessage({ msg: "stop" });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// FrameBuffer allows an array of subarrays (MJPEG frames) to be read one at a time.
|
||||
class FrameBuffer {
|
||||
constructor(src) {
|
||||
this.src = src;
|
||||
this.off = 0;
|
||||
}
|
||||
|
||||
// read returns the next single frame.
|
||||
read() {
|
||||
return this.src[this.off++];
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
// see https://tools.ietf.org/html/rfc1808
|
||||
|
||||
/* jshint ignore:start */
|
||||
(function(root) {
|
||||
/* jshint ignore:end */
|
||||
|
||||
var URL_REGEX = /^((?:[a-zA-Z0-9+\-.]+:)?)(\/\/[^\/?#]*)?((?:[^\/\?#]*\/)*.*?)??(;.*?)?(\?.*?)?(#.*?)?$/;
|
||||
var FIRST_SEGMENT_REGEX = /^([^\/?#]*)(.*)$/;
|
||||
var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
|
||||
var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/).*?(?=\/)/g;
|
||||
|
||||
var URLToolkit = { // jshint ignore:line
|
||||
// If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
|
||||
// E.g
|
||||
// With opts.alwaysNormalize = false (default, spec compliant)
|
||||
// http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
|
||||
// With opts.alwaysNormalize = true (not spec compliant)
|
||||
// http://a.com/b/cd + /e/f/../g => http://a.com/e/g
|
||||
buildAbsoluteURL: function(baseURL, relativeURL, opts) {
|
||||
opts = opts || {};
|
||||
// remove any remaining space and CRLF
|
||||
baseURL = baseURL.trim();
|
||||
relativeURL = relativeURL.trim();
|
||||
if (!relativeURL) {
|
||||
// 2a) If the embedded URL is entirely empty, it inherits the
|
||||
// entire base URL (i.e., is set equal to the base URL)
|
||||
// and we are done.
|
||||
if (!opts.alwaysNormalize) {
|
||||
return baseURL;
|
||||
}
|
||||
var basePartsForNormalise = URLToolkit.parseURL(baseURL);
|
||||
if (!basePartsForNormalise) {
|
||||
throw new Error('Error trying to parse base URL.');
|
||||
}
|
||||
basePartsForNormalise.path = URLToolkit.normalizePath(basePartsForNormalise.path);
|
||||
return URLToolkit.buildURLFromParts(basePartsForNormalise);
|
||||
}
|
||||
var relativeParts = URLToolkit.parseURL(relativeURL);
|
||||
if (!relativeParts) {
|
||||
throw new Error('Error trying to parse relative URL.');
|
||||
}
|
||||
if (relativeParts.scheme) {
|
||||
// 2b) If the embedded URL starts with a scheme name, it is
|
||||
// interpreted as an absolute URL and we are done.
|
||||
if (!opts.alwaysNormalize) {
|
||||
return relativeURL;
|
||||
}
|
||||
relativeParts.path = URLToolkit.normalizePath(relativeParts.path);
|
||||
return URLToolkit.buildURLFromParts(relativeParts);
|
||||
}
|
||||
var baseParts = URLToolkit.parseURL(baseURL);
|
||||
if (!baseParts) {
|
||||
throw new Error('Error trying to parse base URL.');
|
||||
}
|
||||
if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== '/') {
|
||||
// If netLoc missing and path doesn't start with '/', assume everthing before the first '/' is the netLoc
|
||||
// This causes 'example.com/a' to be handled as '//example.com/a' instead of '/example.com/a'
|
||||
var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);
|
||||
baseParts.netLoc = pathParts[1];
|
||||
baseParts.path = pathParts[2];
|
||||
}
|
||||
if (baseParts.netLoc && !baseParts.path) {
|
||||
baseParts.path = '/';
|
||||
}
|
||||
var builtParts = {
|
||||
// 2c) Otherwise, the embedded URL inherits the scheme of
|
||||
// the base URL.
|
||||
scheme: baseParts.scheme,
|
||||
netLoc: relativeParts.netLoc,
|
||||
path: null,
|
||||
params: relativeParts.params,
|
||||
query: relativeParts.query,
|
||||
fragment: relativeParts.fragment
|
||||
};
|
||||
if (!relativeParts.netLoc) {
|
||||
// 3) If the embedded URL's <net_loc> is non-empty, we skip to
|
||||
// Step 7. Otherwise, the embedded URL inherits the <net_loc>
|
||||
// (if any) of the base URL.
|
||||
builtParts.netLoc = baseParts.netLoc;
|
||||
// 4) If the embedded URL path is preceded by a slash "/", the
|
||||
// path is not relative and we skip to Step 7.
|
||||
if (relativeParts.path[0] !== '/') {
|
||||
if (!relativeParts.path) {
|
||||
// 5) If the embedded URL path is empty (and not preceded by a
|
||||
// slash), then the embedded URL inherits the base URL path
|
||||
builtParts.path = baseParts.path;
|
||||
// 5a) if the embedded URL's <params> is non-empty, we skip to
|
||||
// step 7; otherwise, it inherits the <params> of the base
|
||||
// URL (if any) and
|
||||
if (!relativeParts.params) {
|
||||
builtParts.params = baseParts.params;
|
||||
// 5b) if the embedded URL's <query> is non-empty, we skip to
|
||||
// step 7; otherwise, it inherits the <query> of the base
|
||||
// URL (if any) and we skip to step 7.
|
||||
if (!relativeParts.query) {
|
||||
builtParts.query = baseParts.query;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// 6) The last segment of the base URL's path (anything
|
||||
// following the rightmost slash "/", or the entire path if no
|
||||
// slash is present) is removed and the embedded URL's path is
|
||||
// appended in its place.
|
||||
var baseURLPath = baseParts.path;
|
||||
var newPath = baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) + relativeParts.path;
|
||||
builtParts.path = URLToolkit.normalizePath(newPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (builtParts.path === null) {
|
||||
builtParts.path = opts.alwaysNormalize ? URLToolkit.normalizePath(relativeParts.path) : relativeParts.path;
|
||||
}
|
||||
return URLToolkit.buildURLFromParts(builtParts);
|
||||
},
|
||||
parseURL: function(url) {
|
||||
var parts = URL_REGEX.exec(url);
|
||||
if (!parts) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
scheme: parts[1] || '',
|
||||
netLoc: parts[2] || '',
|
||||
path: parts[3] || '',
|
||||
params: parts[4] || '',
|
||||
query: parts[5] || '',
|
||||
fragment: parts[6] || ''
|
||||
};
|
||||
},
|
||||
normalizePath: function(path) {
|
||||
// The following operations are
|
||||
// then applied, in order, to the new path:
|
||||
// 6a) All occurrences of "./", where "." is a complete path
|
||||
// segment, are removed.
|
||||
// 6b) If the path ends with "." as a complete path segment,
|
||||
// that "." is removed.
|
||||
path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, '');
|
||||
// 6c) All occurrences of "<segment>/../", where <segment> is a
|
||||
// complete path segment not equal to "..", are removed.
|
||||
// Removal of these path segments is performed iteratively,
|
||||
// removing the leftmost matching pattern on each iteration,
|
||||
// until no matching pattern remains.
|
||||
// 6d) If the path ends with "<segment>/..", where <segment> is a
|
||||
// complete path segment not equal to "..", that
|
||||
// "<segment>/.." is removed.
|
||||
while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length) {} // jshint ignore:line
|
||||
return path.split('').reverse().join('');
|
||||
},
|
||||
buildURLFromParts: function(parts) {
|
||||
return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;
|
||||
}
|
||||
};
|
||||
|
||||
/* jshint ignore:start */
|
||||
if(typeof exports === 'object' && typeof module === 'object')
|
||||
module.exports = URLToolkit;
|
||||
else if(typeof define === 'function' && define.amd)
|
||||
define([], function() { return URLToolkit; });
|
||||
else if(typeof exports === 'object')
|
||||
exports["URLToolkit"] = URLToolkit;
|
||||
else
|
||||
root["URLToolkit"] = URLToolkit;
|
||||
})(this);
|
||||
/* jshint ignore:end */
|
||||
Loading…
Reference in New Issue