You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
15 KiB
390 lines
15 KiB
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _stream = require('./stream');
|
|
|
|
var _stream2 = _interopRequireDefault(_stream);
|
|
|
|
var _lineStream = require('./line-stream');
|
|
|
|
var _lineStream2 = _interopRequireDefault(_lineStream);
|
|
|
|
var _parseStream = require('./parse-stream');
|
|
|
|
var _parseStream2 = _interopRequireDefault(_parseStream);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
|
|
* @file m3u8/parser.js
|
|
*/
|
|
|
|
|
|
/**
|
|
* A parser for M3U8 files. The current interpretation of the input is
|
|
* exposed as a property `manifest` on parser objects. It's just two lines to
|
|
* create and parse a manifest once you have the contents available as a string:
|
|
*
|
|
* ```js
|
|
* var parser = new m3u8.Parser();
|
|
* parser.push(xhr.responseText);
|
|
* ```
|
|
*
|
|
* New input can later be applied to update the manifest object by calling
|
|
* `push` again.
|
|
*
|
|
* The parser attempts to create a usable manifest object even if the
|
|
* underlying input is somewhat nonsensical. It emits `info` and `warning`
|
|
* events during the parse if it encounters input that seems invalid or
|
|
* requires some property of the manifest object to be defaulted.
|
|
*
|
|
* @class Parser
|
|
* @extends Stream
|
|
*/
|
|
var Parser = function (_Stream) {
|
|
_inherits(Parser, _Stream);
|
|
|
|
function Parser() {
|
|
_classCallCheck(this, Parser);
|
|
|
|
var _this = _possibleConstructorReturn(this, (Parser.__proto__ || Object.getPrototypeOf(Parser)).call(this));
|
|
|
|
_this.lineStream = new _lineStream2['default']();
|
|
_this.parseStream = new _parseStream2['default']();
|
|
_this.lineStream.pipe(_this.parseStream);
|
|
/* eslint-disable consistent-this */
|
|
var self = _this;
|
|
/* eslint-enable consistent-this */
|
|
var uris = [];
|
|
var currentUri = {};
|
|
// if specified, the active EXT-X-MAP definition
|
|
var currentMap = void 0;
|
|
// if specified, the active decryption key
|
|
var _key = void 0;
|
|
var noop = function noop() {};
|
|
var defaultMediaGroups = {
|
|
'AUDIO': {},
|
|
'VIDEO': {},
|
|
'CLOSED-CAPTIONS': {},
|
|
'SUBTITLES': {}
|
|
};
|
|
// group segments into numbered timelines delineated by discontinuities
|
|
var currentTimeline = 0;
|
|
|
|
// the manifest is empty until the parse stream begins delivering data
|
|
_this.manifest = {
|
|
allowCache: true,
|
|
discontinuityStarts: [],
|
|
segments: []
|
|
};
|
|
|
|
// update the manifest with the m3u8 entry from the parse stream
|
|
_this.parseStream.on('data', function (entry) {
|
|
var mediaGroup = void 0;
|
|
var rendition = void 0;
|
|
|
|
({
|
|
tag: function tag() {
|
|
// switch based on the tag type
|
|
(({
|
|
'allow-cache': function allowCache() {
|
|
this.manifest.allowCache = entry.allowed;
|
|
if (!('allowed' in entry)) {
|
|
this.trigger('info', {
|
|
message: 'defaulting allowCache to YES'
|
|
});
|
|
this.manifest.allowCache = true;
|
|
}
|
|
},
|
|
byterange: function byterange() {
|
|
var byterange = {};
|
|
|
|
if ('length' in entry) {
|
|
currentUri.byterange = byterange;
|
|
byterange.length = entry.length;
|
|
|
|
if (!('offset' in entry)) {
|
|
this.trigger('info', {
|
|
message: 'defaulting offset to zero'
|
|
});
|
|
entry.offset = 0;
|
|
}
|
|
}
|
|
if ('offset' in entry) {
|
|
currentUri.byterange = byterange;
|
|
byterange.offset = entry.offset;
|
|
}
|
|
},
|
|
endlist: function endlist() {
|
|
this.manifest.endList = true;
|
|
},
|
|
inf: function inf() {
|
|
if (!('mediaSequence' in this.manifest)) {
|
|
this.manifest.mediaSequence = 0;
|
|
this.trigger('info', {
|
|
message: 'defaulting media sequence to zero'
|
|
});
|
|
}
|
|
if (!('discontinuitySequence' in this.manifest)) {
|
|
this.manifest.discontinuitySequence = 0;
|
|
this.trigger('info', {
|
|
message: 'defaulting discontinuity sequence to zero'
|
|
});
|
|
}
|
|
if (entry.duration > 0) {
|
|
currentUri.duration = entry.duration;
|
|
}
|
|
|
|
if (entry.duration === 0) {
|
|
currentUri.duration = 0.01;
|
|
this.trigger('info', {
|
|
message: 'updating zero segment duration to a small value'
|
|
});
|
|
}
|
|
|
|
this.manifest.segments = uris;
|
|
},
|
|
key: function key() {
|
|
if (!entry.attributes) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring key declaration without attribute list'
|
|
});
|
|
return;
|
|
}
|
|
// clear the active encryption key
|
|
if (entry.attributes.METHOD === 'NONE') {
|
|
_key = null;
|
|
return;
|
|
}
|
|
if (!entry.attributes.URI) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring key declaration without URI'
|
|
});
|
|
return;
|
|
}
|
|
if (!entry.attributes.METHOD) {
|
|
this.trigger('warn', {
|
|
message: 'defaulting key method to AES-128'
|
|
});
|
|
}
|
|
|
|
// setup an encryption key for upcoming segments
|
|
_key = {
|
|
method: entry.attributes.METHOD || 'AES-128',
|
|
uri: entry.attributes.URI
|
|
};
|
|
|
|
if (typeof entry.attributes.IV !== 'undefined') {
|
|
_key.iv = entry.attributes.IV;
|
|
}
|
|
},
|
|
'media-sequence': function mediaSequence() {
|
|
if (!isFinite(entry.number)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid media sequence: ' + entry.number
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.mediaSequence = entry.number;
|
|
},
|
|
'discontinuity-sequence': function discontinuitySequence() {
|
|
if (!isFinite(entry.number)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid discontinuity sequence: ' + entry.number
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.discontinuitySequence = entry.number;
|
|
currentTimeline = entry.number;
|
|
},
|
|
'playlist-type': function playlistType() {
|
|
if (!/VOD|EVENT/.test(entry.playlistType)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring unknown playlist type: ' + entry.playlist
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.playlistType = entry.playlistType;
|
|
},
|
|
map: function map() {
|
|
currentMap = {};
|
|
if (entry.uri) {
|
|
currentMap.uri = entry.uri;
|
|
}
|
|
if (entry.byterange) {
|
|
currentMap.byterange = entry.byterange;
|
|
}
|
|
},
|
|
'stream-inf': function streamInf() {
|
|
this.manifest.playlists = uris;
|
|
this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
|
|
|
|
if (!entry.attributes) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring empty stream-inf attributes'
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (!currentUri.attributes) {
|
|
currentUri.attributes = {};
|
|
}
|
|
_extends(currentUri.attributes, entry.attributes);
|
|
},
|
|
media: function media() {
|
|
this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
|
|
|
|
if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring incomplete or missing media group'
|
|
});
|
|
return;
|
|
}
|
|
|
|
// find the media group, creating defaults as necessary
|
|
var mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
|
|
|
|
mediaGroupType[entry.attributes['GROUP-ID']] = mediaGroupType[entry.attributes['GROUP-ID']] || {};
|
|
mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']];
|
|
|
|
// collect the rendition metadata
|
|
rendition = {
|
|
'default': /yes/i.test(entry.attributes.DEFAULT)
|
|
};
|
|
if (rendition['default']) {
|
|
rendition.autoselect = true;
|
|
} else {
|
|
rendition.autoselect = /yes/i.test(entry.attributes.AUTOSELECT);
|
|
}
|
|
if (entry.attributes.LANGUAGE) {
|
|
rendition.language = entry.attributes.LANGUAGE;
|
|
}
|
|
if (entry.attributes.URI) {
|
|
rendition.uri = entry.attributes.URI;
|
|
}
|
|
if (entry.attributes['INSTREAM-ID']) {
|
|
rendition.instreamId = entry.attributes['INSTREAM-ID'];
|
|
}
|
|
if (entry.attributes.CHARACTERISTICS) {
|
|
rendition.characteristics = entry.attributes.CHARACTERISTICS;
|
|
}
|
|
if (entry.attributes.FORCED) {
|
|
rendition.forced = /yes/i.test(entry.attributes.FORCED);
|
|
}
|
|
|
|
// insert the new rendition
|
|
mediaGroup[entry.attributes.NAME] = rendition;
|
|
},
|
|
discontinuity: function discontinuity() {
|
|
currentTimeline += 1;
|
|
currentUri.discontinuity = true;
|
|
this.manifest.discontinuityStarts.push(uris.length);
|
|
},
|
|
'program-date-time': function programDateTime() {
|
|
this.manifest.dateTimeString = entry.dateTimeString;
|
|
this.manifest.dateTimeObject = entry.dateTimeObject;
|
|
},
|
|
targetduration: function targetduration() {
|
|
if (!isFinite(entry.duration) || entry.duration < 0) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid target duration: ' + entry.duration
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.targetDuration = entry.duration;
|
|
},
|
|
totalduration: function totalduration() {
|
|
if (!isFinite(entry.duration) || entry.duration < 0) {
|
|
this.trigger('warn', {
|
|
message: 'ignoring invalid total duration: ' + entry.duration
|
|
});
|
|
return;
|
|
}
|
|
this.manifest.totalDuration = entry.duration;
|
|
},
|
|
'cue-out': function cueOut() {
|
|
currentUri.cueOut = entry.data;
|
|
},
|
|
'cue-out-cont': function cueOutCont() {
|
|
currentUri.cueOutCont = entry.data;
|
|
},
|
|
'cue-in': function cueIn() {
|
|
currentUri.cueIn = entry.data;
|
|
}
|
|
})[entry.tagType] || noop).call(self);
|
|
},
|
|
uri: function uri() {
|
|
currentUri.uri = entry.uri;
|
|
uris.push(currentUri);
|
|
|
|
// if no explicit duration was declared, use the target duration
|
|
if (this.manifest.targetDuration && !('duration' in currentUri)) {
|
|
this.trigger('warn', {
|
|
message: 'defaulting segment duration to the target duration'
|
|
});
|
|
currentUri.duration = this.manifest.targetDuration;
|
|
}
|
|
// annotate with encryption information, if necessary
|
|
if (_key) {
|
|
currentUri.key = _key;
|
|
}
|
|
currentUri.timeline = currentTimeline;
|
|
// annotate with initialization segment information, if necessary
|
|
if (currentMap) {
|
|
currentUri.map = currentMap;
|
|
}
|
|
|
|
// prepare for the next URI
|
|
currentUri = {};
|
|
},
|
|
comment: function comment() {
|
|
// comments are not important for playback
|
|
}
|
|
})[entry.type].call(self);
|
|
});
|
|
|
|
return _this;
|
|
}
|
|
|
|
/**
|
|
* Parse the input string and update the manifest object.
|
|
*
|
|
* @param {String} chunk a potentially incomplete portion of the manifest
|
|
*/
|
|
|
|
|
|
_createClass(Parser, [{
|
|
key: 'push',
|
|
value: function push(chunk) {
|
|
this.lineStream.push(chunk);
|
|
}
|
|
|
|
/**
|
|
* Flush any remaining input. This can be handy if the last line of an M3U8
|
|
* manifest did not contain a trailing newline but the file has been
|
|
* completely received.
|
|
*/
|
|
|
|
}, {
|
|
key: 'end',
|
|
value: function end() {
|
|
// flush any buffered input
|
|
this.lineStream.push('\n');
|
|
}
|
|
}]);
|
|
|
|
return Parser;
|
|
}(_stream2['default']);
|
|
|
|
exports['default'] = Parser; |