mirror
/
av
mirror of https://bitbucket.org/ausocean/av.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merged in m3u-ts-2 (pull request #350) 

mjpeg-player: ts code to js code

Approved-by: Scott Barnard
This commit is contained in:
Trek Hopton 2020-01-28 05:47:34 +00:00
parent 4bbfa9ee6a 8af11ab4de
commit c1a8f4be2a
7 changed files with 352 additions and 321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
cmd/mjpeg-player/hlsjs/event-handler.js
View File

@ -1,13 +1,32 @@
/*
AUTHOR
Trek Hopton <trek@ausocean.org>
LICENSE
This file is Copyright (C) 2020 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.
*/
/* /*
* *
* All objects in the event handling chain should inherit from this class * All objects in the event handling chain should inherit from this class
* *
*/ */
import Event from './events.js';
import { logger } from './utils/logger';
import { ErrorTypes, ErrorDetails } from './errors';
import Event from './events';
import Hls from './hls';
const FORBIDDEN_EVENT_NAMES = { const FORBIDDEN_EVENT_NAMES = {
'hlsEventGeneric': true, 'hlsEventGeneric': true,
@ -16,11 +35,7 @@ const FORBIDDEN_EVENT_NAMES = {
}; };
class EventHandler { class EventHandler {
hls: Hls; constructor(hls, ...events) {
handledEvents: any[];
useGenericHandler: boolean;
constructor (hls: Hls, ...events: any[]) {
this.hls = hls; this.hls = hls;
this.onEvent = this.onEvent.bind(this); this.onEvent = this.onEvent.bind(this);
this.handledEvents = events; this.handledEvents = events;
@ -29,20 +44,20 @@ class EventHandler {
this.registerListeners(); this.registerListeners();
} }
destroy () { destroy() {
this.onHandlerDestroying(); this.onHandlerDestroying();
this.unregisterListeners(); this.unregisterListeners();
this.onHandlerDestroyed(); this.onHandlerDestroyed();
} }
protected onHandlerDestroying () {} onHandlerDestroying() { }
protected onHandlerDestroyed () {} onHandlerDestroyed() { }
isEventHandler () { isEventHandler() {
return typeof this.handledEvents === 'object' && this.handledEvents.length && typeof this.onEvent === 'function'; return typeof this.handledEvents === 'object' && this.handledEvents.length && typeof this.onEvent === 'function';
} }
registerListeners () { registerListeners() {
if (this.isEventHandler()) { if (this.isEventHandler()) {
this.handledEvents.forEach(function (event) { this.handledEvents.forEach(function (event) {
if (FORBIDDEN_EVENT_NAMES[event]) { if (FORBIDDEN_EVENT_NAMES[event]) {
@ -54,7 +69,7 @@ class EventHandler {
} }
} }
unregisterListeners () { unregisterListeners() {
if (this.isEventHandler()) { if (this.isEventHandler()) {
this.handledEvents.forEach(function (event) { this.handledEvents.forEach(function (event) {
this.hls.off(event, this.onEvent); this.hls.off(event, this.onEvent);
@ -65,12 +80,12 @@ class EventHandler {
/** /**
* arguments: event (string), data (any) * arguments: event (string), data (any)
*/ */
onEvent (event: string, data: any) { onEvent(event, data) {
this.onEventGeneric(event, data); this.onEventGeneric(event, data);
} }
onEventGeneric (event: string, data: any) { onEventGeneric(event, data) {
let eventToFunction = function (event: string, data: any) { let eventToFunction = function (event, data) {
let funcName = 'on' + event.replace('hls', ''); let funcName = 'on' + event.replace('hls', '');
if (typeof this[funcName] !== 'function') { if (typeof this[funcName] !== 'function') {
throw new Error(`Event ${event} has no generic handler in this ${this.constructor.name} class (tried ${funcName})`); throw new Error(`Event ${event} has no generic handler in this ${this.constructor.name} class (tried ${funcName})`);
@ -81,7 +96,7 @@ class EventHandler {
try { try {
eventToFunction.call(this, event, data).call(); eventToFunction.call(this, event, data).call();
} catch (err) { } catch (err) {
logger.error(`An internal error happened while handling event ${event}. Error message: "${err.message}". Here is a stacktrace:`, err); console.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 }); this.hls.trigger(Event.ERROR, { type: ErrorTypes.OTHER_ERROR, details: ErrorDetails.INTERNAL_EXCEPTION, fatal: false, event: event, err: err });
} }
} }

151
cmd/mjpeg-player/hlsjs/loader/fragment.js
View File

@ -1,69 +1,90 @@
/*
AUTHOR
Trek Hopton <trek@ausocean.org>
import { buildAbsoluteURL } from 'url-toolkit'; LICENSE
import { logger } from '../utils/logger'; This file is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
import LevelKey from './level-key';
import { PlaylistLevelType } from '../types/loader';
export enum ElementaryStreamTypes { It is free software: you can redistribute it and/or modify them
AUDIO = 'audio', under the terms of the GNU General Public License as published by the
VIDEO = 'video', 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.
*/
import URLToolkit from '../../url-toolkit/url-toolkit.js';
import LevelKey from './level-key.js';
export const ElementaryStreamTypes = {
AUDIO: 'audio',
VIDEO: 'video'
} }
export default class Fragment { export default class Fragment {
private _url: string | null = null; constructor() {
private _byteRange: number[] | null = null; this._url = null;
private _decryptdata: LevelKey | null = null; this._byteRange = null;
this._decryptdata = null;
// Holds the types of data this fragment supports // Holds the types of data this fragment supports
private _elementaryStreams: Record<ElementaryStreamTypes, boolean> = { this._elementaryStreams = {
[ElementaryStreamTypes.AUDIO]: false, [ElementaryStreamTypes.AUDIO]: false,
[ElementaryStreamTypes.VIDEO]: false [ElementaryStreamTypes.VIDEO]: false
}; };
// deltaPTS tracks the change in presentation timestamp between fragments // deltaPTS tracks the change in presentation timestamp between fragments
public deltaPTS: number = 0; this.deltaPTS = 0;
public rawProgramDateTime: string | null = null; this.rawProgramDateTime = null;
public programDateTime: number | null = null; this.programDateTime = null;
public title: string | null = null; this.title = null;
public tagList: Array<string[]> = []; this.tagList = [];
// TODO: Move at least baseurl to constructor. // 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. // 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. // 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? // Have Fragment be the representation once we have a known state?
// Something to think on. // Something to think on.
// Discontinuity Counter // Discontinuity Counter
public cc!: number; this.cc;
this.type;
// relurl is the portion of the URL that comes from inside the playlist.
this.relurl;
// baseurl is the URL to the playlist
this.baseurl;
// EXTINF has to be present for a m3u8 to be considered valid
this.duration;
// When this segment starts in the timeline
this.start;
// sn notates the sequence number for a segment, and if set to a string can be 'initSegment'
this.sn = 0;
public type!: PlaylistLevelType; this.urlId = 0;
// relurl is the portion of the URL that comes from inside the playlist. // level matches this fragment to a index playlist
public relurl!: string; this.level = 0;
// baseurl is the URL to the playlist // levelkey is the EXT-X-KEY that applies to this segment for decryption
public baseurl!: string; // core difference from the private field _decryptdata is the lack of the initialized IV
// EXTINF has to be present for a m3u8 to be considered valid // _decryptdata will set the IV for this segment based on the segment number in the fragment
public duration!: number; this.levelkey;
// 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; // TODO(typescript-xhrloader)
// level matches this fragment to a index playlist this.loader;
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 converts a EXT-X-BYTERANGE attribute into a two element array
setByteRange (value: string, previousFrag?: Fragment) { setByteRange(value, previousFrag) {
const params = value.split('@', 2); const params = value.split('@', 2);
const byteRange: number[] = []; const byteRange = [];
if (params.length === 1) { if (params.length === 1) {
byteRange[0] = previousFrag ? previousFrag.byteRangeEndOffset : 0; byteRange[0] = previousFrag ? previousFrag.byteRangeEndOffset : 0;
} else { } else {
@ -73,19 +94,19 @@ export default class Fragment {
this._byteRange = byteRange; this._byteRange = byteRange;
} }
get url () { get url() {
if (!this._url && this.relurl) { if (!this._url && this.relurl) {
this._url = buildAbsoluteURL(this.baseurl, this.relurl, { alwaysNormalize: true }); this._url = URLToolkit.buildAbsoluteURL(this.baseurl, this.relurl, { alwaysNormalize: true });
} }
return this._url; return this._url;
} }
set url (value) { set url(value) {
this._url = value; this._url = value;
} }
get byteRange (): number[] { get byteRange() {
if (!this._byteRange) { if (!this._byteRange) {
return []; return [];
} }
@ -96,15 +117,15 @@ export default class Fragment {
/** /**
* @type {number} * @type {number}
*/ */
get byteRangeStartOffset () { get byteRangeStartOffset() {
return this.byteRange[0]; return this.byteRange[0];
} }
get byteRangeEndOffset () { get byteRangeEndOffset() {
return this.byteRange[1]; return this.byteRange[1];
} }
get decryptdata (): LevelKey | null { get decryptdata() {
if (!this.levelkey && !this._decryptdata) { if (!this.levelkey && !this._decryptdata) {
return null; return null;
} }
@ -116,7 +137,7 @@ export default class Fragment {
// If the segment was encrypted with AES-128 // If the segment was encrypted with AES-128
// It must have an IV defined. We cannot substitute the Segment Number in. // It must have an IV defined. We cannot substitute the Segment Number in.
if (this.levelkey && this.levelkey.method === 'AES-128' && !this.levelkey.iv) { 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`); console.warn(`missing IV for initialization segment with method="${this.levelkey.method}" - compliance issue`);
} }
/* /*
@ -134,7 +155,7 @@ export default class Fragment {
return this._decryptdata; return this._decryptdata;
} }
get endProgramDateTime () { get endProgramDateTime() {
if (this.programDateTime === null) { if (this.programDateTime === null) {
return null; return null;
} }
@ -148,21 +169,21 @@ export default class Fragment {
return this.programDateTime + (duration * 1000); return this.programDateTime + (duration * 1000);
} }
get encrypted () { get encrypted() {
return !!((this.decryptdata && this.decryptdata.uri !== null) && (this.decryptdata.key === null)); return !!((this.decryptdata && this.decryptdata.uri !== null) && (this.decryptdata.key === null));
} }
/** /**
* @param {ElementaryStreamTypes} type * @param {ElementaryStreamTypes} type
*/ */
addElementaryStream (type: ElementaryStreamTypes) { addElementaryStream(type) {
this._elementaryStreams[type] = true; this._elementaryStreams[type] = true;
} }
/** /**
* @param {ElementaryStreamTypes} type * @param {ElementaryStreamTypes} type
*/ */
hasElementaryStream (type: ElementaryStreamTypes) { hasElementaryStream(type) {
return this._elementaryStreams[type] === true; return this._elementaryStreams[type] === true;
} }
@ -171,7 +192,7 @@ export default class Fragment {
* @param {number} segmentNumber - segment number to generate IV with * @param {number} segmentNumber - segment number to generate IV with
* @returns {Uint8Array} * @returns {Uint8Array}
*/ */
createInitializationVector (segmentNumber: number): Uint8Array { createInitializationVector(segmentNumber) {
let uint8View = new Uint8Array(16); let uint8View = new Uint8Array(16);
for (let i = 12; i < 16; i++) { for (let i = 12; i < 16; i++) {
@ -187,7 +208,7 @@ export default class Fragment {
* @param segmentNumber - the fragment's segment number * @param segmentNumber - the fragment's segment number
* @returns {LevelKey} - an object to be applied as a fragment's decryptdata * @returns {LevelKey} - an object to be applied as a fragment's decryptdata
*/ */
setDecryptDataFromLevelKey (levelkey: LevelKey, segmentNumber: number): LevelKey { setDecryptDataFromLevelKey(levelkey, segmentNumber) {
let decryptdata = levelkey; let decryptdata = levelkey;
if (levelkey && levelkey.method && levelkey.uri && !levelkey.iv) { if (levelkey && levelkey.method && levelkey.uri && !levelkey.iv) {

43
cmd/mjpeg-player/hlsjs/loader/level-key.js
View File

@ -1,22 +1,45 @@
import { buildAbsoluteURL } from 'url-toolkit'; /*
AUTHOR
Trek Hopton <trek@ausocean.org>
LICENSE
This file is Copyright (C) 2020 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.
*/
import URLToolkit from '../../url-toolkit/url-toolkit.js';
export default class LevelKey { export default class LevelKey {
private _uri: string | null = null; constructor(baseURI, relativeURI) {
this._uri = null;
public baseuri: string; this.baseuri;
public reluri: string; this.reluri;
public method: string | null = null; this.method = null;
public key: Uint8Array | null = null; this.key = null;
public iv: Uint8Array | null = null; this.iv = null;
constructor (baseURI: string, relativeURI: string) {
this.baseuri = baseURI; this.baseuri = baseURI;
this.reluri = relativeURI; this.reluri = relativeURI;
} }
get uri () { get uri() {
if (!this._uri && this.reluri) { if (!this._uri && this.reluri) {
this._uri = buildAbsoluteURL(this.baseuri, this.reluri, { alwaysNormalize: true }); this._uri = URLToolkit.buildAbsoluteURL(this.baseuri, this.reluri, { alwaysNormalize: true });
} }
return this._uri; return this._uri;

222
cmd/mjpeg-player/hlsjs/loader/m3u8-parser.js
View File

@ -1,14 +1,32 @@
import * as URLToolkit from 'url-toolkit'; /*
AUTHOR
Trek Hopton <trek@ausocean.org>
import Fragment from './fragment'; LICENSE
import Level from './level'; This file is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
import LevelKey from './level-key';
import AttrList from '../utils/attr-list'; It is free software: you can redistribute it and/or modify them
import { logger } from '../utils/logger'; under the terms of the GNU General Public License as published by the
import { isCodecType, CodecType } from '../utils/codecs'; Free Software Foundation, either version 3 of the License, or (at your
import { MediaPlaylist, AudioGroup, MediaPlaylistType } from '../types/media-playlist'; option) any later version.
import { PlaylistLevelType } from '../types/loader';
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.
*/
import URLToolkit from '../../url-toolkit/url-toolkit.js';
import Fragment from './fragment.js';
import Level from './level.js';
import LevelKey from './level-key.js';
import AttrList from '../utils/attr-list.js';
import { isCodecType } from '../utils/codecs.js';
/** /**
* M3U8 parser * M3U8 parser
@ -32,7 +50,7 @@ const LEVEL_PLAYLIST_REGEX_SLOW = /(?:(?:#(EXTM3U))|(?:#EXT-X-(PLAYLIST-TYPE):(.
const MP4_REGEX_SUFFIX = /\.(mp4|m4s|m4v|m4a)$/i; const MP4_REGEX_SUFFIX = /\.(mp4|m4s|m4v|m4a)$/i;
export default class M3U8Parser { export default class M3U8Parser {
static findGroup (groups: Array<AudioGroup>, mediaGroupId: string): AudioGroup | undefined { static findGroup(groups, mediaGroupId) {
for (let i = 0; i < groups.length; i++) { for (let i = 0; i < groups.length; i++) {
const group = groups[i]; const group = groups[i];
if (group.id === mediaGroupId) { if (group.id === mediaGroupId) {
@ -41,7 +59,7 @@ export default class M3U8Parser {
} }
} }
static convertAVC1ToAVCOTI (codec) { static convertAVC1ToAVCOTI(codec) {
let avcdata = codec.split('.'); let avcdata = codec.split('.');
let result; let result;
if (avcdata.length > 2) { if (avcdata.length > 2) {
@ -54,18 +72,18 @@ export default class M3U8Parser {
return result; return result;
} }
static resolve (url, baseUrl) { static resolve(url, baseUrl) {
return URLToolkit.buildAbsoluteURL(baseUrl, url, { alwaysNormalize: true }); return URLToolkit.buildAbsoluteURL(baseUrl, url, { alwaysNormalize: true });
} }
static parseMasterPlaylist (string: string, baseurl: string) { static parseMasterPlaylist(string, baseurl) {
// TODO(typescript-level) // TODO(typescript-level)
let levels: Array<any> = []; let levels = [];
MASTER_PLAYLIST_REGEX.lastIndex = 0; MASTER_PLAYLIST_REGEX.lastIndex = 0;
// TODO(typescript-level) // TODO(typescript-level)
function setCodecs (codecs: Array<string>, level: any) { function setCodecs(codecs, level) {
['video', 'audio'].forEach((type: CodecType) => { ['video', 'audio'].forEach((type) => {
const filtered = codecs.filter((codec) => isCodecType(codec, type)); const filtered = codecs.filter((codec) => isCodecType(codec, type));
if (filtered.length) { if (filtered.length) {
const preferred = filtered.filter((codec) => { const preferred = filtered.filter((codec) => {
@ -81,10 +99,10 @@ export default class M3U8Parser {
level.unknownCodecs = codecs; level.unknownCodecs = codecs;
} }
let result: RegExpExecArray | null; let result;
while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) { while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) {
// TODO(typescript-level) // TODO(typescript-level)
const level: any = {}; const level = {};
const attrs = level.attrs = new AttrList(result[1]); const attrs = level.attrs = new AttrList(result[1]);
level.url = M3U8Parser.resolve(result[2], baseurl); level.url = M3U8Parser.resolve(result[2], baseurl);
@ -108,15 +126,15 @@ export default class M3U8Parser {
return levels; return levels;
} }
static parseMasterPlaylistMedia (string: string, baseurl: string, type: MediaPlaylistType, audioGroups: Array<AudioGroup> = []): Array<MediaPlaylist> { static parseMasterPlaylistMedia(string, baseurl, type, audioGroups = []) {
let result: RegExpExecArray | null; let result;
let medias: Array<MediaPlaylist> = []; let medias = [];
let id = 0; let id = 0;
MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0; MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) { while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
const attrs = new AttrList(result[1]); const attrs = new AttrList(result[1]);
if (attrs.TYPE === type) { if (attrs.TYPE === type) {
const media: MediaPlaylist = { const media = {
id: id++, id: id++,
groupId: attrs['GROUP-ID'], groupId: attrs['GROUP-ID'],
name: attrs.NAME || attrs.LANGUAGE, name: attrs.NAME || attrs.LANGUAGE,
@ -146,16 +164,16 @@ export default class M3U8Parser {
return medias; return medias;
} }
static parseLevelPlaylist (string: string, baseurl: string, id: number, type: PlaylistLevelType, levelUrlId: number) { static parseLevelPlaylist(string, baseurl, id, type, levelUrlId) {
let currentSN = 0; let currentSN = 0;
let totalduration = 0; let totalduration = 0;
let level = new Level(baseurl); let level = new Level(baseurl);
let discontinuityCounter = 0; let discontinuityCounter = 0;
let prevFrag: Fragment | null = null; let prevFrag = null;
let frag: Fragment | null = new Fragment(); let frag = new Fragment();
let result: RegExpExecArray | RegExpMatchArray | null; let result;
let i: number; let i;
let levelkey: LevelKey | undefined; let levelkey;
let firstPdtIndex = null; let firstPdtIndex = null;
@ -168,7 +186,7 @@ export default class M3U8Parser {
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939 // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
const title = (' ' + result[2]).slice(1); const title = (' ' + result[2]).slice(1);
frag.title = title || null; frag.title = title || null;
frag.tagList.push(title ? [ 'INF', duration, title ] : [ 'INF', duration ]); frag.tagList.push(title ? ['INF', duration, title] : ['INF', duration]);
} else if (result[3]) { // url } else if (result[3]) { // url
if (Number.isFinite(frag.duration)) { if (Number.isFinite(frag.duration)) {
const sn = currentSN++; const sn = currentSN++;
@ -209,7 +227,7 @@ export default class M3U8Parser {
} else { } else {
result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW); result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
if (!result) { if (!result) {
logger.warn('No matches on slow regex match for level playlist!'); console.warn('No matches on slow regex match for level playlist!');
continue; continue;
} }
for (i = 1; i < result.length; i++) { for (i = 1; i < result.length; i++) {
@ -223,84 +241,84 @@ export default class M3U8Parser {
const value2 = (' ' + result[i + 2]).slice(1); const value2 = (' ' + result[i + 2]).slice(1);
switch (result[i]) { switch (result[i]) {
case '#': case '#':
frag.tagList.push(value2 ? [ value1, value2 ] : [ value1 ]); frag.tagList.push(value2 ? [value1, value2] : [value1]);
break; break;
case 'PLAYLIST-TYPE': case 'PLAYLIST-TYPE':
level.type = value1.toUpperCase(); level.type = value1.toUpperCase();
break; break;
case 'MEDIA-SEQUENCE': case 'MEDIA-SEQUENCE':
currentSN = level.startSN = parseInt(value1); currentSN = level.startSN = parseInt(value1);
break; break;
case 'TARGETDURATION': case 'TARGETDURATION':
level.targetduration = parseFloat(value1); level.targetduration = parseFloat(value1);
break; break;
case 'VERSION': case 'VERSION':
level.version = parseInt(value1); level.version = parseInt(value1);
break; break;
case 'EXTM3U': case 'EXTM3U':
break; break;
case 'ENDLIST': case 'ENDLIST':
level.live = false; level.live = false;
break; break;
case 'DIS': case 'DIS':
discontinuityCounter++; discontinuityCounter++;
frag.tagList.push(['DIS']); frag.tagList.push(['DIS']);
break; break;
case 'DISCONTINUITY-SEQ': case 'DISCONTINUITY-SEQ':
discontinuityCounter = parseInt(value1); discontinuityCounter = parseInt(value1);
break; break;
case 'KEY': { case 'KEY': {
// https://tools.ietf.org/html/draft-pantos-http-live-streaming-08#section-3.4.4 // https://tools.ietf.org/html/draft-pantos-http-live-streaming-08#section-3.4.4
const decryptparams = value1; const decryptparams = value1;
const keyAttrs = new AttrList(decryptparams); const keyAttrs = new AttrList(decryptparams);
const decryptmethod = keyAttrs.enumeratedString('METHOD'); const decryptmethod = keyAttrs.enumeratedString('METHOD');
const decrypturi = keyAttrs.URI; const decrypturi = keyAttrs.URI;
const decryptiv = keyAttrs.hexadecimalInteger('IV'); const decryptiv = keyAttrs.hexadecimalInteger('IV');
if (decryptmethod) { if (decryptmethod) {
levelkey = new LevelKey(baseurl, decrypturi); levelkey = new LevelKey(baseurl, decrypturi);
if ((decrypturi) && (['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC'].indexOf(decryptmethod) >= 0)) { if ((decrypturi) && (['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC'].indexOf(decryptmethod) >= 0)) {
levelkey.method = decryptmethod; levelkey.method = decryptmethod;
levelkey.key = null; levelkey.key = null;
// Initialization Vector (IV) // Initialization Vector (IV)
levelkey.iv = decryptiv; levelkey.iv = decryptiv;
}
} }
break;
} }
break; case 'START': {
} const startAttrs = new AttrList(value1);
case 'START': { const startTimeOffset = startAttrs.decimalFloatingPoint('TIME-OFFSET');
const startAttrs = new AttrList(value1); // TIME-OFFSET can be 0
const startTimeOffset = startAttrs.decimalFloatingPoint('TIME-OFFSET'); if (Number.isFinite(startTimeOffset)) {
// TIME-OFFSET can be 0 level.startTimeOffset = startTimeOffset;
if (Number.isFinite(startTimeOffset)) { }
level.startTimeOffset = startTimeOffset; break;
} }
break; case 'MAP': {
} const mapAttrs = new AttrList(value1);
case 'MAP': { frag.relurl = mapAttrs.URI;
const mapAttrs = new AttrList(value1); if (mapAttrs.BYTERANGE) {
frag.relurl = mapAttrs.URI; frag.setByteRange(mapAttrs.BYTERANGE);
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;
} }
frag.baseurl = baseurl; default:
frag.level = id; console.warn(`line parsed but not handled: ${result}`);
frag.type = type; break;
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; frag = prevFrag;
// logger.log('found ' + level.fragments.length + ' fragments'); // console.log('found ' + level.fragments.length + ' fragments');
if (frag && !frag.relurl) { if (frag && !frag.relurl) {
level.fragments.pop(); level.fragments.pop();
totalduration -= frag.duration; totalduration -= frag.duration;
@ -316,7 +334,7 @@ export default class M3U8Parser {
// if the fragments are TS or MP4, except if we download them :/ // if the fragments are TS or MP4, except if we download them :/
// but this is to be able to handle SIDX. // but this is to be able to handle SIDX.
if (level.fragments.every((frag) => MP4_REGEX_SUFFIX.test(frag.relurl))) { 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'); console.warn('MP4 fragments found but no init segment (probably no MAP, incomplete M3U8), trying to fetch SIDX');
frag = new Fragment(); frag = new Fragment();
frag.relurl = level.fragments[0].relurl; frag.relurl = level.fragments[0].relurl;
@ -347,7 +365,7 @@ export default class M3U8Parser {
} }
} }
function backfillProgramDateTimes (fragments, startIndex) { function backfillProgramDateTimes(fragments, startIndex) {
let fragPrev = fragments[startIndex]; let fragPrev = fragments[startIndex];
for (let i = startIndex - 1; i >= 0; i--) { for (let i = startIndex - 1; i >= 0; i--) {
const frag = fragments[i]; const frag = fragments[i];
@ -356,7 +374,7 @@ function backfillProgramDateTimes (fragments, startIndex) {
} }
} }
function assignProgramDateTime (frag, prevFrag) { function assignProgramDateTime(frag, prevFrag) {
if (frag.rawProgramDateTime) { if (frag.rawProgramDateTime) {
frag.programDateTime = Date.parse(frag.rawProgramDateTime); frag.programDateTime = Date.parse(frag.rawProgramDateTime);
} else if (prevFrag && prevFrag.programDateTime) { } else if (prevFrag && prevFrag.programDateTime) {

27
cmd/mjpeg-player/hlsjs/observer.js
View File

@ -1,4 +1,27 @@
import { EventEmitter } from 'eventemitter3'; /*
AUTHOR
Trek Hopton <trek@ausocean.org>
LICENSE
This file is Copyright (C) 2020 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.
*/
import EventEmitter from '../eventemitter3/index.js';
/** /**
* Simple adapter sub-class of Nodejs-like EventEmitter. * Simple adapter sub-class of Nodejs-like EventEmitter.
@ -9,7 +32,7 @@ export class Observer extends EventEmitter {
* in every call to a handler, which is the purpose of our `trigger` method * in every call to a handler, which is the purpose of our `trigger` method
* extending the standard API. * extending the standard API.
*/ */
trigger (event: string, ...data: Array<any>): void { trigger(event, ...data) {
this.emit(event, event, ...data); this.emit(event, event, ...data);
} }
} }

146
cmd/mjpeg-player/hlsjs/types/loader.js
View File

@ -1,132 +1,42 @@
import Level from '../loader/level'; /*
AUTHOR
Trek Hopton <trek@ausocean.org>
export interface LoaderContext { LICENSE
// target URL This file is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
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 { It is free software: you can redistribute it and/or modify them
// Max number of load retries under the terms of the GNU General Public License as published by the
maxRetry: number Free Software Foundation, either version 3 of the License, or (at your
// Timeout after which `onTimeOut` callback will be triggered option) any later version.
// (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 { It is distributed in the hope that it will be useful, but WITHOUT
url: string, ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// TODO(jstackhouse): SharedArrayBuffer, es2017 extension to TS FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
data: string | ArrayBuffer for more details.
}
export interface LoaderStats { You should have received a copy of the GNU General Public License in gpl.txt.
// performance.now() just after load() has been called If not, see http://www.gnu.org/licenses.
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 > = ( For hls.js Copyright notice and license, see LICENSE file.
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 * @readonly
* @enum * @enum {string}
*
*/ */
export enum PlaylistContextType { export const PlaylistContextType = {
MANIFEST = 'manifest', MANIFEST: 'manifest',
LEVEL = 'level', LEVEL: 'level',
AUDIO_TRACK = 'audioTrack', AUDIO_TRACK: 'audioTrack',
SUBTITLE_TRACK= 'subtitleTrack' SUBTITLE_TRACK: 'subtitleTrack'
} }
/** /**
* @enum {string} * @enum {string}
*/ */
export enum PlaylistLevelType { export const PlaylistLevelType = {
MAIN = 'main', MAIN: 'main',
AUDIO = 'audio', AUDIO: 'audio',
SUBTITLE = 'subtitle' 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
} }

29
cmd/mjpeg-player/hlsjs/utils/codecs.js
View File

@ -1,3 +1,26 @@
/*
AUTHOR
Trek Hopton <trek@ausocean.org>
LICENSE
This file is Copyright (C) 2020 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.
*/
// from http://mp4ra.org/codecs.html // from http://mp4ra.org/codecs.html
const sampleEntryCodesISO = { const sampleEntryCodesISO = {
audio: { audio: {
@ -63,14 +86,12 @@ const sampleEntryCodesISO = {
} }
}; };
export type CodecType = 'audio' | 'video'; function isCodecType(codec, type) {
function isCodecType (codec: string, type: CodecType): boolean {
const typeCodes = sampleEntryCodesISO[type]; const typeCodes = sampleEntryCodesISO[type];
return !!typeCodes && typeCodes[codec.slice(0, 4)] === true; return !!typeCodes && typeCodes[codec.slice(0, 4)] === true;
} }
function isCodecSupportedInMp4 (codec: string, type: CodecType): boolean { function isCodecSupportedInMp4(codec, type) {
return MediaSource.isTypeSupported(`${type || 'video'}/mp4;codecs="${codec}"`); return MediaSource.isTypeSupported(`${type || 'video'}/mp4;codecs="${codec}"`);
} }