App-MHFS
view release on metacpan or search on metacpan
lib/App/MHFS.pm view on Meta::CPAN
return \%self;
}
sub new {
my ($class, $evp, $cb) = @_;
my $self = _new(@_);
$cb->($self->{fulfill}, $self->{reject});
return $self;
}
sub throw {
return MHFS::Promise::FakeException->new(@_);
}
sub handleResolved {
my ($self, $deferred) = @_;
$self->{evp}->add_timer(0, 0, sub {
my $success = $self->{state} == MHFS_PROMISE_SUCCESS;
my $value = $self->{end_value};
if($success && $deferred->{onFulfilled}) {
$value = $deferred->{onFulfilled}($value);
lib/App/MHFS.pm view on Meta::CPAN
make_path($metadir);
MHFS::Util::write_file("$metadir/plot.txt", $_[0]->{results}[0]{overview});
}
if($metadatatype eq 'plot') {
$request->SendLocalFile("$metadir/plot.txt");
return;
}
# thumb or fanart
my $imagepartial = ($metadatatype eq 'thumb') ? $_[0]->{results}[0]{poster_path} : $_[0]->{results}[0]{backdrop_path};
if (!$imagepartial || $imagepartial !~ /(\.[^\.]+)$/) {
return MHFS::Promise::throw('path not matched');
}
my $ext = $1;
make_path($metadir);
return MHFS::Promise->new($request->{client}{server}{evp}, sub {
my ($resolve, $reject) = @_;
if(! defined $self->{tmdbconfig}) {
$resolve->(_TMDB_api_promise($request->{client}{server}, 'configuration')->then( sub {
$self->{tmdbconfig} = $_[0];
return $_[0];
}));
share/public_html/static/browse_gazelle_music.html view on Meta::CPAN
}
function get_browse(url) {
fetch(url)
.then(res => res.json())
.then((out) => {
console.log('Checkout this JSON! ', out);
dirsplayjson(out);
})
.catch(err => { throw err });
}
</script>
share/public_html/static/hls.js view on Meta::CPAN
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 = this.parseURL(baseURL);
if (!baseParts) {
throw new Error('Error trying to parse base URL.');
}
basePartsForNormalise.path = URLToolkit.normalizePath(basePartsForNormalise.path);
return URLToolkit.buildURLFromParts(basePartsForNormalise);
}
var relativeParts = this.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 = this.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 = '/';
share/public_html/static/hls.js view on Meta::CPAN
})(this);
/* jshint ignore:end */
/***/ }),
/* 5 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return utf8ArrayToStr; });
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* ID3 parser
*/
var ID3 = function () {
function ID3() {
_classCallCheck(this, ID3);
}
/**
share/public_html/static/hls.js view on Meta::CPAN
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};
EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;
if (!this._events)
this._events = {};
// If there is no 'error' event listener then throw.
if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
} else {
// At least give some kind of context to the user
var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
err.context = er;
throw err;
}
}
}
handler = this._events[type];
if (isUndefined(handler))
return false;
if (isFunction(handler)) {
share/public_html/static/hls.js view on Meta::CPAN
listeners[i].apply(this, args);
}
return true;
};
EventEmitter.prototype.addListener = function(type, listener) {
var m;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events)
this._events = {};
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);
share/public_html/static/hls.js view on Meta::CPAN
}
}
return this;
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.once = function(type, listener) {
if (!isFunction(listener))
throw TypeError('listener must be a function');
var fired = false;
function g() {
this.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(this, arguments);
}
share/public_html/static/hls.js view on Meta::CPAN
this.on(type, g);
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events || !this._events[type])
return this;
list = this._events[type];
length = list.length;
position = -1;
if (list === listener ||
(isFunction(list.listener) && list.listener === listener)) {
share/public_html/static/hls.js view on Meta::CPAN
}
/***/ }),
/* 7 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// CONCATENATED MODULE: ./src/crypt/aes-crypto.js
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var AESCrypto = function () {
function AESCrypto(subtle, iv) {
_classCallCheck(this, AESCrypto);
this.subtle = subtle;
this.aesIV = iv;
}
AESCrypto.prototype.decrypt = function decrypt(data, key) {
return this.subtle.decrypt({ name: 'AES-CBC', iv: this.aesIV }, key, data);
};
return AESCrypto;
}();
/* harmony default export */ var aes_crypto = (AESCrypto);
// CONCATENATED MODULE: ./src/crypt/fast-aes-key.js
function fast_aes_key__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var FastAESKey = function () {
function FastAESKey(subtle, key) {
fast_aes_key__classCallCheck(this, FastAESKey);
this.subtle = subtle;
this.key = key;
}
FastAESKey.prototype.expandKey = function expandKey() {
return this.subtle.importKey('raw', this.key, { name: 'AES-CBC' }, false, ['encrypt', 'decrypt']);
};
return FastAESKey;
}();
/* harmony default export */ var fast_aes_key = (FastAESKey);
// CONCATENATED MODULE: ./src/crypt/aes-decryptor.js
function aes_decryptor__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
// PKCS7
function removePadding(buffer) {
var outputBytes = buffer.byteLength;
var paddingBytes = outputBytes && new DataView(buffer).getUint8(outputBytes - 1);
if (paddingBytes) {
return buffer.slice(0, outputBytes - paddingBytes);
} else {
return buffer;
}
share/public_html/static/hls.js view on Meta::CPAN
}
if (sameKey) {
return;
}
this.key = key;
var keySize = this.keySize = key.length;
if (keySize !== 4 && keySize !== 6 && keySize !== 8) {
throw new Error('Invalid aes key size=' + keySize);
}
var ksRows = this.ksRows = (keySize + 6 + 1) * 4;
var ksRow = void 0;
var invKsRow = void 0;
var keySchedule = this.keySchedule = new Uint32Array(ksRows);
var invKeySchedule = this.invKeySchedule = new Uint32Array(ksRows);
var sbox = this.sBox;
var rcon = this.rcon;
share/public_html/static/hls.js view on Meta::CPAN
// EXTERNAL MODULE: ./src/utils/logger.js
var logger = __webpack_require__(0);
// EXTERNAL MODULE: ./src/events.js
var events = __webpack_require__(1);
// EXTERNAL MODULE: ./src/utils/get-self-scope.js
var get_self_scope = __webpack_require__(3);
// CONCATENATED MODULE: ./src/crypt/decrypter.js
function decrypter__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
share/public_html/static/hls.js view on Meta::CPAN
/* harmony default export */ var decrypter = __webpack_exports__["a"] = (decrypter_Decrypter);
/***/ }),
/* 8 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__utils_logger__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__events__ = __webpack_require__(1);
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* MP4 demuxer
*/
var UINT32_MAX = Math.pow(2, 32) - 1;
var MP4Demuxer = function () {
share/public_html/static/hls.js view on Meta::CPAN
return { sample: aacSample, length: frameLength + headerLength };
}
return undefined;
}
// EXTERNAL MODULE: ./src/demux/id3.js
var id3 = __webpack_require__(5);
// CONCATENATED MODULE: ./src/demux/aacdemuxer.js
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* AAC demuxer
*/
var aacdemuxer_AACDemuxer = function () {
function AACDemuxer(observer, remuxer, config) {
share/public_html/static/hls.js view on Meta::CPAN
if (newOffset === data.length || newOffset + 1 < data.length && this.isHeaderPattern(data, newOffset)) {
return true;
}
}
return false;
}
};
/* harmony default export */ var mpegaudio = (MpegAudio);
// CONCATENATED MODULE: ./src/demux/exp-golomb.js
function exp_golomb__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
*/
var exp_golomb_ExpGolomb = function () {
function ExpGolomb(data) {
exp_golomb__classCallCheck(this, ExpGolomb);
share/public_html/static/hls.js view on Meta::CPAN
// ():void
ExpGolomb.prototype.loadWord = function loadWord() {
var data = this.data,
bytesAvailable = this.bytesAvailable,
position = data.byteLength - bytesAvailable,
workingBytes = new Uint8Array(4),
availableBytes = Math.min(4, bytesAvailable);
if (availableBytes === 0) {
throw new Error('no bytes available');
}
workingBytes.set(data.subarray(position, position + availableBytes));
this.word = new DataView(workingBytes.buffer).getUint32(0);
// track the amount of this.data that has been processed
this.bitsAvailable = availableBytes * 8;
this.bytesAvailable -= availableBytes;
};
// (count:int):void
share/public_html/static/hls.js view on Meta::CPAN
this.readUEG();
// return slice_type
return this.readUEG();
};
return ExpGolomb;
}();
/* harmony default export */ var exp_golomb = (exp_golomb_ExpGolomb);
// CONCATENATED MODULE: ./src/demux/sample-aes.js
function sample_aes__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* SAMPLE-AES decrypter
*/
var sample_aes_SampleAesDecrypter = function () {
function SampleAesDecrypter(observer, config, decryptdata, discardEPB) {
sample_aes__classCallCheck(this, SampleAesDecrypter);
share/public_html/static/hls.js view on Meta::CPAN
}
}
}
};
return SampleAesDecrypter;
}();
/* harmony default export */ var sample_aes = (sample_aes_SampleAesDecrypter);
// CONCATENATED MODULE: ./src/demux/tsdemuxer.js
function tsdemuxer__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* highly optimized TS demuxer:
* parse PAT, PMT
* extract PES packet from audio and video PIDs
* extract AVC/H264 NAL units and AAC/ADTS samples from PES packet
* trigger the remuxer upon parsing completion
* it also tries to workaround as best as it can audio codec switch (HE-AAC to AAC and vice versa), without having to restart the MediaSource.
* it also controls the remuxing process :
* upon discontinuity or level switch detection, it will also notifies the remuxer so that it can reset its state.
share/public_html/static/hls.js view on Meta::CPAN
TSDemuxer.prototype._parseID3PES = function _parseID3PES(pes) {
this._id3Track.samples.push(pes);
};
return TSDemuxer;
}();
/* harmony default export */ var tsdemuxer = (tsdemuxer_TSDemuxer);
// CONCATENATED MODULE: ./src/demux/mp3demuxer.js
function mp3demuxer__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* MP3 demuxer
*/
var mp3demuxer_MP3Demuxer = function () {
function MP3Demuxer(observer, remuxer, config) {
share/public_html/static/hls.js view on Meta::CPAN
this.remuxer.remux(track, { samples: [] }, { samples: id3Samples, inputTimeScale: 90000 }, { samples: [] }, timeOffset, contiguous, accurateTimeOffset);
};
MP3Demuxer.prototype.destroy = function destroy() {};
return MP3Demuxer;
}();
/* harmony default export */ var mp3demuxer = (mp3demuxer_MP3Demuxer);
// CONCATENATED MODULE: ./src/remux/aac-helper.js
function aac_helper__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* AAC helper
*/
var AAC = function () {
function AAC() {
aac_helper__classCallCheck(this, AAC);
}
share/public_html/static/hls.js view on Meta::CPAN
break;
}
return null;
};
return AAC;
}();
/* harmony default export */ var aac_helper = (AAC);
// CONCATENATED MODULE: ./src/remux/mp4-generator.js
function mp4_generator__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* Generate MP4 Box
*/
var UINT32_MAX = Math.pow(2, 32) - 1;
var MP4 = function () {
function MP4() {
mp4_generator__classCallCheck(this, MP4);
share/public_html/static/hls.js view on Meta::CPAN
result.set(MP4.FTYP);
result.set(movie, MP4.FTYP.byteLength);
return result;
};
return MP4;
}();
/* harmony default export */ var mp4_generator = (MP4);
// CONCATENATED MODULE: ./src/remux/mp4-remuxer.js
function mp4_remuxer__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* fMP4 remuxer
*/
share/public_html/static/hls.js view on Meta::CPAN
}
return value;
};
return MP4Remuxer;
}();
/* harmony default export */ var mp4_remuxer = (mp4_remuxer_MP4Remuxer);
// CONCATENATED MODULE: ./src/remux/passthrough-remuxer.js
function passthrough_remuxer__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* passthrough remuxer
*/
var passthrough_remuxer_PassThroughRemuxer = function () {
function PassThroughRemuxer(observer) {
passthrough_remuxer__classCallCheck(this, PassThroughRemuxer);
share/public_html/static/hls.js view on Meta::CPAN
});
// notify end of parsing
observer.trigger(events["a" /* default */].FRAG_PARSED);
};
return PassThroughRemuxer;
}();
/* harmony default export */ var passthrough_remuxer = (passthrough_remuxer_PassThroughRemuxer);
// CONCATENATED MODULE: ./src/demux/demuxer-inline.js
function demuxer_inline__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
*
* inline demuxer: probe fragments and instantiate
* appropriate demuxer depending on content type (TSDemuxer, AACDemuxer, ...)
*
*/
share/public_html/static/hls.js view on Meta::CPAN
// EXTERNAL MODULE: ./src/events.js
var events = __webpack_require__(1);
// EXTERNAL MODULE: ./src/utils/logger.js
var logger = __webpack_require__(0);
// CONCATENATED MODULE: ./src/event-handler.js
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbo...
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/*
*
* All objects in the event handling chain should inherit from this class
*
*/
share/public_html/static/hls.js view on Meta::CPAN
EventHandler.prototype.onHandlerDestroyed = function onHandlerDestroyed() {};
EventHandler.prototype.isEventHandler = function isEventHandler() {
return _typeof(this.handledEvents) === 'object' && this.handledEvents.length && typeof this.onEvent === 'function';
};
EventHandler.prototype.registerListeners = function registerListeners() {
if (this.isEventHandler()) {
this.handledEvents.forEach(function (event) {
if (FORBIDDEN_EVENT_NAMES.has(event)) {
throw new Error('Forbidden event-name: ' + event);
}
this.hls.on(event, this.onEvent);
}, this);
}
};
EventHandler.prototype.unregisterListeners = function unregisterListeners() {
if (this.isEventHandler()) {
this.handledEvents.forEach(function (event) {
share/public_html/static/hls.js view on Meta::CPAN
EventHandler.prototype.onEvent = function onEvent(event, data) {
this.onEventGeneric(event, data);
};
EventHandler.prototype.onEventGeneric = function onEventGeneric(event, data) {
var eventToFunction = function eventToFunction(event, data) {
var 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["b" /* logger */].error('An internal error happened while handling event ' + event + '. Error message: "' + err.message + '". Here is a stacktrace:', err);
this.hls.trigger(events["a" /* default */].ERROR, { type: errors["b" /* ErrorTypes */].OTHER_ERROR, details: errors["a" /* ErrorDetails */].INTERNAL_EXCEPTION, fatal: false, event: event, err: err });
}
share/public_html/static/hls.js view on Meta::CPAN
return EventHandler;
}();
/* harmony default export */ var event_handler = (event_handler_EventHandler);
// EXTERNAL MODULE: ./src/demux/mp4demuxer.js
var mp4demuxer = __webpack_require__(8);
// CONCATENATED MODULE: ./src/loader/level-key.js
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 des...
function level_key__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var level_key_LevelKey = function () {
function LevelKey() {
level_key__classCallCheck(this, LevelKey);
this.method = null;
this.key = null;
this.iv = null;
share/public_html/static/hls.js view on Meta::CPAN
}
}]);
return LevelKey;
}();
/* harmony default export */ var level_key = (level_key_LevelKey);
// CONCATENATED MODULE: ./src/loader/fragment.js
var fragment__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 ("valu...
function fragment__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var fragment_Fragment = function () {
function Fragment() {
var _elementaryStreams;
fragment__classCallCheck(this, Fragment);
share/public_html/static/hls.js view on Meta::CPAN
VIDEO: 'video'
};
}
}]);
return Fragment;
}();
/* harmony default export */ var loader_fragment = (fragment_Fragment);
// CONCATENATED MODULE: ./src/utils/attr-list.js
function attr_list__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/; // eslint-disable-line no-useless-escape
var ATTR_LIST_REGEX = /\s*(.+?)\s*=((?:\".*?\")|.*?)(?:,|$)/g; // eslint-disable-line no-useless-escape
// adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
var AttrList = function () {
function AttrList(attrs) {
attr_list__classCallCheck(this, AttrList);
share/public_html/static/hls.js view on Meta::CPAN
var typeCodes = sampleEntryCodesISO[type];
return !!typeCodes && typeCodes[codec.slice(0, 4)] === true;
}
function isCodecSupportedInMp4(codec, type) {
return window.MediaSource.isTypeSupported((type || 'video') + '/mp4;codecs="' + codec + '"');
}
// CONCATENATED MODULE: ./src/loader/m3u8-parser.js
function m3u8_parser__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
share/public_html/static/hls.js view on Meta::CPAN
return level;
};
return M3U8Parser;
}();
/* harmony default export */ var m3u8_parser = (m3u8_parser_M3U8Parser);
// CONCATENATED MODULE: ./src/loader/playlist-loader.js
var playlist_loader__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...
function playlist_loader__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(superC...
/**
* 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
*
share/public_html/static/hls.js view on Meta::CPAN
get: function get() {
return LevelType;
}
}]);
return PlaylistLoader;
}(event_handler);
/* harmony default export */ var playlist_loader = (playlist_loader_PlaylistLoader);
// CONCATENATED MODULE: ./src/loader/fragment-loader.js
function fragment_loader__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function fragment_loader__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 : s...
function fragment_loader__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 = Obje...
/*
* Fragment Loader
*/
share/public_html/static/hls.js view on Meta::CPAN
var frag = context.frag;
frag.loaded = stats.loaded;
this.hls.trigger(events["a" /* default */].FRAG_LOAD_PROGRESS, { frag: frag, stats: stats, networkDetails: networkDetails });
};
return FragmentLoader;
}(event_handler);
/* harmony default export */ var fragment_loader = (fragment_loader_FragmentLoader);
// CONCATENATED MODULE: ./src/loader/key-loader.js
function key_loader__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function key_loader__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 key_loader__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.cr...
/*
* Decrypt key Loader
*/
share/public_html/static/hls.js view on Meta::CPAN
this.loaders[context.type] = undefined;
this.hls.trigger(events["a" /* default */].ERROR, { type: errors["b" /* ErrorTypes */].NETWORK_ERROR, details: errors["a" /* ErrorDetails */].KEY_LOAD_TIMEOUT, fatal: false, frag: frag });
};
return KeyLoader;
}(event_handler);
/* harmony default export */ var key_loader = (key_loader_KeyLoader);
// CONCATENATED MODULE: ./src/controller/fragment-tracker.js
function fragment_tracker__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function fragment_tracker__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 : ...
function fragment_tracker__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 = Obj...
var FragmentState = {
NOT_LOADED: 'NOT_LOADED',
APPENDING: 'APPENDING',
PARTIAL: 'PARTIAL',
OK: 'OK'
};
share/public_html/static/hls.js view on Meta::CPAN
return currentElement;
}
}
return null;
}
};
/* harmony default export */ var binary_search = (BinarySearch);
// CONCATENATED MODULE: ./src/utils/buffer-helper.js
function buffer_helper__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* @module BufferHelper
*
* Providing methods dealing with buffer length retrieval for example.
*
* In general, a helper around HTML5 MediaElement TimeRanges gathered from `buffered` property.
*
* Also @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/buffered
*/
share/public_html/static/hls.js view on Meta::CPAN
function getMediaSource() {
if (typeof window !== 'undefined') {
return window.MediaSource || window.WebKitMediaSource;
}
}
// EXTERNAL MODULE: ./src/utils/get-self-scope.js
var get_self_scope = __webpack_require__(3);
// CONCATENATED MODULE: ./src/demux/demuxer.js
function demuxer__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
share/public_html/static/hls.js view on Meta::CPAN
var newPDT = details.programDateTime;
// date diff is in ms. frag.start is in seconds
var sliding = (newPDT - lastPDT) / 1000 + lastLevel.details.fragments[0].start;
if (!isNaN(sliding)) {
logger["b" /* logger */].log('adjusting PTS using programDateTime delta, sliding:' + sliding.toFixed(3));
adjustPts(sliding, details);
}
}
}
// CONCATENATED MODULE: ./src/task-loop.js
function task_loop__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function task_loop__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 task_loop__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.cre...
/**
* Sub-class specialization of EventHandler base class.
*
* TaskLoop allows to schedule a task function being called (optionnaly repeatedly) on the main loop,
* scheduled asynchroneously, avoiding recursive calls in the same tick.
*
* The task itself is implemented in `doTick`. It can be requested and called for single execution
share/public_html/static/hls.js view on Meta::CPAN
} else if (candidate.start - candidateLookupTolerance > bufferEnd && candidate.start) {
// if maxFragLookUpTolerance will have negative value then don't return -1 for first element
return -1;
}
return 0;
}
// CONCATENATED MODULE: ./src/controller/stream-controller.js
var stream_controller__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; ...
function stream_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function stream_controller__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 :...
function stream_controller__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 = Ob...
/*
* Stream Controller
*/
share/public_html/static/hls.js view on Meta::CPAN
return StreamController;
}(task_loop);
/* harmony default export */ var stream_controller = (stream_controller_StreamController);
// CONCATENATED MODULE: ./src/controller/level-controller.js
var level_controller__typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.p...
var level_controller__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; i...
function level_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function level_controller__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 : ...
function level_controller__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 = Obj...
/*
* Level Controller
*/
share/public_html/static/hls.js view on Meta::CPAN
}
function clearCurrentCues(track) {
if (track && track.cues) {
while (track.cues.length > 0) {
track.removeCue(track.cues[0]);
}
}
}
// CONCATENATED MODULE: ./src/controller/id3-track-controller.js
function id3_track_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function id3_track_controller__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") ? cal...
function id3_track_controller__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 =...
/*
* id3 metadata track controller
*/
share/public_html/static/hls.js view on Meta::CPAN
var mediaSource = getMediaSource();
var sourceBuffer = window.SourceBuffer || window.WebKitSourceBuffer;
var isTypeSupported = mediaSource && typeof mediaSource.isTypeSupported === 'function' && mediaSource.isTypeSupported('video/mp4; codecs="avc1.42E01E,mp4a.40.2"');
// if SourceBuffer is exposed ensure its API is valid
// safari and old version of Chrome doe not expose SourceBuffer globally so checking SourceBuffer.prototype is impossible
var sourceBufferValidAPI = !sourceBuffer || sourceBuffer.prototype && typeof sourceBuffer.prototype.appendBuffer === 'function' && typeof sourceBuffer.prototype.remove === 'function';
return !!isTypeSupported && !!sourceBufferValidAPI;
}
// CONCATENATED MODULE: ./src/utils/ewma.js
function ewma__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/*
* compute an Exponential Weighted moving average
* - https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
* - heavily inspired from shaka-player
*/
var EWMA = function () {
// About half of the estimated value will be from the last |halfLife| samples by weight.
function EWMA(halfLife) {
share/public_html/static/hls.js view on Meta::CPAN
} else {
return this.estimate_;
}
};
return EWMA;
}();
/* harmony default export */ var ewma = (EWMA);
// CONCATENATED MODULE: ./src/utils/ewma-bandwidth-estimator.js
function ewma_bandwidth_estimator__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/*
* EWMA Bandwidth Estimator
* - heavily inspired from shaka-player
* Tracks bandwidth samples and estimates available bandwidth.
* Based on the minimum of two exponentially-weighted moving averages with
* different half-lives.
*/
share/public_html/static/hls.js view on Meta::CPAN
EwmaBandWidthEstimator.prototype.destroy = function destroy() {};
return EwmaBandWidthEstimator;
}();
/* harmony default export */ var ewma_bandwidth_estimator = (ewma_bandwidth_estimator_EwmaBandWidthEstimator);
// CONCATENATED MODULE: ./src/controller/abr-controller.js
var abr_controller__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 ...
function abr_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function abr_controller__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 : se...
function abr_controller__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 = Objec...
/*
* simple ABR Controller
* - compute next level based on last fragment bw heuristics
* - implement an abandon rules triggered if we have less than 2 frag buffered and if computed bw shows that we risk buffer stalling
*/
share/public_html/static/hls.js view on Meta::CPAN
return Math.max(bestLevel, 0);
}
}
}]);
return AbrController;
}(event_handler);
/* harmony default export */ var abr_controller = (abr_controller_AbrController);
// CONCATENATED MODULE: ./src/controller/buffer-controller.js
function buffer_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function buffer_controller__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 :...
function buffer_controller__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 = Ob...
/*
* Buffer Controller
*/
share/public_html/static/hls.js view on Meta::CPAN
this._needsFlush = false;
// let's recompute this.appended, which is used to avoid flush looping
var appended = 0;
var sourceBuffer = this.sourceBuffer;
try {
for (var type in sourceBuffer) {
appended += sourceBuffer[type].buffered.length;
}
} catch (error) {
// error could be thrown while accessing buffered, in case sourcebuffer has already been removed from MediaSource
// this is harmess at this stage, catch this to avoid reporting an internal exception
logger["b" /* logger */].error('error while accessing sourceBuffer.buffered');
}
this.appended = appended;
this.hls.trigger(events["a" /* default */].BUFFER_FLUSHED);
}
};
BufferController.prototype.doAppending = function doAppending() {
var hls = this.hls,
share/public_html/static/hls.js view on Meta::CPAN
return true;
};
return BufferController;
}(event_handler);
/* harmony default export */ var buffer_controller = (buffer_controller_BufferController);
// CONCATENATED MODULE: ./src/controller/cap-level-controller.js
var cap_level_controller__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 = tru...
function cap_level_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function cap_level_controller__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") ? cal...
function cap_level_controller__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 =...
/*
* cap stream level to media size dimension controller
*/
var cap_level_controller_CapLevelController = function (_EventHandler) {
cap_level_controller__inherits(CapLevelController, _EventHandler);
share/public_html/static/hls.js view on Meta::CPAN
} catch (e) {}
return pixelRatio;
}
}]);
return CapLevelController;
}(event_handler);
/* harmony default export */ var cap_level_controller = (cap_level_controller_CapLevelController);
// CONCATENATED MODULE: ./src/controller/fps-controller.js
function fps_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function fps_controller__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 : se...
function fps_controller__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 = Objec...
/*
* FPS Controller
*/
var fps_controller__window = window,
share/public_html/static/hls.js view on Meta::CPAN
this.checkFPS(video, video.webkitDecodedFrameCount, video.webkitDroppedFrameCount);
}
}
};
return FPSController;
}(event_handler);
/* harmony default export */ var fps_controller = (fps_controller_FPSController);
// CONCATENATED MODULE: ./src/utils/xhr-loader.js
function xhr_loader__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* XHR based logger
*/
var xhr_loader__window = window,
xhr_loader_performance = xhr_loader__window.performance,
XMLHttpRequest = xhr_loader__window.XMLHttpRequest;
share/public_html/static/hls.js view on Meta::CPAN
// 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);
share/public_html/static/hls.js view on Meta::CPAN
}
};
return XhrLoader;
}();
/* harmony default export */ var xhr_loader = (xhr_loader_XhrLoader);
// CONCATENATED MODULE: ./src/controller/audio-track-controller.js
var audio_track_controller__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 = t...
function audio_track_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function audio_track_controller__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") ? c...
function audio_track_controller__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...
/**
* @class AudioTrackController
* @implements {EventHandler}
*
share/public_html/static/hls.js view on Meta::CPAN
}
}]);
return AudioTrackController;
}(task_loop);
/* harmony default export */ var audio_track_controller = (audio_track_controller_AudioTrackController);
// CONCATENATED MODULE: ./src/controller/audio-stream-controller.js
var audio_stream_controller__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 = ...
function audio_stream_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function audio_stream_controller__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") ? ...
function audio_stream_controller__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.prototyp...
/*
* Audio Stream Controller
*/
share/public_html/static/hls.js view on Meta::CPAN
_pauseOnExit = !!value;
}
}));
Object.defineProperty(cue, 'startTime', extend({}, baseObj, {
get: function get() {
return _startTime;
},
set: function set(value) {
if (typeof value !== 'number') {
throw new TypeError('Start time must be set to a number.');
}
_startTime = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'endTime', extend({}, baseObj, {
get: function get() {
return _endTime;
},
set: function set(value) {
if (typeof value !== 'number') {
throw new TypeError('End time must be set to a number.');
}
_endTime = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'text', extend({}, baseObj, {
get: function get() {
return _text;
share/public_html/static/hls.js view on Meta::CPAN
}));
Object.defineProperty(cue, 'vertical', extend({}, baseObj, {
get: function get() {
return _vertical;
},
set: function set(value) {
var setting = findDirectionSetting(value);
// Have to check for false because the setting an be an empty string.
if (setting === false) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_vertical = setting;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'snapToLines', extend({}, baseObj, {
get: function get() {
return _snapToLines;
share/public_html/static/hls.js view on Meta::CPAN
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'line', extend({}, baseObj, {
get: function get() {
return _line;
},
set: function set(value) {
if (typeof value !== 'number' && value !== autoKeyword) {
throw new SyntaxError('An invalid number or illegal string was specified.');
}
_line = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'lineAlign', extend({}, baseObj, {
get: function get() {
return _lineAlign;
},
set: function set(value) {
var setting = findAlignSetting(value);
if (!setting) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_lineAlign = setting;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'position', extend({}, baseObj, {
get: function get() {
return _position;
},
set: function set(value) {
if (value < 0 || value > 100) {
throw new Error('Position must be between 0 and 100.');
}
_position = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'positionAlign', extend({}, baseObj, {
get: function get() {
return _positionAlign;
},
set: function set(value) {
var setting = findAlignSetting(value);
if (!setting) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_positionAlign = setting;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'size', extend({}, baseObj, {
get: function get() {
return _size;
},
set: function set(value) {
if (value < 0 || value > 100) {
throw new Error('Size must be between 0 and 100.');
}
_size = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'align', extend({}, baseObj, {
get: function get() {
return _align;
},
set: function set(value) {
var setting = findAlignSetting(value);
if (!setting) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_align = setting;
this.hasBeenReset = true;
}
}));
/**
* Other <track> spec defined properties
*/
share/public_html/static/hls.js view on Meta::CPAN
var StringDecoder = function StringDecoder() {
return {
decode: function decode(data) {
if (!data) {
return '';
}
if (typeof data !== 'string') {
throw new Error('Error - expected string data.');
}
return decodeURIComponent(encodeURIComponent(data));
}
};
};
function VTTParser() {
this.window = window;
this.state = 'INITIAL';
share/public_html/static/hls.js view on Meta::CPAN
callback(k, v);
}
}
var defaults = new vttcue(0, 0, 0);
// 'middle' was changed to 'center' in the spec: https://github.com/w3c/webvtt/pull/244
// Safari doesn't yet support this change, but FF and Chrome do.
var center = defaults.align === 'middle' ? 'middle' : 'center';
function parseCue(input, cue, regionList) {
// Remember the original input if we need to throw an error.
var oInput = input;
// 4.1 WebVTT timestamp
function consumeTimeStamp() {
var ts = parseTimeStamp(input);
if (ts === null) {
throw new Error('Malformed timestamp: ' + oInput);
}
// Remove time stamp from input.
input = input.replace(/^[^\sa-zA-Z-]+/, '');
return ts;
}
// 4.4.2 WebVTT cue settings
function consumeCueSettings(input, cue) {
var settings = new Settings();
share/public_html/static/hls.js view on Meta::CPAN
function skipWhitespace() {
input = input.replace(/^\s+/, '');
}
// 4.1 WebVTT cue timings.
skipWhitespace();
cue.startTime = consumeTimeStamp(); // (1) collect cue start time
skipWhitespace();
if (input.substr(0, 3) !== '-->') {
// (3) next characters must match '-->'
throw new Error('Malformed time stamp (time stamps must be separated by \'-->\'): ' + oInput);
}
input = input.substr(3);
skipWhitespace();
cue.endTime = consumeTimeStamp(); // (5) collect cue end time
// 4.1 WebVTT cue settings list.
skipWhitespace();
consumeCueSettings(input, cue);
}
share/public_html/static/hls.js view on Meta::CPAN
// We can't start parsing until we have the first line.
if (!/\r\n|\n/.test(self.buffer)) {
return this;
}
line = collectNextLine();
// strip of UTF-8 BOM if any
// https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
var m = line.match(/^()?WEBVTT([ \t].*)?$/);
if (!m || !m[0]) {
throw new Error('Malformed WebVTT signature.');
}
self.state = 'HEADER';
}
var alreadyCollectedLine = false;
while (self.buffer) {
// We can't parse a line until we have the full line.
if (!/\r\n|\n/.test(self.buffer)) {
return this;
share/public_html/static/hls.js view on Meta::CPAN
self.buffer += self.decoder.decode();
// Synthesize the end of the current cue or region.
if (self.cue || self.state === 'HEADER') {
self.buffer += '\n\n';
self.parse();
}
// If we've flushed, parsed, and we're still on the INITIAL state then
// that means we don't have enough of the stream to parse the first
// line.
if (self.state === 'INITIAL') {
throw new Error('Malformed WebVTT signature.');
}
} catch (e) {
throw e;
}
if (self.onflush) {
self.onflush();
}
return this;
}
};
share/public_html/static/hls.js view on Meta::CPAN
// VTTCue.line get's flakey when using controls, so let's now include line 13&14
// also, drop line 1 since it's to close to the top
if (navigator.userAgent.match(/Firefox\//)) {
cue.line = r + 1;
} else {
cue.line = r > 7 ? r - 2 : r + 1;
}
cue.align = 'left';
// Clamp the position between 0 and 100 - if out of these bounds, Firefox throws an exception and captions break
cue.position = Math.max(0, Math.min(100, 100 * (indent / 32) + (navigator.userAgent.match(/Firefox\//) ? 50 : 0)));
track.addCue(cue);
}
}
}
// CONCATENATED MODULE: ./src/utils/cea-608-parser.js
function cea_608_parser__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
*
* This code was ported from the dash.js project at:
* https://github.com/Dash-Industry-Forum/dash.js/blob/development/externals/cea608-parser.js
* https://github.com/Dash-Industry-Forum/dash.js/commit/8269b26a761e0853bb21d78780ed945144ecdd4d#diff-71bc295a2d6b6b7093a1d3290d53a4b2
*
* The original copyright appears below:
*
* The copyright in this software is being made available under the BSD License,
share/public_html/static/hls.js view on Meta::CPAN
this.channels[i].cueSplitAtTime(t);
}
}
};
return Cea608Parser;
}();
/* harmony default export */ var cea_608_parser = (Cea608Parser);
// CONCATENATED MODULE: ./src/utils/output-filter.js
function output_filter__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var OutputFilter = function () {
function OutputFilter(timelineController, trackName) {
output_filter__classCallCheck(this, OutputFilter);
this.timelineController = timelineController;
this.trackName = trackName;
this.startTime = null;
this.endTime = null;
this.screen = null;
share/public_html/static/hls.js view on Meta::CPAN
// Parse line by default.
parser.parse(line + '\n');
});
parser.flush();
}
};
/* harmony default export */ var webvtt_parser = (WebVTTParser);
// CONCATENATED MODULE: ./src/controller/timeline-controller.js
function timeline_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function timeline_controller__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...
function timeline_controller__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 = ...
/*
* Timeline Controller
*/
share/public_html/static/hls.js view on Meta::CPAN
this.prevCC = frag.cc;
}
var textTracks = this.textTracks,
hls = this.hls;
// Parse the WebVTT file contents.
webvtt_parser.parse(payload, this.initPTS, vttCCs, frag.cc, function (cues) {
var currentTrack = textTracks[frag.trackId];
// WebVTTParser.parse is an async method and if the currently selected text track mode is set to "disabled"
// before parsing is done then don't try to access currentTrack.cues.getCueById as cues will be null
// and trying to access getCueById method of cues will throw an exception
if (currentTrack.mode === 'disabled') {
hls.trigger(events["a" /* default */].SUBTITLE_FRAG_PROCESSED, { success: false, frag: frag });
return;
}
// Add cues and trigger event with success true.
cues.forEach(function (cue) {
// Sometimes there are cue overlaps on segmented vtts so the same
// cue can appear more than once in different vtt files.
// This avoid showing duplicated cues with same timecode and text.
if (!currentTrack.cues.getCueById(cue.id)) {
share/public_html/static/hls.js view on Meta::CPAN
return actualCCBytes;
};
return TimelineController;
}(event_handler);
/* harmony default export */ var timeline_controller = (timeline_controller_TimelineController);
// CONCATENATED MODULE: ./src/controller/subtitle-track-controller.js
var subtitle_track_controller__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 ...
function subtitle_track_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function subtitle_track_controller__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") ...
function subtitle_track_controller__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.protot...
/*
* subtitle track controller
*/
function filterSubtitleTracks(textTrackList) {
share/public_html/static/hls.js view on Meta::CPAN
}]);
return SubtitleTrackController;
}(event_handler);
/* harmony default export */ var subtitle_track_controller = (subtitle_track_controller_SubtitleTrackController);
// EXTERNAL MODULE: ./src/crypt/decrypter.js + 3 modules
var decrypter = __webpack_require__(7);
// CONCATENATED MODULE: ./src/controller/subtitle-stream-controller.js
function subtitle_stream_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function subtitle_stream_controller__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")...
function subtitle_stream_controller__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.proto...
/*
* Subtitle Stream Controller
*/
share/public_html/static/hls.js view on Meta::CPAN
}
};
return SubtitleStreamController;
}(task_loop);
/* harmony default export */ var subtitle_stream_controller = (subtitle_stream_controller_SubtitleStreamController);
// CONCATENATED MODULE: ./src/controller/eme-controller.js
var eme_controller__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 ...
function eme_controller__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function eme_controller__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 : se...
function eme_controller__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 = Objec...
/**
* @author Stephan Hesse <disparat@gmail.com> | <tchakabam@gmail.com>
*
* DRM support for Hls.js
*/
share/public_html/static/hls.js view on Meta::CPAN
});
});
return [baseConfig];
};
/**
* The idea here is to handle key-system (and their respective platforms) specific configuration differences
* in order to work with the local requestMediaKeySystemAccess method.
*
* We can also rule-out platform-related key-system support at this point by throwing an error or returning null.
*
* @param {string} keySystem Identifier for the key-system, see `KeySystems` enum
* @param {Array<string>} audioCodecs List of required audio codecs to support
* @param {Array<string>} videoCodecs List of required video codecs to support
* @returns {Array<MediaSystemConfiguration> | null} A non-empty Array of MediaKeySystemConfiguration objects or `null`
*/
var getSupportedMediaKeySystemConfigurations = function getSupportedMediaKeySystemConfigurations(keySystem, audioCodecs, videoCodecs) {
switch (keySystem) {
case KeySystems.WIDEVINE:
return createWidevineMediaKeySystemConfigurations(audioCodecs, videoCodecs);
default:
throw Error('Unknown key-system: ' + keySystem);
}
};
/**
* Controller to deal with encrypted media extensions (EME)
* @see https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API
*
* @class
* @constructor
*/
share/public_html/static/hls.js view on Meta::CPAN
// let's try to open before running setup
xhr.open('POST', url, true);
licenseXhrSetup(xhr, url);
}
}
// if licenseXhrSetup did not yet call open, let's do it now
if (!xhr.readyState) {
xhr.open('POST', url, true);
}
} catch (e) {
// IE11 throws an exception on xhr.open if attempting to access an HTTP resource over HTTPS
logger["b" /* logger */].error('Error setting up key-system license XHR', e);
this.hls.trigger(events["a" /* default */].ERROR, {
type: errors["b" /* ErrorTypes */].KEY_SYSTEM_ERROR,
details: errors["a" /* ErrorDetails */].KEY_SYSTEM_LICENSE_REQUEST_FAILED,
fatal: true
});
return;
}
xhr.responseType = 'arraybuffer';
share/public_html/static/hls.js view on Meta::CPAN
logger["b" /* logger */].error('PlayReady is not supported (yet)');
// from https://github.com/MicrosoftEdge/Demos/blob/master/eme/scripts/demo.js
/*
if (this.licenseType !== this.LICENSE_TYPE_WIDEVINE) {
// For PlayReady CDMs, we need to dig the Challenge out of the XML.
var keyMessageXml = new DOMParser().parseFromString(String.fromCharCode.apply(null, new Uint16Array(keyMessage)), 'application/xml');
if (keyMessageXml.getElementsByTagName('Challenge')[0]) {
challenge = atob(keyMessageXml.getElementsByTagName('Challenge')[0].childNodes[0].nodeValue);
} else {
throw 'Cannot find <Challenge> in key message';
}
var headerNames = keyMessageXml.getElementsByTagName('name');
var headerValues = keyMessageXml.getElementsByTagName('value');
if (headerNames.length !== headerValues.length) {
throw 'Mismatched header <name>/<value> pair in key message';
}
for (var i = 0; i < headerNames.length; i++) {
xhr.setRequestHeader(headerNames[i].childNodes[0].nodeValue, headerValues[i].childNodes[0].nodeValue);
}
}
*/
} else if (keysListItem.mediaKeySystemDomain === KeySystems.WIDEVINE) {
// For Widevine CDMs, the challenge is the keyMessage.
challenge = keyMessage;
} else {
share/public_html/static/hls.js view on Meta::CPAN
return level.videoCodec;
});
this._attemptKeySystemAccess(KeySystems.WIDEVINE, audioCodecs, videoCodecs);
};
eme_controller__createClass(EMEController, [{
key: 'requestMediaKeySystemAccess',
get: function get() {
if (!this._requestMediaKeySystemAccess) {
throw new Error('No requestMediaKeySystemAccess function configured');
}
return this._requestMediaKeySystemAccess;
}
}]);
return EMEController;
}(event_handler);
/* harmony default export */ var eme_controller = (eme_controller_EMEController);
share/public_html/static/hls.js view on Meta::CPAN
hlsDefaultConfig.audioStreamController = audio_stream_controller;
hlsDefaultConfig.audioTrackController = audio_track_controller;
}
if (true) {
hlsDefaultConfig.emeController = eme_controller;
}
// CONCATENATED MODULE: ./src/hls.js
var hls__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...
function hls__classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
share/public_html/static/hls.js view on Meta::CPAN
function Hls() {
var _this = this;
var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
hls__classCallCheck(this, Hls);
var defaultConfig = Hls.DefaultConfig;
if ((config.liveSyncDurationCount || config.liveMaxLatencyDurationCount) && (config.liveSyncDuration || config.liveMaxLatencyDuration)) {
throw new Error('Illegal hls.js config: don\'t mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration');
}
for (var prop in defaultConfig) {
if (prop in config) continue;
config[prop] = defaultConfig[prop];
}
if (config.liveMaxLatencyDurationCount !== undefined && config.liveMaxLatencyDurationCount <= config.liveSyncDurationCount) {
throw new Error('Illegal hls.js config: "liveMaxLatencyDurationCount" must be gt "liveSyncDurationCount"');
}
if (config.liveMaxLatencyDuration !== undefined && (config.liveMaxLatencyDuration <= config.liveSyncDuration || config.liveSyncDuration === undefined)) {
throw new Error('Illegal hls.js config: "liveMaxLatencyDuration" must be gt "liveSyncDuration"');
}
Object(logger["a" /* enableLogs */])(config.debug);
this.config = config;
this._autoLevelCapping = -1;
// observer setup
var observer = this.observer = new events_default.a();
observer.trigger = function trigger(event) {
for (var _len = arguments.length, data = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
data[_key - 1] = arguments[_key];
share/public_html/static/hls.js view on Meta::CPAN
/******/ return getter;
/******/ };
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "/";
/******/ // on error function for async loading
/******/ __webpack_require__.oe = function(err) { console.error(err); throw err; };
var f = __webpack_require__(__webpack_require__.s = ENTRY_MODULE)
return f.default || f // try to call default if defined to also support babel esmodule exports
}
var moduleNameReqExp = '[\\.|\\-|\\+|\\w|\/|@]+'
var dependencyRegExp = '\\((\/\\*.*?\\*\/)?\s?.*?(' + moduleNameReqExp + ').*?\\)' // additional chars when output.pathinfo is true
// http://stackoverflow.com/a/2593661/130442
function quoteRegExp (str) {
share/public_html/static/hls.js view on Meta::CPAN
try {
var object = {};
var $defineProperty = Object.defineProperty;
var result = $defineProperty(object, object, object) && $defineProperty;
} catch(error) {}
return result;
}());
var toString = {}.toString;
var endsWith = function(search) {
if (this == null) {
throw TypeError();
}
var string = String(this);
if (search && toString.call(search) == '[object RegExp]') {
throw TypeError();
}
var stringLength = string.length;
var searchString = String(search);
var searchLength = searchString.length;
var pos = stringLength;
if (arguments.length > 1) {
var position = arguments[1];
if (position !== undefined) {
// `ToInteger`
pos = position ? Number(position) : 0;
share/public_html/static/jsmpeg.min.js view on Meta::CPAN
var JSMpeg={Player:null,VideoElement:null,BitBuffer:null,Source:{},Demuxer:{},Decoder:{},Renderer:{},AudioOutput:{},Now:function(){return window.performance?window.performance.now()/1e3:Date.now()/1e3},CreateVideoElements:function(){var elements=docu...
src++;y|=sY[src]<<16;src++;y|=sY[src]<<24;src++;dY[dest++]=y}dest+=scan>>2;src+=scan}}}width=this.halfWidth;scan=width-8;H=motionH/2>>1;V=motionV/2>>1;oddH=(motionH/2&1)===1;oddV=(motionV/2&1)===1;src=((this.mbRow<<3)+V)*width+(this.mbCol<<3)+H;dest=...
gl.uniform1i(gl.getUniformLocation(this.program,name),index);return texture};WebGLRenderer.prototype.createProgram=function(vsh,fsh){var gl=this.gl;var program=gl.createProgram();gl.attachShader(program,this.compileShader(gl.VERTEX_SHADER,vsh));gl.at...
share/public_html/static/music_inc/drflac.js view on Meta::CPAN
var Module = (() => {
var _scriptName = import.meta.url;
return (
async function(moduleArg = {}) {
var moduleRtn;
var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});["_network_drflac_open_mem","_network_drflac_read_pcm_frames_f32_mem","_network_dr...
return moduleRtn;
}
);
})();
export default Module;
share/public_html/static/music_inc/index.html view on Meta::CPAN
</script>
<script src="music_drflac_module.cache.js" type="module"></script>
<script src="music_inc_module.js" type="module" async> </script>
<script>
// load the DB
let urlParams = new URLSearchParams(window.location.search);
urlParams.append('fmt', 'musicdbhtml');
let myRequest = new Request('../../music?'+urlParams.toString());
fetch(myRequest).then(function(response) {
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return response.text();
}).then((html) => {
document.getElementById("musicdb").innerHTML = html;
});
</script>
</body>
</html>
share/public_html/static/music_inc/music_drflac_module.cache.js view on Meta::CPAN
});
};
xhr.send();
//console.log('sending xhr');
});
}
const GetFileSize = function(xhr) {
let re = new RegExp('/([0-9]+)');
let res = re.exec(xhr.getResponseHeader('Content-Range'));
if(!res) throw("Failed to get filesize");
return Number(res[1]);
};
const NDRFLAC_SUCCESS = 0;
const NDRFLAC_GENERIC_ERROR = 1;
const NDRFLAC_MEM_NEED_MORE = 2;
const NetworkDrFlac = async function(theURL, gsignal) {
// make sure drflac is ready. Inlined to avoid await when it's already ready
while(typeof DrFlac === 'undefined') {
share/public_html/static/music_inc/music_drflac_module.cache.js view on Meta::CPAN
if(!DrFlac.ready) {
console.log('music_drflac, waiting for drflac to be ready');
await waitForEvent(DrFlac, 'ready');
}
let that = {};
that.CHUNKSIZE = 262144;
that.downloadChunk = async function(start, mysignal) {
if(start % that.CHUNKSIZE)
{
throw("start is not a multiple of CHUNKSIZE: " + start);
}
const def_end = start+that.CHUNKSIZE-1;
const end = that.filesize ? Math.min(def_end, that.filesize-1) : def_end;
let xhr = await makeRequest('GET', theURL, start, end, mysignal);
if(!that.filesize) that.filesize = GetFileSize(xhr);
if(!that.memptr) that.memptr = DrFlac.network_drflac_mem_create(that.filesize, that.CHUNKSIZE);
let dataHeap = new Uint8Array(DrFlac.Module.HEAPU8.buffer, DrFlac.network_drflac_mem_bufptr(that.memptr)+start, xhr.response.byteLength);
dataHeap.set(new Uint8Array(xhr.response));
DrFlac.network_drflac_mem_add_block(that.memptr, start);
return xhr.response.byteLength;
share/public_html/static/music_inc/music_drflac_module.cache.js view on Meta::CPAN
let destdata = DrFlac.Module._malloc(count*pcm_float_frame_size);
let err_ptr = DrFlac.network_drflac_create_error();
const samples = DrFlac.network_drflac_read_pcm_frames_f32_mem(that.ptr, start, count, destdata, err_ptr);
const err = that.freeError(err_ptr);
if(err.code !== NDRFLAC_SUCCESS)
{
DrFlac.Module._free(destdata);
if(err.code !== NDRFLAC_MEM_NEED_MORE)
{
throw("network_drflac_read_pcm_frames_f32_mem failed");
}
// download more data
await that.downloadChunk(err.extradata, mysignal);
// reopen drflac
DrFlac.network_drflac_close(that.ptr);
let err_ptr = DrFlac.network_drflac_create_error();
that.ptr = DrFlac.network_drflac_open_mem(that.filesize, that.memptr, err_ptr);
that.freeError(err_ptr);
if(!that.ptr) {
throw("Failed network_drflac_open");
}
continue;
}
let audiobuffer = audiocontext.createBuffer(that.channels, samples, that.sampleRate);
const chansize = samples * f32_size;
for( let i = 0; i < that.channels; i++) {
let buf = new Float32Array(DrFlac.Module.HEAPU8.buffer, destdata+(chansize*i), samples);
audiobuffer.getChannelData(i).set(buf);
}
share/public_html/static/music_inc/music_drflac_module.cache.js view on Meta::CPAN
//return that.read_pcm_frames_to_AudioBuffer_wav(start, count, mysignal, audiocontext);
return that.read_pcm_frames_to_AudioBuffer_f32_mem(start, count, mysignal, audiocontext);
};
// open drflac for the first time
for(let start = 0; ;) {
try {
await that.downloadChunk(start, gsignal);
} catch(error) {
that.close();
throw(error);
}
let err_ptr = DrFlac.network_drflac_create_error();
that.ptr = DrFlac.network_drflac_open_mem(that.filesize, that.memptr, err_ptr);
const err = that.freeError(err_ptr);
start = err.extradata;
if(that.ptr) {
break;
}
else if(err.code !== NDRFLAC_MEM_NEED_MORE){
that.close();
throw("Failed network_drflac_open");
}
}
that.totalPCMFrameCount = DrFlac.network_drflac_totalPCMFrameCount(that.ptr);
that.sampleRate = DrFlac.network_drflac_sampleRate(that.ptr);
that.bitsPerSample = DrFlac.network_drflac_bitsPerSample(that.ptr);
that.channels = DrFlac.network_drflac_channels(that.ptr);
that.url = theURL;
return that;
share/public_html/static/music_inc/music_inc_module.js view on Meta::CPAN
for(let failedcount = 0;!buffer;) {
try {
buffer = await NWDRFLAC.read_pcm_frames_to_AudioBuffer(dectime, todec, mysignal, MainAudioContext);
if(mysignal.aborted) {
console.log('aborted decodeaudiodata success');
unlock();
return;
}
if(buffer.duration !== (todec / NWDRFLAC.sampleRate)) {
buffer = null;
throw('network error? buffer wrong length');
}
}
catch(error) {
console.error(error);
if(mysignal.aborted) {
console.log('aborted read_pcm_frames decodeaudiodata catch');
unlock();
return;
}
failedcount++;
share/public_html/static/music_inc/src/miniaudio.h view on Meta::CPAN
#endif
#if defined(MA_POSIX)
typedef struct
{
int value;
pthread_mutex_t lock;
pthread_cond_t cond;
} ma_semaphore;
#endif /* MA_POSIX */
#else
/* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
#ifndef MA_NO_DEVICE_IO
#error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
#endif
#endif /* MA_NO_THREADING */
/*
Retrieves the version of miniaudio as separated integers. Each component can be NULL if it's not required.
*/
MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
share/public_html/static/music_inc/src/miniaudio.h view on Meta::CPAN
}
#ifdef MA_WIN32
return ma_semaphore_release__win32(pSemaphore);
#endif
#ifdef MA_POSIX
return ma_semaphore_release__posix(pSemaphore);
#endif
}
#else
/* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
#ifndef MA_NO_DEVICE_IO
#error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
#endif
#endif /* MA_NO_THREADING */
/************************************************************************************************************************************************************
*************************************************************************************************************************************************************
DEVICE I/O
share/public_html/static/music_inc/src/miniaudio.h view on Meta::CPAN
pContext->jack.jack_activate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_activate");
pContext->jack.jack_deactivate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_deactivate");
pContext->jack.jack_connect = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_connect");
pContext->jack.jack_port_register = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_register");
pContext->jack.jack_port_name = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_name");
pContext->jack.jack_port_get_buffer = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_get_buffer");
pContext->jack.jack_free = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_free");
#else
/*
This strange assignment system is here just to ensure type safety of miniaudio's function pointer
types. If anything differs slightly the compiler should throw a warning.
*/
ma_jack_client_open_proc _jack_client_open = jack_client_open;
ma_jack_client_close_proc _jack_client_close = jack_client_close;
ma_jack_client_name_size_proc _jack_client_name_size = jack_client_name_size;
ma_jack_set_process_callback_proc _jack_set_process_callback = jack_set_process_callback;
ma_jack_set_buffer_size_callback_proc _jack_set_buffer_size_callback = jack_set_buffer_size_callback;
ma_jack_on_shutdown_proc _jack_on_shutdown = jack_on_shutdown;
ma_jack_get_sample_rate_proc _jack_get_sample_rate = jack_get_sample_rate;
ma_jack_get_buffer_size_proc _jack_get_buffer_size = jack_get_buffer_size;
ma_jack_get_ports_proc _jack_get_ports = jack_get_ports;
share/public_html/static/music_worklet_inprogress/decoder/bin/_mhfscl.js view on Meta::CPAN
var Module = (() => {
var _scriptName = import.meta.url;
return (
async function(moduleArg = {}) {
var moduleRtn;
var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof im...
return moduleRtn;
}
);
})();
export default Module;
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
#endif
#if defined(MA_POSIX)
typedef struct
{
int value;
ma_pthread_mutex_t lock;
ma_pthread_cond_t cond;
} ma_semaphore;
#endif /* MA_POSIX */
#else
/* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
#ifndef MA_NO_DEVICE_IO
#error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
#endif
#endif /* MA_NO_THREADING */
/*
Retrieves the version of miniaudio as separated integers. Each component can be NULL if it's not required.
*/
MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
}
#ifdef MA_WIN32
return ma_semaphore_release__win32(pSemaphore);
#endif
#ifdef MA_POSIX
return ma_semaphore_release__posix(pSemaphore);
#endif
}
#else
/* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
#ifndef MA_NO_DEVICE_IO
#error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
#endif
#endif /* MA_NO_THREADING */
#define MA_FENCE_COUNTER_MAX 0x7FFFFFFF
MA_API ma_result ma_fence_init(ma_fence* pFence)
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
pContext->jack.jack_activate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_activate");
pContext->jack.jack_deactivate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_deactivate");
pContext->jack.jack_connect = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_connect");
pContext->jack.jack_port_register = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_register");
pContext->jack.jack_port_name = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_name");
pContext->jack.jack_port_get_buffer = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_get_buffer");
pContext->jack.jack_free = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_free");
#else
/*
This strange assignment system is here just to ensure type safety of miniaudio's function pointer
types. If anything differs slightly the compiler should throw a warning.
*/
ma_jack_client_open_proc _jack_client_open = jack_client_open;
ma_jack_client_close_proc _jack_client_close = jack_client_close;
ma_jack_client_name_size_proc _jack_client_name_size = jack_client_name_size;
ma_jack_set_process_callback_proc _jack_set_process_callback = jack_set_process_callback;
ma_jack_set_buffer_size_callback_proc _jack_set_buffer_size_callback = jack_set_buffer_size_callback;
ma_jack_on_shutdown_proc _jack_on_shutdown = jack_on_shutdown;
ma_jack_get_sample_rate_proc _jack_get_sample_rate = jack_get_sample_rate;
ma_jack_get_buffer_size_proc _jack_get_buffer_size = jack_get_buffer_size;
ma_jack_get_ports_proc _jack_get_ports = jack_get_ports;
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
that.curOffset = startOffset;
that.fetchResponse = await fetch(url, {
signal: that.acSignal,
headers: {
'Range': 'bytes='+startOffset+'-'
}
});
const contentrange = that.fetchResponse.headers.get('Content-Range');
const re = new RegExp('/([0-9]+)');
const res = re.exec(contentrange);
if(!res) throw("Failed to get filesize");
that.size = Number(res[1]);
that.reader = that.fetchResponse.body.getReader();
that.data = new Uint8Array(0);
that.headers = {};
const ct = that.fetchResponse.headers.get('Content-Type');
if(ct) {
that.headers['Content-Type'] = ct;
}
const tpcmcnt = that.fetchResponse.headers.get('X-MHFS-totalPCMFrameCount');
if(tpcmcnt) {
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
that._AbortIfExists = function() {
if(that.aController) {
console.log('abort req');
that.aController.abort();
that.aController = null;
}
};
that.GetChunk = async function(url, startOffset, signal) {
if(that.inuse) {
throw("GetChunk is inuse");
}
that.inuse = 1;
try {
if(that.ExternalSignal) {
that.ExternalSignal.removeEventListener('abort', that._AbortIfExists);
}
that.ExternalSignal = signal;
that.ExternalSignal.addEventListener('abort', that._AbortIfExists);
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
const tmp = new Uint8Array(that.data.byteLength + chunk.byteLength);
tmp.set(that.data, 0);
tmp.set(chunk, that.data.byteLength);
that.data = tmp;
}
that.done = readerDone;
}
}
catch(err) {
if(err.name === "AbortError") {
throw('AbortError');
}
else {
throw('other that.GetChunk error');
}
}
finally {
that.inuse = 0;
}
};
return that;
};
const GetFileSize = function(xhr) {
let re = new RegExp('/([0-9]+)');
let res = re.exec(xhr.getResponseHeader('Content-Range'));
if(!res) throw("Failed to get filesize");
return Number(res[1]);
};
const DefDownloadManager = function(chunksize) {
const that = {};
that.CHUNKSIZE = chunksize;
that.curOffset;
that.GetChunk = async function(url, startOffset, signal) {
const sd = (that.curOffset === startOffset) ? ' SAME' : ' DIFF DFDFDFDFDFFSDFSFS';
//console.log('curOffset '+ that.curOffset + 'startOffset ' + startOffset + sd);
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
}
const that = {};
that.CHUNKSIZE = 262144;
that.url = theURL;
DLMGR ||= DefDownloadManager(that.CHUNKSIZE);
that._downloadChunk = async function(start, mysignal) {
if(start % that.CHUNKSIZE)
{
throw("start is not a multiple of CHUNKSIZE: " + start);
}
const chunk = await DLMGR.GetChunk(theURL, start, mysignal);
that.filesize = chunk.filesize;
return chunk;
};
that._storeChunk = function(chunk, start) {
let blockptr = MHFSCL.Module._mhfs_cl_track_add_block(that.ptr, start, that.filesize);
if(!blockptr)
{
throw("failed MHFSCL.Module._mhfs_cl_track_add_block");
}
let dataHeap = new Uint8Array(MHFSCL.Module.HEAPU8.buffer, blockptr, chunk.data.byteLength);
dataHeap.set(chunk.data);
};
that.downloadAndStoreChunk = async function(start, mysignal) {
const chunk = await that._downloadChunk(start, mysignal);
that._storeChunk(chunk, start);
return chunk;
};
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
if(that.ptr){
if(that.initialized) {
MHFSCL.Module._mhfs_cl_track_deinit(that.ptr);
}
MHFSCL.Module._free(that.ptr);
that.ptr = null;
}
};
that.seek = function(pcmFrameIndex) {
if(!MHFSCL.Module._mhfs_cl_track_seek_to_pcm_frame(that.ptr, pcmFrameIndex)) throw("Failed to seek to " + pcmFrameIndex);
};
that.seekSecs = function(floatseconds) {
that.seek(Math.floor(floatseconds * that.sampleRate));
};
that._openPictureIfExists = function() {
if(!that.picture) {
return undefined;
}
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
});
const url = URL.createObjectURL(blobert);
return url;
};
return that.picture;
};
// allocate memory for the mhfs_cl_track and return data
const alignedTrackSize = MHFSCL.AlignedSize(MHFSCL.mhfs_cl_track.sizeof);
that.ptr = MHFSCL.Module._malloc(alignedTrackSize + MHFSCL.mhfs_cl_track_return_data.sizeof);
if(!that.ptr) throw("failed malloc");
const rd = MHFSCL.mhfs_cl_track_return_data.from(that.ptr + alignedTrackSize);
const thatid = MHFSCLObjectMap.addData(that);
const pFullFilename = MHFSCL.Module.allocateUTF8(theURL);
let pMime;
try {
// initialize the track
let start = 0;
const firstreq = await that._downloadChunk(start, gsignal);
const mime = firstreq.headers['Content-Type'] || '';
pMime = MHFSCL.Module.allocateUTF8(mime);
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
// load enough of the track that the metadata loads
for(;;) {
that.picture = null;
const code = MHFSCL.Module._mhfs_cl_track_load_metadata(that.ptr, rd.ptr, pMime, pFullFilename, totalPCMFramesLo, totalPCMFramesHi, MHFSCL.pMHFSCLTrackOnMeta, thatid);
if(code === MHFSCL.MHFS_CL_SUCCESS) {
break;
}
if(code !== MHFSCL.MHFS_CL_NEED_MORE_DATA){
that.close();
throw("Failed opening MHFSCLTrack");
}
start = rd.get('needed_offset');
await that.downloadAndStoreChunk(start, gsignal);
}
}
catch(error) {
that.close();
throw(error);
}
finally {
MHFSCL.Module._free(pFullFilename);
if(pMime) MHFSCL.Module._free(pMime);
MHFSCLObjectMap.removeData(thatid);
}
return that;
};
export { MHFSCLTrack };
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
that.size = 0;
that.ptr = 0;
// return a ptr to a block of memory of at least sz bytes
that.with = function(sz) {
if(sz <= that.size) {
return that.ptr;
}
const ptr = MHFSCL.Module._realloc(that.ptr, sz);
if(!ptr) {
throw("realloc failed");
}
that.ptr = ptr;
that.size = sz;
return ptr;
};
that.free = function() {
if(that.ptr) {
MHFSCL.Module._free(that.ptr);
that.ptr = 0;
that.size = 0;
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
return that;
};
const MHFSCLDecoder = async function(outputSampleRate, outputChannelCount) {
if(!MHFSCL.ready) {
console.log('MHFSCLDecoder, waiting for MHFSCL to be ready');
await waitForEvent(MHFSCL, 'ready');
}
const that = {};
that.ptr = MHFSCL.Module._mhfs_cl_decoder_open(outputSampleRate, outputChannelCount, outputSampleRate);
if(! that.ptr) throw("Failed to open decoder");
that.outputSampleRate = outputSampleRate;
that.outputChannelCount = outputChannelCount;
that.f32_size = 4;
that.pcm_float_frame_size = that.f32_size * that.outputChannelCount;
that.returnDataAlloc = MHFSCLAllocation(MHFSCL.mhfs_cl_track_return_data.sizeof);
that.deinterleaveDataAlloc = MHFSCLArrsAlloc(outputChannelCount, that.outputSampleRate*that.f32_size);
//that.DM = DownloadManager(262144);
that.rd = MHFSCL.mhfs_cl_track_return_data.from(that.returnDataAlloc.ptr);
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
do {
const url = intrack.url;
if(that.track) {
if(that.track.url === url) {
doseek = 1;
break;
}
await that.track.close();
that.track = null;
if(signal.aborted) {
throw("abort after closing track");
}
}
that.track = await MHFSCLTrack(signal, url, that.DM);
} while(0);
if(doseek) {
that.track.seekSecs(starttime);
}
if(signal.aborted) {
console.log('');
await that.track.close();
that.track = null;
throw("abort after open track success");
}
return { duration : that.track.duration, mediametadata : that.track.mediametadata };
};
that.seek_input_pcm_frames = async function(pcmFrameIndex) {
if(!that.track) throw("nothing to seek on");
that.track.seek(pcmFrameIndex);
};
that.seek = async function(floatseconds) {
if(!that.track) throw("nothing to seek on");
that.track.seekSecs(floatseconds);
}
that.read_pcm_frames_f32_deinterleaved = async function(todec, destdata, mysignal) {
while(1) {
// attempt to decode the samples
const code = MHFSCL.Module._mhfs_cl_decoder_read_pcm_frames_f32_deinterleaved(that.ptr, that.track.ptr, todec, destdata, that.rd.ptr);
// success, retdata is frames read
if(code === MHFSCL.MHFS_CL_SUCCESS)
{
return that.rd.get('frames_read');
}
if(code !== MHFSCL.MHFS_CL_NEED_MORE_DATA)
{
throw("mhfs_cl_decoder_read_pcm_frames_f32_deinterleaved failed");
}
// download more data
await that.track.downloadAndStoreChunk(that.rd.get('needed_offset'), mysignal);
}
};
that.read_pcm_frames_f32_AudioBuffer = async function(todec, mysignal) {
let theerror;
let returnval;
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
const buf = new Float32Array(MHFSCL.Module.HEAPU8.buffer, chanPtrs[i], frames);
audiobuffer.copyToChannel(buf, i);
}
returnval = audiobuffer;
}
}
catch(error) {
theerror = error;
}
finally {
if(theerror) throw(theerror);
return returnval;
}
};
that.read_pcm_frames_f32_arrs = async function(todec, mysignal) {
let theerror;
let returnval;
const destdata = that.deinterleaveDataAlloc.with(todec*that.f32_size);
try {
const frames = await that.read_pcm_frames_f32_deinterleaved(todec, destdata, mysignal);
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
for( let i = 0; i < that.outputChannelCount; i++) {
obj.chanData[i] = new Float32Array(MHFSCL.Module.HEAPU8.buffer, chanPtrs[i], frames);
}
returnval = obj;
}
}
catch(error) {
theerror = error;
}
finally {
if(theerror) throw(theerror);
return returnval;
}
};
return that;
};
export { MHFSCLDecoder };
const ExposeType_LoadTypes = function(BINDTO, wasmMod, loadType) {
const currentObject = [BINDTO];
share/public_html/static/music_worklet_inprogress/decoder/mhfscl.js view on Meta::CPAN
}
else if(this.members[memberName].type === BINDTO.ET_TT_UINT64) {
return BigInt(wasmMod.HEAPU32[ptr >> 2]) + (BigInt(wasmMod.HEAPU32[(ptr+4) >> 2]) << BigInt(32));
}
else if(this.members[memberName].type === BINDTO.ET_TT_UINT16) {
return wasmMod.HEAPU16[ptr >> 1];
}
else if(this.members[memberName].type === BINDTO.ET_TT_UINT8) {
return wasmMod.HEAPU8[ptr];
}
throw("ENOTIMPLEMENTED");
}
};
const struct = function(ptr) {
this.ptr = ptr;
};
struct.prototype = structPrototype;
struct.prototype.constructor = struct;
BINDTO[structmeta.name] = {
from : (ptr) => new struct(ptr),
sizeof : structmeta.size
share/public_html/static/music_worklet_inprogress/index.html view on Meta::CPAN
<link rel="modulepreload" href='player/mhfsplayer.js'>
<script src="music_inc_module.js" type="module" async> </script>
<script>
// load the DB
let urlParams = new URLSearchParams(window.location.search);
/*
urlParams.append('fmt', 'musicdbhtml');
let myRequest = new Request('../../music?'+urlParams.toString());
fetch(myRequest).then(function(response) {
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return response.text();
}).then((html) => {
document.getElementById("musicdb").innerHTML = html;
});
*/
function escapeHTML(unsafe) {
return unsafe
.replace(/&/g, "&")
share/public_html/static/music_worklet_inprogress/index.html view on Meta::CPAN
}
} while(1);
}
if(readerDone) break;
} while(1);
// search backwards for the end token
// attempting to parse the input as an array each time it's found
do {
const endIndex = existingData.lastIndexOf(endStr);
if(endIndex === -1) {
throw("Failed to find json end!");
}
existingData = existingData.slice(0, endIndex);
try {
const records = JSON.parse('['+existingData + ']');
yield records;
return;
}
catch {
}
} while(1);
};
urlParams.append('fmt', 'musicdbjson');
const apiroot = '../..';
const jsonurl = apiroot + '/music?'+urlParams.toString();
//fetch(jsonurl).then(function(response) {
// if (!response.ok) {
// throw new Error(`HTTP error! status: ${response.status}`);
// }
// return response.json();
////}).then(DB2HTMLRunner);
////}).then(OldDB2HTML);
//}).then(DB2HTMLDomRunner);
//const newmdb = document.createElement("div");
///newmdb.setAttribute("id", 'musicdb');
const oldmdb = document.getElementById("musicdb");
const jsonReader = JSONArrayStreamer(jsonurl);
share/public_html/static/music_worklet_inprogress/player/AudioWriterReader.js view on Meta::CPAN
//return (this._writeindex() - this._readindex()) % this._size;
}
// returns the number of free slots
getspace() {
return this._capacity - this.getcount();
}
_AssertSameArrayCount(param) {
if(param.length === this._subbuffercount) return;
throw("Different Array Counts! param " + param + " subbuffercount " + this._subbuffercount);
}
}
class RingBufferReader {
constructor(rb) {
this._rb = rb;
}
getcount() {
return this._rb.getcount();
share/public_html/static/music_worklet_inprogress/player/AudioWriterReader.js view on Meta::CPAN
Atomics.store(this._rb._sharedvarsuint32, 0, newval);
}
write(arrs, max) {
this._rb._AssertSameArrayCount(arrs);
max = max || arrs[0].length;
const count = Math.min(max, arrs[0].length);
const space = this._rb.getspace();
if(count > space) {
throw("Tried to write too much data, count " + count + " space " + space);
}
let writeindex = this._rb._writeindex();
if((writeindex+count) < this._rb._size) {
// copy the data for each array
for(let i = 0; i < arrs.length; i++) {
this._rb._buffer[i].set(arrs[i].subarray(0, count), writeindex);
}
writeindex += count;
share/public_html/static/music_worklet_inprogress/player/AudioWriterReader.js view on Meta::CPAN
}
// commit that more data is available to read
this._setwriteindex(writeindex);
}
/*
write_from_rb_reader(srcrb, count) {
const srccount = srcrb.getcount();
if(srccount <= count) throw("Not enough data to read");
const destcount = this._getcount();
if(destcount <= count) throw("not enough room to write");
if(this._rb._subbuffercount !== src._rb._subbuffercount) throw("different subbuffer count between dest and src");
// copy the first half
let destwi = this._rb._writeindex();
const writeleft = this._rb._size - destwi;
const canwrite = Math.min(count, writeleft);
src.read(this._rb._buffer, canwrite, destwi);
count -= canwrite;
destwi = (destwi+canwrite) % this._rb._size;
// copy the second half if needed
share/public_html/static/music_worklet_inprogress/player/worklet_processor_ff.js view on Meta::CPAN
//return (this._writeindex() - this._readindex()) % this._size;
}
// returns the number of free slots
getspace() {
return this._capacity - this.getcount();
}
_AssertSameArrayCount(param) {
if(param.length === this._subbuffercount) return;
throw("Different Array Counts! param " + param + " subbuffercount " + this._subbuffercount);
}
}
class RingBufferReader {
constructor(rb) {
this._rb = rb;
}
getcount() {
return this._rb.getcount();
share/public_html/static/music_worklet_inprogress/player/worklet_processor_ff.js view on Meta::CPAN
Atomics.store(this._rb._sharedvarsuint32, 0, newval);
}
write(arrs, max) {
this._rb._AssertSameArrayCount(arrs);
max = max || arrs[0].length;
const count = Math.min(max, arrs[0].length);
const space = this._rb.getspace();
if(count > space) {
throw("Tried to write too much data, count " + count + " space " + space);
}
let writeindex = this._rb._writeindex();
if((writeindex+count) < this._rb._size) {
// copy the data for each array
for(let i = 0; i < arrs.length; i++) {
this._rb._buffer[i].set(arrs[i].subarray(0, count), writeindex);
}
writeindex += count;
share/public_html/static/music_worklet_inprogress/player/worklet_processor_ff.js view on Meta::CPAN
}
// commit that more data is available to read
this._setwriteindex(writeindex);
}
/*
write_from_rb_reader(srcrb, count) {
const srccount = srcrb.getcount();
if(srccount <= count) throw("Not enough data to read");
const destcount = this._getcount();
if(destcount <= count) throw("not enough room to write");
if(this._rb._subbuffercount !== src._rb._subbuffercount) throw("different subbuffer count between dest and src");
// copy the first half
let destwi = this._rb._writeindex();
const writeleft = this._rb._size - destwi;
const canwrite = Math.min(count, writeleft);
src.read(this._rb._buffer, canwrite, destwi);
count -= canwrite;
destwi = (destwi+canwrite) % this._rb._size;
// copy the second half if needed
( run in 0.465 second using v1.01-cache-2.11-cpan-8d75d55dd25 )