forked from apps/plugin-preview
9995 lines
367 KiB
JavaScript
9995 lines
367 KiB
JavaScript
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('path'), require('fs'), require('crypto')) :
|
||
typeof define === 'function' && define.amd ? define(['path', 'fs', 'crypto'], factory) :
|
||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.path, global.fs, global.crypto$1));
|
||
})(this, (function (path, fs, crypto$1) { 'use strict';
|
||
|
||
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
|
||
|
||
var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
|
||
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
|
||
var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto$1);
|
||
|
||
function createCommonjsModule(fn, module) {
|
||
return module = { exports: {} }, fn(module, module.exports), module.exports;
|
||
}
|
||
|
||
var decoderProSimd = createCommonjsModule(function (module) {
|
||
var Module = typeof Module != "undefined" ? Module : {};
|
||
var moduleOverrides = Object.assign({}, Module);
|
||
var thisProgram = "./this.program";
|
||
var ENVIRONMENT_IS_WEB = typeof window == "object";
|
||
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
|
||
var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
|
||
var scriptDirectory = "";
|
||
function locateFile(path) {
|
||
if (Module["locateFile"]) {
|
||
return Module["locateFile"](path, scriptDirectory);
|
||
}
|
||
return scriptDirectory + path;
|
||
}
|
||
var read_, readAsync, readBinary;
|
||
var fs;
|
||
var nodePath;
|
||
var requireNodeFS;
|
||
if (ENVIRONMENT_IS_NODE) {
|
||
if (ENVIRONMENT_IS_WORKER) {
|
||
scriptDirectory = path__default["default"].dirname(scriptDirectory) + "/";
|
||
} else {
|
||
scriptDirectory = __dirname + "/";
|
||
}
|
||
requireNodeFS = () => {
|
||
if (!nodePath) {
|
||
fs = fs__default["default"];
|
||
nodePath = path__default["default"];
|
||
}
|
||
};
|
||
read_ = function shell_read(filename, binary) {
|
||
requireNodeFS();
|
||
filename = nodePath["normalize"](filename);
|
||
return fs.readFileSync(filename, binary ? undefined : "utf8");
|
||
};
|
||
readBinary = filename => {
|
||
var ret = read_(filename, true);
|
||
if (!ret.buffer) {
|
||
ret = new Uint8Array(ret);
|
||
}
|
||
return ret;
|
||
};
|
||
readAsync = (filename, onload, onerror) => {
|
||
requireNodeFS();
|
||
filename = nodePath["normalize"](filename);
|
||
fs.readFile(filename, function (err, data) {
|
||
if (err) onerror(err);else onload(data.buffer);
|
||
});
|
||
};
|
||
if (process["argv"].length > 1) {
|
||
thisProgram = process["argv"][1].replace(/\\/g, "/");
|
||
}
|
||
process["argv"].slice(2);
|
||
{
|
||
module["exports"] = Module;
|
||
}
|
||
process["on"]("uncaughtException", function (ex) {
|
||
if (!(ex instanceof ExitStatus)) {
|
||
throw ex;
|
||
}
|
||
});
|
||
process["on"]("unhandledRejection", function (reason) {
|
||
throw reason;
|
||
});
|
||
Module["inspect"] = function () {
|
||
return "[Emscripten Module object]";
|
||
};
|
||
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
|
||
if (ENVIRONMENT_IS_WORKER) {
|
||
scriptDirectory = self.location.href;
|
||
} else if (typeof document != "undefined" && document.currentScript) {
|
||
scriptDirectory = document.currentScript.src;
|
||
}
|
||
if (scriptDirectory.indexOf("blob:") !== 0) {
|
||
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
|
||
} else {
|
||
scriptDirectory = "";
|
||
}
|
||
{
|
||
read_ = url => {
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("GET", url, false);
|
||
xhr.send(null);
|
||
return xhr.responseText;
|
||
};
|
||
if (ENVIRONMENT_IS_WORKER) {
|
||
readBinary = url => {
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("GET", url, false);
|
||
xhr.responseType = "arraybuffer";
|
||
xhr.send(null);
|
||
return new Uint8Array(xhr.response);
|
||
};
|
||
}
|
||
readAsync = (url, onload, onerror) => {
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("GET", url, true);
|
||
xhr.responseType = "arraybuffer";
|
||
xhr.onload = () => {
|
||
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
|
||
onload(xhr.response);
|
||
return;
|
||
}
|
||
onerror();
|
||
};
|
||
xhr.onerror = onerror;
|
||
xhr.send(null);
|
||
};
|
||
}
|
||
} else ;
|
||
var out = Module["print"] || console.log.bind(console);
|
||
var err = Module["printErr"] || console.warn.bind(console);
|
||
Object.assign(Module, moduleOverrides);
|
||
moduleOverrides = null;
|
||
if (Module["arguments"]) Module["arguments"];
|
||
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
|
||
if (Module["quit"]) Module["quit"];
|
||
var POINTER_SIZE = 4;
|
||
var wasmBinary;
|
||
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
|
||
Module["noExitRuntime"] || true;
|
||
if (typeof WebAssembly != "object") {
|
||
abort("no native wasm support detected");
|
||
}
|
||
var wasmMemory;
|
||
var ABORT = false;
|
||
function assert(condition, text) {
|
||
if (!condition) {
|
||
abort(text);
|
||
}
|
||
}
|
||
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
|
||
function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
|
||
var endIdx = idx + maxBytesToRead;
|
||
var endPtr = idx;
|
||
while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
|
||
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
|
||
return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
|
||
}
|
||
var str = "";
|
||
while (idx < endPtr) {
|
||
var u0 = heapOrArray[idx++];
|
||
if (!(u0 & 128)) {
|
||
str += String.fromCharCode(u0);
|
||
continue;
|
||
}
|
||
var u1 = heapOrArray[idx++] & 63;
|
||
if ((u0 & 224) == 192) {
|
||
str += String.fromCharCode((u0 & 31) << 6 | u1);
|
||
continue;
|
||
}
|
||
var u2 = heapOrArray[idx++] & 63;
|
||
if ((u0 & 240) == 224) {
|
||
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
|
||
} else {
|
||
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
|
||
}
|
||
if (u0 < 65536) {
|
||
str += String.fromCharCode(u0);
|
||
} else {
|
||
var ch = u0 - 65536;
|
||
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
|
||
}
|
||
}
|
||
return str;
|
||
}
|
||
function UTF8ToString(ptr, maxBytesToRead) {
|
||
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
|
||
}
|
||
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
|
||
if (!(maxBytesToWrite > 0)) return 0;
|
||
var startIdx = outIdx;
|
||
var endIdx = outIdx + maxBytesToWrite - 1;
|
||
for (var i = 0; i < str.length; ++i) {
|
||
var u = str.charCodeAt(i);
|
||
if (u >= 55296 && u <= 57343) {
|
||
var u1 = str.charCodeAt(++i);
|
||
u = 65536 + ((u & 1023) << 10) | u1 & 1023;
|
||
}
|
||
if (u <= 127) {
|
||
if (outIdx >= endIdx) break;
|
||
heap[outIdx++] = u;
|
||
} else if (u <= 2047) {
|
||
if (outIdx + 1 >= endIdx) break;
|
||
heap[outIdx++] = 192 | u >> 6;
|
||
heap[outIdx++] = 128 | u & 63;
|
||
} else if (u <= 65535) {
|
||
if (outIdx + 2 >= endIdx) break;
|
||
heap[outIdx++] = 224 | u >> 12;
|
||
heap[outIdx++] = 128 | u >> 6 & 63;
|
||
heap[outIdx++] = 128 | u & 63;
|
||
} else {
|
||
if (outIdx + 3 >= endIdx) break;
|
||
heap[outIdx++] = 240 | u >> 18;
|
||
heap[outIdx++] = 128 | u >> 12 & 63;
|
||
heap[outIdx++] = 128 | u >> 6 & 63;
|
||
heap[outIdx++] = 128 | u & 63;
|
||
}
|
||
}
|
||
heap[outIdx] = 0;
|
||
return outIdx - startIdx;
|
||
}
|
||
function stringToUTF8(str, outPtr, maxBytesToWrite) {
|
||
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
|
||
}
|
||
function lengthBytesUTF8(str) {
|
||
var len = 0;
|
||
for (var i = 0; i < str.length; ++i) {
|
||
var c = str.charCodeAt(i);
|
||
if (c <= 127) {
|
||
len++;
|
||
} else if (c <= 2047) {
|
||
len += 2;
|
||
} else if (c >= 55296 && c <= 57343) {
|
||
len += 4;
|
||
++i;
|
||
} else {
|
||
len += 3;
|
||
}
|
||
}
|
||
return len;
|
||
}
|
||
var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
|
||
function updateGlobalBufferAndViews(buf) {
|
||
buffer = buf;
|
||
Module["HEAP8"] = HEAP8 = new Int8Array(buf);
|
||
Module["HEAP16"] = HEAP16 = new Int16Array(buf);
|
||
Module["HEAP32"] = HEAP32 = new Int32Array(buf);
|
||
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
|
||
Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
|
||
Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
|
||
Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
|
||
Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
|
||
}
|
||
Module["INITIAL_MEMORY"] || 268435456;
|
||
var wasmTable;
|
||
var __ATPRERUN__ = [];
|
||
var __ATINIT__ = [];
|
||
var __ATPOSTRUN__ = [];
|
||
function preRun() {
|
||
if (Module["preRun"]) {
|
||
if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
|
||
while (Module["preRun"].length) {
|
||
addOnPreRun(Module["preRun"].shift());
|
||
}
|
||
}
|
||
callRuntimeCallbacks(__ATPRERUN__);
|
||
}
|
||
function initRuntime() {
|
||
if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
|
||
FS.ignorePermissions = false;
|
||
callRuntimeCallbacks(__ATINIT__);
|
||
}
|
||
function postRun() {
|
||
if (Module["postRun"]) {
|
||
if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
|
||
while (Module["postRun"].length) {
|
||
addOnPostRun(Module["postRun"].shift());
|
||
}
|
||
}
|
||
callRuntimeCallbacks(__ATPOSTRUN__);
|
||
}
|
||
function addOnPreRun(cb) {
|
||
__ATPRERUN__.unshift(cb);
|
||
}
|
||
function addOnInit(cb) {
|
||
__ATINIT__.unshift(cb);
|
||
}
|
||
function addOnPostRun(cb) {
|
||
__ATPOSTRUN__.unshift(cb);
|
||
}
|
||
var runDependencies = 0;
|
||
var dependenciesFulfilled = null;
|
||
function getUniqueRunDependency(id) {
|
||
return id;
|
||
}
|
||
function addRunDependency(id) {
|
||
runDependencies++;
|
||
if (Module["monitorRunDependencies"]) {
|
||
Module["monitorRunDependencies"](runDependencies);
|
||
}
|
||
}
|
||
function removeRunDependency(id) {
|
||
runDependencies--;
|
||
if (Module["monitorRunDependencies"]) {
|
||
Module["monitorRunDependencies"](runDependencies);
|
||
}
|
||
if (runDependencies == 0) {
|
||
if (dependenciesFulfilled) {
|
||
var callback = dependenciesFulfilled;
|
||
dependenciesFulfilled = null;
|
||
callback();
|
||
}
|
||
}
|
||
}
|
||
function abort(what) {
|
||
{
|
||
if (Module["onAbort"]) {
|
||
Module["onAbort"](what);
|
||
}
|
||
}
|
||
what = "Aborted(" + what + ")";
|
||
err(what);
|
||
ABORT = true;
|
||
what += ". Build with -sASSERTIONS for more info.";
|
||
var e = new WebAssembly.RuntimeError(what);
|
||
throw e;
|
||
}
|
||
var dataURIPrefix = "data:application/octet-stream;base64,";
|
||
function isDataURI(filename) {
|
||
return filename.startsWith(dataURIPrefix);
|
||
}
|
||
function isFileURI(filename) {
|
||
return filename.startsWith("file://");
|
||
}
|
||
var wasmBinaryFile;
|
||
wasmBinaryFile = "decoder-pro-simd.wasm";
|
||
if (!isDataURI(wasmBinaryFile)) {
|
||
wasmBinaryFile = locateFile(wasmBinaryFile);
|
||
}
|
||
function getBinary(file) {
|
||
try {
|
||
if (file == wasmBinaryFile && wasmBinary) {
|
||
return new Uint8Array(wasmBinary);
|
||
}
|
||
if (readBinary) {
|
||
return readBinary(file);
|
||
}
|
||
throw "both async and sync fetching of the wasm failed";
|
||
} catch (err) {
|
||
abort(err);
|
||
}
|
||
}
|
||
function getBinaryPromise() {
|
||
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
|
||
if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) {
|
||
return fetch(wasmBinaryFile, {
|
||
credentials: "same-origin"
|
||
}).then(function (response) {
|
||
if (!response["ok"]) {
|
||
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
|
||
}
|
||
return response["arrayBuffer"]();
|
||
}).catch(function () {
|
||
return getBinary(wasmBinaryFile);
|
||
});
|
||
} else {
|
||
if (readAsync) {
|
||
return new Promise(function (resolve, reject) {
|
||
readAsync(wasmBinaryFile, function (response) {
|
||
resolve(new Uint8Array(response));
|
||
}, reject);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
return Promise.resolve().then(function () {
|
||
return getBinary(wasmBinaryFile);
|
||
});
|
||
}
|
||
function createWasm() {
|
||
var info = {
|
||
"a": asmLibraryArg
|
||
};
|
||
function receiveInstance(instance, module) {
|
||
var exports = instance.exports;
|
||
Module["asm"] = exports;
|
||
wasmMemory = Module["asm"]["F"];
|
||
updateGlobalBufferAndViews(wasmMemory.buffer);
|
||
wasmTable = Module["asm"]["J"];
|
||
addOnInit(Module["asm"]["G"]);
|
||
removeRunDependency();
|
||
}
|
||
addRunDependency();
|
||
function receiveInstantiationResult(result) {
|
||
receiveInstance(result["instance"]);
|
||
}
|
||
function instantiateArrayBuffer(receiver) {
|
||
return getBinaryPromise().then(function (binary) {
|
||
return WebAssembly.instantiate(binary, info);
|
||
}).then(function (instance) {
|
||
return instance;
|
||
}).then(receiver, function (reason) {
|
||
err("failed to asynchronously prepare wasm: " + reason);
|
||
abort(reason);
|
||
});
|
||
}
|
||
function instantiateAsync() {
|
||
if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
|
||
return fetch(wasmBinaryFile, {
|
||
credentials: "same-origin"
|
||
}).then(function (response) {
|
||
var result = WebAssembly.instantiateStreaming(response, info);
|
||
return result.then(receiveInstantiationResult, function (reason) {
|
||
err("wasm streaming compile failed: " + reason);
|
||
err("falling back to ArrayBuffer instantiation");
|
||
return instantiateArrayBuffer(receiveInstantiationResult);
|
||
});
|
||
});
|
||
} else {
|
||
return instantiateArrayBuffer(receiveInstantiationResult);
|
||
}
|
||
}
|
||
if (Module["instantiateWasm"]) {
|
||
try {
|
||
var exports = Module["instantiateWasm"](info, receiveInstance);
|
||
return exports;
|
||
} catch (e) {
|
||
err("Module.instantiateWasm callback failed with error: " + e);
|
||
return false;
|
||
}
|
||
}
|
||
instantiateAsync();
|
||
return {};
|
||
}
|
||
var tempDouble;
|
||
var tempI64;
|
||
function ExitStatus(status) {
|
||
this.name = "ExitStatus";
|
||
this.message = "Program terminated with exit(" + status + ")";
|
||
this.status = status;
|
||
}
|
||
function callRuntimeCallbacks(callbacks) {
|
||
while (callbacks.length > 0) {
|
||
callbacks.shift()(Module);
|
||
}
|
||
}
|
||
function ___cxa_allocate_exception(size) {
|
||
return _malloc(size + 24) + 24;
|
||
}
|
||
function ExceptionInfo(excPtr) {
|
||
this.excPtr = excPtr;
|
||
this.ptr = excPtr - 24;
|
||
this.set_type = function (type) {
|
||
HEAPU32[this.ptr + 4 >> 2] = type;
|
||
};
|
||
this.get_type = function () {
|
||
return HEAPU32[this.ptr + 4 >> 2];
|
||
};
|
||
this.set_destructor = function (destructor) {
|
||
HEAPU32[this.ptr + 8 >> 2] = destructor;
|
||
};
|
||
this.get_destructor = function () {
|
||
return HEAPU32[this.ptr + 8 >> 2];
|
||
};
|
||
this.set_refcount = function (refcount) {
|
||
HEAP32[this.ptr >> 2] = refcount;
|
||
};
|
||
this.set_caught = function (caught) {
|
||
caught = caught ? 1 : 0;
|
||
HEAP8[this.ptr + 12 >> 0] = caught;
|
||
};
|
||
this.get_caught = function () {
|
||
return HEAP8[this.ptr + 12 >> 0] != 0;
|
||
};
|
||
this.set_rethrown = function (rethrown) {
|
||
rethrown = rethrown ? 1 : 0;
|
||
HEAP8[this.ptr + 13 >> 0] = rethrown;
|
||
};
|
||
this.get_rethrown = function () {
|
||
return HEAP8[this.ptr + 13 >> 0] != 0;
|
||
};
|
||
this.init = function (type, destructor) {
|
||
this.set_adjusted_ptr(0);
|
||
this.set_type(type);
|
||
this.set_destructor(destructor);
|
||
this.set_refcount(0);
|
||
this.set_caught(false);
|
||
this.set_rethrown(false);
|
||
};
|
||
this.add_ref = function () {
|
||
var value = HEAP32[this.ptr >> 2];
|
||
HEAP32[this.ptr >> 2] = value + 1;
|
||
};
|
||
this.release_ref = function () {
|
||
var prev = HEAP32[this.ptr >> 2];
|
||
HEAP32[this.ptr >> 2] = prev - 1;
|
||
return prev === 1;
|
||
};
|
||
this.set_adjusted_ptr = function (adjustedPtr) {
|
||
HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
|
||
};
|
||
this.get_adjusted_ptr = function () {
|
||
return HEAPU32[this.ptr + 16 >> 2];
|
||
};
|
||
this.get_exception_ptr = function () {
|
||
var isPointer = ___cxa_is_pointer_type(this.get_type());
|
||
if (isPointer) {
|
||
return HEAPU32[this.excPtr >> 2];
|
||
}
|
||
var adjusted = this.get_adjusted_ptr();
|
||
if (adjusted !== 0) return adjusted;
|
||
return this.excPtr;
|
||
};
|
||
}
|
||
function ___cxa_throw(ptr, type, destructor) {
|
||
var info = new ExceptionInfo(ptr);
|
||
info.init(type, destructor);
|
||
throw ptr;
|
||
}
|
||
function setErrNo(value) {
|
||
HEAP32[___errno_location() >> 2] = value;
|
||
return value;
|
||
}
|
||
var PATH = {
|
||
isAbs: path => path.charAt(0) === "/",
|
||
splitPath: filename => {
|
||
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
||
return splitPathRe.exec(filename).slice(1);
|
||
},
|
||
normalizeArray: (parts, allowAboveRoot) => {
|
||
var up = 0;
|
||
for (var i = parts.length - 1; i >= 0; i--) {
|
||
var last = parts[i];
|
||
if (last === ".") {
|
||
parts.splice(i, 1);
|
||
} else if (last === "..") {
|
||
parts.splice(i, 1);
|
||
up++;
|
||
} else if (up) {
|
||
parts.splice(i, 1);
|
||
up--;
|
||
}
|
||
}
|
||
if (allowAboveRoot) {
|
||
for (; up; up--) {
|
||
parts.unshift("..");
|
||
}
|
||
}
|
||
return parts;
|
||
},
|
||
normalize: path => {
|
||
var isAbsolute = PATH.isAbs(path),
|
||
trailingSlash = path.substr(-1) === "/";
|
||
path = PATH.normalizeArray(path.split("/").filter(p => !!p), !isAbsolute).join("/");
|
||
if (!path && !isAbsolute) {
|
||
path = ".";
|
||
}
|
||
if (path && trailingSlash) {
|
||
path += "/";
|
||
}
|
||
return (isAbsolute ? "/" : "") + path;
|
||
},
|
||
dirname: path => {
|
||
var result = PATH.splitPath(path),
|
||
root = result[0],
|
||
dir = result[1];
|
||
if (!root && !dir) {
|
||
return ".";
|
||
}
|
||
if (dir) {
|
||
dir = dir.substr(0, dir.length - 1);
|
||
}
|
||
return root + dir;
|
||
},
|
||
basename: path => {
|
||
if (path === "/") return "/";
|
||
path = PATH.normalize(path);
|
||
path = path.replace(/\/$/, "");
|
||
var lastSlash = path.lastIndexOf("/");
|
||
if (lastSlash === -1) return path;
|
||
return path.substr(lastSlash + 1);
|
||
},
|
||
join: function () {
|
||
var paths = Array.prototype.slice.call(arguments, 0);
|
||
return PATH.normalize(paths.join("/"));
|
||
},
|
||
join2: (l, r) => {
|
||
return PATH.normalize(l + "/" + r);
|
||
}
|
||
};
|
||
function getRandomDevice() {
|
||
if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
|
||
var randomBuffer = new Uint8Array(1);
|
||
return () => {
|
||
crypto.getRandomValues(randomBuffer);
|
||
return randomBuffer[0];
|
||
};
|
||
} else if (ENVIRONMENT_IS_NODE) {
|
||
try {
|
||
var crypto_module = crypto__default["default"];
|
||
return () => crypto_module["randomBytes"](1)[0];
|
||
} catch (e) {}
|
||
}
|
||
return () => abort("randomDevice");
|
||
}
|
||
var PATH_FS = {
|
||
resolve: function () {
|
||
var resolvedPath = "",
|
||
resolvedAbsolute = false;
|
||
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
||
var path = i >= 0 ? arguments[i] : FS.cwd();
|
||
if (typeof path != "string") {
|
||
throw new TypeError("Arguments to path.resolve must be strings");
|
||
} else if (!path) {
|
||
return "";
|
||
}
|
||
resolvedPath = path + "/" + resolvedPath;
|
||
resolvedAbsolute = PATH.isAbs(path);
|
||
}
|
||
resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/");
|
||
return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
|
||
},
|
||
relative: (from, to) => {
|
||
from = PATH_FS.resolve(from).substr(1);
|
||
to = PATH_FS.resolve(to).substr(1);
|
||
function trim(arr) {
|
||
var start = 0;
|
||
for (; start < arr.length; start++) {
|
||
if (arr[start] !== "") break;
|
||
}
|
||
var end = arr.length - 1;
|
||
for (; end >= 0; end--) {
|
||
if (arr[end] !== "") break;
|
||
}
|
||
if (start > end) return [];
|
||
return arr.slice(start, end - start + 1);
|
||
}
|
||
var fromParts = trim(from.split("/"));
|
||
var toParts = trim(to.split("/"));
|
||
var length = Math.min(fromParts.length, toParts.length);
|
||
var samePartsLength = length;
|
||
for (var i = 0; i < length; i++) {
|
||
if (fromParts[i] !== toParts[i]) {
|
||
samePartsLength = i;
|
||
break;
|
||
}
|
||
}
|
||
var outputParts = [];
|
||
for (var i = samePartsLength; i < fromParts.length; i++) {
|
||
outputParts.push("..");
|
||
}
|
||
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
||
return outputParts.join("/");
|
||
}
|
||
};
|
||
function intArrayFromString(stringy, dontAddNull, length) {
|
||
var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
|
||
var u8array = new Array(len);
|
||
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
|
||
if (dontAddNull) u8array.length = numBytesWritten;
|
||
return u8array;
|
||
}
|
||
var TTY = {
|
||
ttys: [],
|
||
init: function () {},
|
||
shutdown: function () {},
|
||
register: function (dev, ops) {
|
||
TTY.ttys[dev] = {
|
||
input: [],
|
||
output: [],
|
||
ops: ops
|
||
};
|
||
FS.registerDevice(dev, TTY.stream_ops);
|
||
},
|
||
stream_ops: {
|
||
open: function (stream) {
|
||
var tty = TTY.ttys[stream.node.rdev];
|
||
if (!tty) {
|
||
throw new FS.ErrnoError(43);
|
||
}
|
||
stream.tty = tty;
|
||
stream.seekable = false;
|
||
},
|
||
close: function (stream) {
|
||
stream.tty.ops.flush(stream.tty);
|
||
},
|
||
flush: function (stream) {
|
||
stream.tty.ops.flush(stream.tty);
|
||
},
|
||
read: function (stream, buffer, offset, length, pos) {
|
||
if (!stream.tty || !stream.tty.ops.get_char) {
|
||
throw new FS.ErrnoError(60);
|
||
}
|
||
var bytesRead = 0;
|
||
for (var i = 0; i < length; i++) {
|
||
var result;
|
||
try {
|
||
result = stream.tty.ops.get_char(stream.tty);
|
||
} catch (e) {
|
||
throw new FS.ErrnoError(29);
|
||
}
|
||
if (result === undefined && bytesRead === 0) {
|
||
throw new FS.ErrnoError(6);
|
||
}
|
||
if (result === null || result === undefined) break;
|
||
bytesRead++;
|
||
buffer[offset + i] = result;
|
||
}
|
||
if (bytesRead) {
|
||
stream.node.timestamp = Date.now();
|
||
}
|
||
return bytesRead;
|
||
},
|
||
write: function (stream, buffer, offset, length, pos) {
|
||
if (!stream.tty || !stream.tty.ops.put_char) {
|
||
throw new FS.ErrnoError(60);
|
||
}
|
||
try {
|
||
for (var i = 0; i < length; i++) {
|
||
stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
|
||
}
|
||
} catch (e) {
|
||
throw new FS.ErrnoError(29);
|
||
}
|
||
if (length) {
|
||
stream.node.timestamp = Date.now();
|
||
}
|
||
return i;
|
||
}
|
||
},
|
||
default_tty_ops: {
|
||
get_char: function (tty) {
|
||
if (!tty.input.length) {
|
||
var result = null;
|
||
if (ENVIRONMENT_IS_NODE) {
|
||
var BUFSIZE = 256;
|
||
var buf = Buffer.alloc(BUFSIZE);
|
||
var bytesRead = 0;
|
||
try {
|
||
bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1);
|
||
} catch (e) {
|
||
if (e.toString().includes("EOF")) bytesRead = 0;else throw e;
|
||
}
|
||
if (bytesRead > 0) {
|
||
result = buf.slice(0, bytesRead).toString("utf-8");
|
||
} else {
|
||
result = null;
|
||
}
|
||
} else if (typeof window != "undefined" && typeof window.prompt == "function") {
|
||
result = window.prompt("Input: ");
|
||
if (result !== null) {
|
||
result += "\n";
|
||
}
|
||
} else if (typeof readline == "function") {
|
||
result = readline();
|
||
if (result !== null) {
|
||
result += "\n";
|
||
}
|
||
}
|
||
if (!result) {
|
||
return null;
|
||
}
|
||
tty.input = intArrayFromString(result, true);
|
||
}
|
||
return tty.input.shift();
|
||
},
|
||
put_char: function (tty, val) {
|
||
if (val === null || val === 10) {
|
||
out(UTF8ArrayToString(tty.output, 0));
|
||
tty.output = [];
|
||
} else {
|
||
if (val != 0) tty.output.push(val);
|
||
}
|
||
},
|
||
flush: function (tty) {
|
||
if (tty.output && tty.output.length > 0) {
|
||
out(UTF8ArrayToString(tty.output, 0));
|
||
tty.output = [];
|
||
}
|
||
}
|
||
},
|
||
default_tty1_ops: {
|
||
put_char: function (tty, val) {
|
||
if (val === null || val === 10) {
|
||
err(UTF8ArrayToString(tty.output, 0));
|
||
tty.output = [];
|
||
} else {
|
||
if (val != 0) tty.output.push(val);
|
||
}
|
||
},
|
||
flush: function (tty) {
|
||
if (tty.output && tty.output.length > 0) {
|
||
err(UTF8ArrayToString(tty.output, 0));
|
||
tty.output = [];
|
||
}
|
||
}
|
||
}
|
||
};
|
||
function zeroMemory(address, size) {
|
||
HEAPU8.fill(0, address, address + size);
|
||
}
|
||
function alignMemory(size, alignment) {
|
||
return Math.ceil(size / alignment) * alignment;
|
||
}
|
||
function mmapAlloc(size) {
|
||
size = alignMemory(size, 65536);
|
||
var ptr = _emscripten_builtin_memalign(65536, size);
|
||
if (!ptr) return 0;
|
||
zeroMemory(ptr, size);
|
||
return ptr;
|
||
}
|
||
var MEMFS = {
|
||
ops_table: null,
|
||
mount: function (mount) {
|
||
return MEMFS.createNode(null, "/", 16384 | 511, 0);
|
||
},
|
||
createNode: function (parent, name, mode, dev) {
|
||
if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
if (!MEMFS.ops_table) {
|
||
MEMFS.ops_table = {
|
||
dir: {
|
||
node: {
|
||
getattr: MEMFS.node_ops.getattr,
|
||
setattr: MEMFS.node_ops.setattr,
|
||
lookup: MEMFS.node_ops.lookup,
|
||
mknod: MEMFS.node_ops.mknod,
|
||
rename: MEMFS.node_ops.rename,
|
||
unlink: MEMFS.node_ops.unlink,
|
||
rmdir: MEMFS.node_ops.rmdir,
|
||
readdir: MEMFS.node_ops.readdir,
|
||
symlink: MEMFS.node_ops.symlink
|
||
},
|
||
stream: {
|
||
llseek: MEMFS.stream_ops.llseek
|
||
}
|
||
},
|
||
file: {
|
||
node: {
|
||
getattr: MEMFS.node_ops.getattr,
|
||
setattr: MEMFS.node_ops.setattr
|
||
},
|
||
stream: {
|
||
llseek: MEMFS.stream_ops.llseek,
|
||
read: MEMFS.stream_ops.read,
|
||
write: MEMFS.stream_ops.write,
|
||
allocate: MEMFS.stream_ops.allocate,
|
||
mmap: MEMFS.stream_ops.mmap,
|
||
msync: MEMFS.stream_ops.msync
|
||
}
|
||
},
|
||
link: {
|
||
node: {
|
||
getattr: MEMFS.node_ops.getattr,
|
||
setattr: MEMFS.node_ops.setattr,
|
||
readlink: MEMFS.node_ops.readlink
|
||
},
|
||
stream: {}
|
||
},
|
||
chrdev: {
|
||
node: {
|
||
getattr: MEMFS.node_ops.getattr,
|
||
setattr: MEMFS.node_ops.setattr
|
||
},
|
||
stream: FS.chrdev_stream_ops
|
||
}
|
||
};
|
||
}
|
||
var node = FS.createNode(parent, name, mode, dev);
|
||
if (FS.isDir(node.mode)) {
|
||
node.node_ops = MEMFS.ops_table.dir.node;
|
||
node.stream_ops = MEMFS.ops_table.dir.stream;
|
||
node.contents = {};
|
||
} else if (FS.isFile(node.mode)) {
|
||
node.node_ops = MEMFS.ops_table.file.node;
|
||
node.stream_ops = MEMFS.ops_table.file.stream;
|
||
node.usedBytes = 0;
|
||
node.contents = null;
|
||
} else if (FS.isLink(node.mode)) {
|
||
node.node_ops = MEMFS.ops_table.link.node;
|
||
node.stream_ops = MEMFS.ops_table.link.stream;
|
||
} else if (FS.isChrdev(node.mode)) {
|
||
node.node_ops = MEMFS.ops_table.chrdev.node;
|
||
node.stream_ops = MEMFS.ops_table.chrdev.stream;
|
||
}
|
||
node.timestamp = Date.now();
|
||
if (parent) {
|
||
parent.contents[name] = node;
|
||
parent.timestamp = node.timestamp;
|
||
}
|
||
return node;
|
||
},
|
||
getFileDataAsTypedArray: function (node) {
|
||
if (!node.contents) return new Uint8Array(0);
|
||
if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
|
||
return new Uint8Array(node.contents);
|
||
},
|
||
expandFileStorage: function (node, newCapacity) {
|
||
var prevCapacity = node.contents ? node.contents.length : 0;
|
||
if (prevCapacity >= newCapacity) return;
|
||
var CAPACITY_DOUBLING_MAX = 1024 * 1024;
|
||
newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
|
||
if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
|
||
var oldContents = node.contents;
|
||
node.contents = new Uint8Array(newCapacity);
|
||
if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
|
||
},
|
||
resizeFileStorage: function (node, newSize) {
|
||
if (node.usedBytes == newSize) return;
|
||
if (newSize == 0) {
|
||
node.contents = null;
|
||
node.usedBytes = 0;
|
||
} else {
|
||
var oldContents = node.contents;
|
||
node.contents = new Uint8Array(newSize);
|
||
if (oldContents) {
|
||
node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
|
||
}
|
||
node.usedBytes = newSize;
|
||
}
|
||
},
|
||
node_ops: {
|
||
getattr: function (node) {
|
||
var attr = {};
|
||
attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
|
||
attr.ino = node.id;
|
||
attr.mode = node.mode;
|
||
attr.nlink = 1;
|
||
attr.uid = 0;
|
||
attr.gid = 0;
|
||
attr.rdev = node.rdev;
|
||
if (FS.isDir(node.mode)) {
|
||
attr.size = 4096;
|
||
} else if (FS.isFile(node.mode)) {
|
||
attr.size = node.usedBytes;
|
||
} else if (FS.isLink(node.mode)) {
|
||
attr.size = node.link.length;
|
||
} else {
|
||
attr.size = 0;
|
||
}
|
||
attr.atime = new Date(node.timestamp);
|
||
attr.mtime = new Date(node.timestamp);
|
||
attr.ctime = new Date(node.timestamp);
|
||
attr.blksize = 4096;
|
||
attr.blocks = Math.ceil(attr.size / attr.blksize);
|
||
return attr;
|
||
},
|
||
setattr: function (node, attr) {
|
||
if (attr.mode !== undefined) {
|
||
node.mode = attr.mode;
|
||
}
|
||
if (attr.timestamp !== undefined) {
|
||
node.timestamp = attr.timestamp;
|
||
}
|
||
if (attr.size !== undefined) {
|
||
MEMFS.resizeFileStorage(node, attr.size);
|
||
}
|
||
},
|
||
lookup: function (parent, name) {
|
||
throw FS.genericErrors[44];
|
||
},
|
||
mknod: function (parent, name, mode, dev) {
|
||
return MEMFS.createNode(parent, name, mode, dev);
|
||
},
|
||
rename: function (old_node, new_dir, new_name) {
|
||
if (FS.isDir(old_node.mode)) {
|
||
var new_node;
|
||
try {
|
||
new_node = FS.lookupNode(new_dir, new_name);
|
||
} catch (e) {}
|
||
if (new_node) {
|
||
for (var i in new_node.contents) {
|
||
throw new FS.ErrnoError(55);
|
||
}
|
||
}
|
||
}
|
||
delete old_node.parent.contents[old_node.name];
|
||
old_node.parent.timestamp = Date.now();
|
||
old_node.name = new_name;
|
||
new_dir.contents[new_name] = old_node;
|
||
new_dir.timestamp = old_node.parent.timestamp;
|
||
old_node.parent = new_dir;
|
||
},
|
||
unlink: function (parent, name) {
|
||
delete parent.contents[name];
|
||
parent.timestamp = Date.now();
|
||
},
|
||
rmdir: function (parent, name) {
|
||
var node = FS.lookupNode(parent, name);
|
||
for (var i in node.contents) {
|
||
throw new FS.ErrnoError(55);
|
||
}
|
||
delete parent.contents[name];
|
||
parent.timestamp = Date.now();
|
||
},
|
||
readdir: function (node) {
|
||
var entries = [".", ".."];
|
||
for (var key in node.contents) {
|
||
if (!node.contents.hasOwnProperty(key)) {
|
||
continue;
|
||
}
|
||
entries.push(key);
|
||
}
|
||
return entries;
|
||
},
|
||
symlink: function (parent, newname, oldpath) {
|
||
var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
|
||
node.link = oldpath;
|
||
return node;
|
||
},
|
||
readlink: function (node) {
|
||
if (!FS.isLink(node.mode)) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
return node.link;
|
||
}
|
||
},
|
||
stream_ops: {
|
||
read: function (stream, buffer, offset, length, position) {
|
||
var contents = stream.node.contents;
|
||
if (position >= stream.node.usedBytes) return 0;
|
||
var size = Math.min(stream.node.usedBytes - position, length);
|
||
if (size > 8 && contents.subarray) {
|
||
buffer.set(contents.subarray(position, position + size), offset);
|
||
} else {
|
||
for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
|
||
}
|
||
return size;
|
||
},
|
||
write: function (stream, buffer, offset, length, position, canOwn) {
|
||
if (!length) return 0;
|
||
var node = stream.node;
|
||
node.timestamp = Date.now();
|
||
if (buffer.subarray && (!node.contents || node.contents.subarray)) {
|
||
if (canOwn) {
|
||
node.contents = buffer.subarray(offset, offset + length);
|
||
node.usedBytes = length;
|
||
return length;
|
||
} else if (node.usedBytes === 0 && position === 0) {
|
||
node.contents = buffer.slice(offset, offset + length);
|
||
node.usedBytes = length;
|
||
return length;
|
||
} else if (position + length <= node.usedBytes) {
|
||
node.contents.set(buffer.subarray(offset, offset + length), position);
|
||
return length;
|
||
}
|
||
}
|
||
MEMFS.expandFileStorage(node, position + length);
|
||
if (node.contents.subarray && buffer.subarray) {
|
||
node.contents.set(buffer.subarray(offset, offset + length), position);
|
||
} else {
|
||
for (var i = 0; i < length; i++) {
|
||
node.contents[position + i] = buffer[offset + i];
|
||
}
|
||
}
|
||
node.usedBytes = Math.max(node.usedBytes, position + length);
|
||
return length;
|
||
},
|
||
llseek: function (stream, offset, whence) {
|
||
var position = offset;
|
||
if (whence === 1) {
|
||
position += stream.position;
|
||
} else if (whence === 2) {
|
||
if (FS.isFile(stream.node.mode)) {
|
||
position += stream.node.usedBytes;
|
||
}
|
||
}
|
||
if (position < 0) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
return position;
|
||
},
|
||
allocate: function (stream, offset, length) {
|
||
MEMFS.expandFileStorage(stream.node, offset + length);
|
||
stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
|
||
},
|
||
mmap: function (stream, length, position, prot, flags) {
|
||
if (!FS.isFile(stream.node.mode)) {
|
||
throw new FS.ErrnoError(43);
|
||
}
|
||
var ptr;
|
||
var allocated;
|
||
var contents = stream.node.contents;
|
||
if (!(flags & 2) && contents.buffer === buffer) {
|
||
allocated = false;
|
||
ptr = contents.byteOffset;
|
||
} else {
|
||
if (position > 0 || position + length < contents.length) {
|
||
if (contents.subarray) {
|
||
contents = contents.subarray(position, position + length);
|
||
} else {
|
||
contents = Array.prototype.slice.call(contents, position, position + length);
|
||
}
|
||
}
|
||
allocated = true;
|
||
ptr = mmapAlloc(length);
|
||
if (!ptr) {
|
||
throw new FS.ErrnoError(48);
|
||
}
|
||
HEAP8.set(contents, ptr);
|
||
}
|
||
return {
|
||
ptr: ptr,
|
||
allocated: allocated
|
||
};
|
||
},
|
||
msync: function (stream, buffer, offset, length, mmapFlags) {
|
||
if (!FS.isFile(stream.node.mode)) {
|
||
throw new FS.ErrnoError(43);
|
||
}
|
||
if (mmapFlags & 2) {
|
||
return 0;
|
||
}
|
||
MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
|
||
return 0;
|
||
}
|
||
}
|
||
};
|
||
function asyncLoad(url, onload, onerror, noRunDep) {
|
||
var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
|
||
readAsync(url, arrayBuffer => {
|
||
assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
|
||
onload(new Uint8Array(arrayBuffer));
|
||
if (dep) removeRunDependency();
|
||
}, event => {
|
||
if (onerror) {
|
||
onerror();
|
||
} else {
|
||
throw 'Loading data file "' + url + '" failed.';
|
||
}
|
||
});
|
||
if (dep) addRunDependency();
|
||
}
|
||
var FS = {
|
||
root: null,
|
||
mounts: [],
|
||
devices: {},
|
||
streams: [],
|
||
nextInode: 1,
|
||
nameTable: null,
|
||
currentPath: "/",
|
||
initialized: false,
|
||
ignorePermissions: true,
|
||
ErrnoError: null,
|
||
genericErrors: {},
|
||
filesystems: null,
|
||
syncFSRequests: 0,
|
||
lookupPath: function (path) {
|
||
let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
path = PATH_FS.resolve(FS.cwd(), path);
|
||
if (!path) return {
|
||
path: "",
|
||
node: null
|
||
};
|
||
var defaults = {
|
||
follow_mount: true,
|
||
recurse_count: 0
|
||
};
|
||
opts = Object.assign(defaults, opts);
|
||
if (opts.recurse_count > 8) {
|
||
throw new FS.ErrnoError(32);
|
||
}
|
||
var parts = PATH.normalizeArray(path.split("/").filter(p => !!p), false);
|
||
var current = FS.root;
|
||
var current_path = "/";
|
||
for (var i = 0; i < parts.length; i++) {
|
||
var islast = i === parts.length - 1;
|
||
if (islast && opts.parent) {
|
||
break;
|
||
}
|
||
current = FS.lookupNode(current, parts[i]);
|
||
current_path = PATH.join2(current_path, parts[i]);
|
||
if (FS.isMountpoint(current)) {
|
||
if (!islast || islast && opts.follow_mount) {
|
||
current = current.mounted.root;
|
||
}
|
||
}
|
||
if (!islast || opts.follow) {
|
||
var count = 0;
|
||
while (FS.isLink(current.mode)) {
|
||
var link = FS.readlink(current_path);
|
||
current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
|
||
var lookup = FS.lookupPath(current_path, {
|
||
recurse_count: opts.recurse_count + 1
|
||
});
|
||
current = lookup.node;
|
||
if (count++ > 40) {
|
||
throw new FS.ErrnoError(32);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
path: current_path,
|
||
node: current
|
||
};
|
||
},
|
||
getPath: node => {
|
||
var path;
|
||
while (true) {
|
||
if (FS.isRoot(node)) {
|
||
var mount = node.mount.mountpoint;
|
||
if (!path) return mount;
|
||
return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path;
|
||
}
|
||
path = path ? node.name + "/" + path : node.name;
|
||
node = node.parent;
|
||
}
|
||
},
|
||
hashName: (parentid, name) => {
|
||
var hash = 0;
|
||
for (var i = 0; i < name.length; i++) {
|
||
hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
|
||
}
|
||
return (parentid + hash >>> 0) % FS.nameTable.length;
|
||
},
|
||
hashAddNode: node => {
|
||
var hash = FS.hashName(node.parent.id, node.name);
|
||
node.name_next = FS.nameTable[hash];
|
||
FS.nameTable[hash] = node;
|
||
},
|
||
hashRemoveNode: node => {
|
||
var hash = FS.hashName(node.parent.id, node.name);
|
||
if (FS.nameTable[hash] === node) {
|
||
FS.nameTable[hash] = node.name_next;
|
||
} else {
|
||
var current = FS.nameTable[hash];
|
||
while (current) {
|
||
if (current.name_next === node) {
|
||
current.name_next = node.name_next;
|
||
break;
|
||
}
|
||
current = current.name_next;
|
||
}
|
||
}
|
||
},
|
||
lookupNode: (parent, name) => {
|
||
var errCode = FS.mayLookup(parent);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode, parent);
|
||
}
|
||
var hash = FS.hashName(parent.id, name);
|
||
for (var node = FS.nameTable[hash]; node; node = node.name_next) {
|
||
var nodeName = node.name;
|
||
if (node.parent.id === parent.id && nodeName === name) {
|
||
return node;
|
||
}
|
||
}
|
||
return FS.lookup(parent, name);
|
||
},
|
||
createNode: (parent, name, mode, rdev) => {
|
||
var node = new FS.FSNode(parent, name, mode, rdev);
|
||
FS.hashAddNode(node);
|
||
return node;
|
||
},
|
||
destroyNode: node => {
|
||
FS.hashRemoveNode(node);
|
||
},
|
||
isRoot: node => {
|
||
return node === node.parent;
|
||
},
|
||
isMountpoint: node => {
|
||
return !!node.mounted;
|
||
},
|
||
isFile: mode => {
|
||
return (mode & 61440) === 32768;
|
||
},
|
||
isDir: mode => {
|
||
return (mode & 61440) === 16384;
|
||
},
|
||
isLink: mode => {
|
||
return (mode & 61440) === 40960;
|
||
},
|
||
isChrdev: mode => {
|
||
return (mode & 61440) === 8192;
|
||
},
|
||
isBlkdev: mode => {
|
||
return (mode & 61440) === 24576;
|
||
},
|
||
isFIFO: mode => {
|
||
return (mode & 61440) === 4096;
|
||
},
|
||
isSocket: mode => {
|
||
return (mode & 49152) === 49152;
|
||
},
|
||
flagModes: {
|
||
"r": 0,
|
||
"r+": 2,
|
||
"w": 577,
|
||
"w+": 578,
|
||
"a": 1089,
|
||
"a+": 1090
|
||
},
|
||
modeStringToFlags: str => {
|
||
var flags = FS.flagModes[str];
|
||
if (typeof flags == "undefined") {
|
||
throw new Error("Unknown file open mode: " + str);
|
||
}
|
||
return flags;
|
||
},
|
||
flagsToPermissionString: flag => {
|
||
var perms = ["r", "w", "rw"][flag & 3];
|
||
if (flag & 512) {
|
||
perms += "w";
|
||
}
|
||
return perms;
|
||
},
|
||
nodePermissions: (node, perms) => {
|
||
if (FS.ignorePermissions) {
|
||
return 0;
|
||
}
|
||
if (perms.includes("r") && !(node.mode & 292)) {
|
||
return 2;
|
||
} else if (perms.includes("w") && !(node.mode & 146)) {
|
||
return 2;
|
||
} else if (perms.includes("x") && !(node.mode & 73)) {
|
||
return 2;
|
||
}
|
||
return 0;
|
||
},
|
||
mayLookup: dir => {
|
||
var errCode = FS.nodePermissions(dir, "x");
|
||
if (errCode) return errCode;
|
||
if (!dir.node_ops.lookup) return 2;
|
||
return 0;
|
||
},
|
||
mayCreate: (dir, name) => {
|
||
try {
|
||
var node = FS.lookupNode(dir, name);
|
||
return 20;
|
||
} catch (e) {}
|
||
return FS.nodePermissions(dir, "wx");
|
||
},
|
||
mayDelete: (dir, name, isdir) => {
|
||
var node;
|
||
try {
|
||
node = FS.lookupNode(dir, name);
|
||
} catch (e) {
|
||
return e.errno;
|
||
}
|
||
var errCode = FS.nodePermissions(dir, "wx");
|
||
if (errCode) {
|
||
return errCode;
|
||
}
|
||
if (isdir) {
|
||
if (!FS.isDir(node.mode)) {
|
||
return 54;
|
||
}
|
||
if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
|
||
return 10;
|
||
}
|
||
} else {
|
||
if (FS.isDir(node.mode)) {
|
||
return 31;
|
||
}
|
||
}
|
||
return 0;
|
||
},
|
||
mayOpen: (node, flags) => {
|
||
if (!node) {
|
||
return 44;
|
||
}
|
||
if (FS.isLink(node.mode)) {
|
||
return 32;
|
||
} else if (FS.isDir(node.mode)) {
|
||
if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
|
||
return 31;
|
||
}
|
||
}
|
||
return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
|
||
},
|
||
MAX_OPEN_FDS: 4096,
|
||
nextfd: function () {
|
||
let fd_start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
||
let fd_end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : FS.MAX_OPEN_FDS;
|
||
for (var fd = fd_start; fd <= fd_end; fd++) {
|
||
if (!FS.streams[fd]) {
|
||
return fd;
|
||
}
|
||
}
|
||
throw new FS.ErrnoError(33);
|
||
},
|
||
getStream: fd => FS.streams[fd],
|
||
createStream: (stream, fd_start, fd_end) => {
|
||
if (!FS.FSStream) {
|
||
FS.FSStream = function () {
|
||
this.shared = {};
|
||
};
|
||
FS.FSStream.prototype = {};
|
||
Object.defineProperties(FS.FSStream.prototype, {
|
||
object: {
|
||
get: function () {
|
||
return this.node;
|
||
},
|
||
set: function (val) {
|
||
this.node = val;
|
||
}
|
||
},
|
||
isRead: {
|
||
get: function () {
|
||
return (this.flags & 2097155) !== 1;
|
||
}
|
||
},
|
||
isWrite: {
|
||
get: function () {
|
||
return (this.flags & 2097155) !== 0;
|
||
}
|
||
},
|
||
isAppend: {
|
||
get: function () {
|
||
return this.flags & 1024;
|
||
}
|
||
},
|
||
flags: {
|
||
get: function () {
|
||
return this.shared.flags;
|
||
},
|
||
set: function (val) {
|
||
this.shared.flags = val;
|
||
}
|
||
},
|
||
position: {
|
||
get: function () {
|
||
return this.shared.position;
|
||
},
|
||
set: function (val) {
|
||
this.shared.position = val;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
stream = Object.assign(new FS.FSStream(), stream);
|
||
var fd = FS.nextfd(fd_start, fd_end);
|
||
stream.fd = fd;
|
||
FS.streams[fd] = stream;
|
||
return stream;
|
||
},
|
||
closeStream: fd => {
|
||
FS.streams[fd] = null;
|
||
},
|
||
chrdev_stream_ops: {
|
||
open: stream => {
|
||
var device = FS.getDevice(stream.node.rdev);
|
||
stream.stream_ops = device.stream_ops;
|
||
if (stream.stream_ops.open) {
|
||
stream.stream_ops.open(stream);
|
||
}
|
||
},
|
||
llseek: () => {
|
||
throw new FS.ErrnoError(70);
|
||
}
|
||
},
|
||
major: dev => dev >> 8,
|
||
minor: dev => dev & 255,
|
||
makedev: (ma, mi) => ma << 8 | mi,
|
||
registerDevice: (dev, ops) => {
|
||
FS.devices[dev] = {
|
||
stream_ops: ops
|
||
};
|
||
},
|
||
getDevice: dev => FS.devices[dev],
|
||
getMounts: mount => {
|
||
var mounts = [];
|
||
var check = [mount];
|
||
while (check.length) {
|
||
var m = check.pop();
|
||
mounts.push(m);
|
||
check.push.apply(check, m.mounts);
|
||
}
|
||
return mounts;
|
||
},
|
||
syncfs: (populate, callback) => {
|
||
if (typeof populate == "function") {
|
||
callback = populate;
|
||
populate = false;
|
||
}
|
||
FS.syncFSRequests++;
|
||
if (FS.syncFSRequests > 1) {
|
||
err("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work");
|
||
}
|
||
var mounts = FS.getMounts(FS.root.mount);
|
||
var completed = 0;
|
||
function doCallback(errCode) {
|
||
FS.syncFSRequests--;
|
||
return callback(errCode);
|
||
}
|
||
function done(errCode) {
|
||
if (errCode) {
|
||
if (!done.errored) {
|
||
done.errored = true;
|
||
return doCallback(errCode);
|
||
}
|
||
return;
|
||
}
|
||
if (++completed >= mounts.length) {
|
||
doCallback(null);
|
||
}
|
||
}
|
||
mounts.forEach(mount => {
|
||
if (!mount.type.syncfs) {
|
||
return done(null);
|
||
}
|
||
mount.type.syncfs(mount, populate, done);
|
||
});
|
||
},
|
||
mount: (type, opts, mountpoint) => {
|
||
var root = mountpoint === "/";
|
||
var pseudo = !mountpoint;
|
||
var node;
|
||
if (root && FS.root) {
|
||
throw new FS.ErrnoError(10);
|
||
} else if (!root && !pseudo) {
|
||
var lookup = FS.lookupPath(mountpoint, {
|
||
follow_mount: false
|
||
});
|
||
mountpoint = lookup.path;
|
||
node = lookup.node;
|
||
if (FS.isMountpoint(node)) {
|
||
throw new FS.ErrnoError(10);
|
||
}
|
||
if (!FS.isDir(node.mode)) {
|
||
throw new FS.ErrnoError(54);
|
||
}
|
||
}
|
||
var mount = {
|
||
type: type,
|
||
opts: opts,
|
||
mountpoint: mountpoint,
|
||
mounts: []
|
||
};
|
||
var mountRoot = type.mount(mount);
|
||
mountRoot.mount = mount;
|
||
mount.root = mountRoot;
|
||
if (root) {
|
||
FS.root = mountRoot;
|
||
} else if (node) {
|
||
node.mounted = mount;
|
||
if (node.mount) {
|
||
node.mount.mounts.push(mount);
|
||
}
|
||
}
|
||
return mountRoot;
|
||
},
|
||
unmount: mountpoint => {
|
||
var lookup = FS.lookupPath(mountpoint, {
|
||
follow_mount: false
|
||
});
|
||
if (!FS.isMountpoint(lookup.node)) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
var node = lookup.node;
|
||
var mount = node.mounted;
|
||
var mounts = FS.getMounts(mount);
|
||
Object.keys(FS.nameTable).forEach(hash => {
|
||
var current = FS.nameTable[hash];
|
||
while (current) {
|
||
var next = current.name_next;
|
||
if (mounts.includes(current.mount)) {
|
||
FS.destroyNode(current);
|
||
}
|
||
current = next;
|
||
}
|
||
});
|
||
node.mounted = null;
|
||
var idx = node.mount.mounts.indexOf(mount);
|
||
node.mount.mounts.splice(idx, 1);
|
||
},
|
||
lookup: (parent, name) => {
|
||
return parent.node_ops.lookup(parent, name);
|
||
},
|
||
mknod: (path, mode, dev) => {
|
||
var lookup = FS.lookupPath(path, {
|
||
parent: true
|
||
});
|
||
var parent = lookup.node;
|
||
var name = PATH.basename(path);
|
||
if (!name || name === "." || name === "..") {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
var errCode = FS.mayCreate(parent, name);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
if (!parent.node_ops.mknod) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
return parent.node_ops.mknod(parent, name, mode, dev);
|
||
},
|
||
create: (path, mode) => {
|
||
mode = mode !== undefined ? mode : 438;
|
||
mode &= 4095;
|
||
mode |= 32768;
|
||
return FS.mknod(path, mode, 0);
|
||
},
|
||
mkdir: (path, mode) => {
|
||
mode = mode !== undefined ? mode : 511;
|
||
mode &= 511 | 512;
|
||
mode |= 16384;
|
||
return FS.mknod(path, mode, 0);
|
||
},
|
||
mkdirTree: (path, mode) => {
|
||
var dirs = path.split("/");
|
||
var d = "";
|
||
for (var i = 0; i < dirs.length; ++i) {
|
||
if (!dirs[i]) continue;
|
||
d += "/" + dirs[i];
|
||
try {
|
||
FS.mkdir(d, mode);
|
||
} catch (e) {
|
||
if (e.errno != 20) throw e;
|
||
}
|
||
}
|
||
},
|
||
mkdev: (path, mode, dev) => {
|
||
if (typeof dev == "undefined") {
|
||
dev = mode;
|
||
mode = 438;
|
||
}
|
||
mode |= 8192;
|
||
return FS.mknod(path, mode, dev);
|
||
},
|
||
symlink: (oldpath, newpath) => {
|
||
if (!PATH_FS.resolve(oldpath)) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
var lookup = FS.lookupPath(newpath, {
|
||
parent: true
|
||
});
|
||
var parent = lookup.node;
|
||
if (!parent) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
var newname = PATH.basename(newpath);
|
||
var errCode = FS.mayCreate(parent, newname);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
if (!parent.node_ops.symlink) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
return parent.node_ops.symlink(parent, newname, oldpath);
|
||
},
|
||
rename: (old_path, new_path) => {
|
||
var old_dirname = PATH.dirname(old_path);
|
||
var new_dirname = PATH.dirname(new_path);
|
||
var old_name = PATH.basename(old_path);
|
||
var new_name = PATH.basename(new_path);
|
||
var lookup, old_dir, new_dir;
|
||
lookup = FS.lookupPath(old_path, {
|
||
parent: true
|
||
});
|
||
old_dir = lookup.node;
|
||
lookup = FS.lookupPath(new_path, {
|
||
parent: true
|
||
});
|
||
new_dir = lookup.node;
|
||
if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
|
||
if (old_dir.mount !== new_dir.mount) {
|
||
throw new FS.ErrnoError(75);
|
||
}
|
||
var old_node = FS.lookupNode(old_dir, old_name);
|
||
var relative = PATH_FS.relative(old_path, new_dirname);
|
||
if (relative.charAt(0) !== ".") {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
relative = PATH_FS.relative(new_path, old_dirname);
|
||
if (relative.charAt(0) !== ".") {
|
||
throw new FS.ErrnoError(55);
|
||
}
|
||
var new_node;
|
||
try {
|
||
new_node = FS.lookupNode(new_dir, new_name);
|
||
} catch (e) {}
|
||
if (old_node === new_node) {
|
||
return;
|
||
}
|
||
var isdir = FS.isDir(old_node.mode);
|
||
var errCode = FS.mayDelete(old_dir, old_name, isdir);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
if (!old_dir.node_ops.rename) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
|
||
throw new FS.ErrnoError(10);
|
||
}
|
||
if (new_dir !== old_dir) {
|
||
errCode = FS.nodePermissions(old_dir, "w");
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
}
|
||
FS.hashRemoveNode(old_node);
|
||
try {
|
||
old_dir.node_ops.rename(old_node, new_dir, new_name);
|
||
} catch (e) {
|
||
throw e;
|
||
} finally {
|
||
FS.hashAddNode(old_node);
|
||
}
|
||
},
|
||
rmdir: path => {
|
||
var lookup = FS.lookupPath(path, {
|
||
parent: true
|
||
});
|
||
var parent = lookup.node;
|
||
var name = PATH.basename(path);
|
||
var node = FS.lookupNode(parent, name);
|
||
var errCode = FS.mayDelete(parent, name, true);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
if (!parent.node_ops.rmdir) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
if (FS.isMountpoint(node)) {
|
||
throw new FS.ErrnoError(10);
|
||
}
|
||
parent.node_ops.rmdir(parent, name);
|
||
FS.destroyNode(node);
|
||
},
|
||
readdir: path => {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: true
|
||
});
|
||
var node = lookup.node;
|
||
if (!node.node_ops.readdir) {
|
||
throw new FS.ErrnoError(54);
|
||
}
|
||
return node.node_ops.readdir(node);
|
||
},
|
||
unlink: path => {
|
||
var lookup = FS.lookupPath(path, {
|
||
parent: true
|
||
});
|
||
var parent = lookup.node;
|
||
if (!parent) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
var name = PATH.basename(path);
|
||
var node = FS.lookupNode(parent, name);
|
||
var errCode = FS.mayDelete(parent, name, false);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
if (!parent.node_ops.unlink) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
if (FS.isMountpoint(node)) {
|
||
throw new FS.ErrnoError(10);
|
||
}
|
||
parent.node_ops.unlink(parent, name);
|
||
FS.destroyNode(node);
|
||
},
|
||
readlink: path => {
|
||
var lookup = FS.lookupPath(path);
|
||
var link = lookup.node;
|
||
if (!link) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
if (!link.node_ops.readlink) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
|
||
},
|
||
stat: (path, dontFollow) => {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: !dontFollow
|
||
});
|
||
var node = lookup.node;
|
||
if (!node) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
if (!node.node_ops.getattr) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
return node.node_ops.getattr(node);
|
||
},
|
||
lstat: path => {
|
||
return FS.stat(path, true);
|
||
},
|
||
chmod: (path, mode, dontFollow) => {
|
||
var node;
|
||
if (typeof path == "string") {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: !dontFollow
|
||
});
|
||
node = lookup.node;
|
||
} else {
|
||
node = path;
|
||
}
|
||
if (!node.node_ops.setattr) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
node.node_ops.setattr(node, {
|
||
mode: mode & 4095 | node.mode & ~4095,
|
||
timestamp: Date.now()
|
||
});
|
||
},
|
||
lchmod: (path, mode) => {
|
||
FS.chmod(path, mode, true);
|
||
},
|
||
fchmod: (fd, mode) => {
|
||
var stream = FS.getStream(fd);
|
||
if (!stream) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
FS.chmod(stream.node, mode);
|
||
},
|
||
chown: (path, uid, gid, dontFollow) => {
|
||
var node;
|
||
if (typeof path == "string") {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: !dontFollow
|
||
});
|
||
node = lookup.node;
|
||
} else {
|
||
node = path;
|
||
}
|
||
if (!node.node_ops.setattr) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
node.node_ops.setattr(node, {
|
||
timestamp: Date.now()
|
||
});
|
||
},
|
||
lchown: (path, uid, gid) => {
|
||
FS.chown(path, uid, gid, true);
|
||
},
|
||
fchown: (fd, uid, gid) => {
|
||
var stream = FS.getStream(fd);
|
||
if (!stream) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
FS.chown(stream.node, uid, gid);
|
||
},
|
||
truncate: (path, len) => {
|
||
if (len < 0) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
var node;
|
||
if (typeof path == "string") {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: true
|
||
});
|
||
node = lookup.node;
|
||
} else {
|
||
node = path;
|
||
}
|
||
if (!node.node_ops.setattr) {
|
||
throw new FS.ErrnoError(63);
|
||
}
|
||
if (FS.isDir(node.mode)) {
|
||
throw new FS.ErrnoError(31);
|
||
}
|
||
if (!FS.isFile(node.mode)) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
var errCode = FS.nodePermissions(node, "w");
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
node.node_ops.setattr(node, {
|
||
size: len,
|
||
timestamp: Date.now()
|
||
});
|
||
},
|
||
ftruncate: (fd, len) => {
|
||
var stream = FS.getStream(fd);
|
||
if (!stream) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if ((stream.flags & 2097155) === 0) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
FS.truncate(stream.node, len);
|
||
},
|
||
utime: (path, atime, mtime) => {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: true
|
||
});
|
||
var node = lookup.node;
|
||
node.node_ops.setattr(node, {
|
||
timestamp: Math.max(atime, mtime)
|
||
});
|
||
},
|
||
open: (path, flags, mode) => {
|
||
if (path === "") {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
flags = typeof flags == "string" ? FS.modeStringToFlags(flags) : flags;
|
||
mode = typeof mode == "undefined" ? 438 : mode;
|
||
if (flags & 64) {
|
||
mode = mode & 4095 | 32768;
|
||
} else {
|
||
mode = 0;
|
||
}
|
||
var node;
|
||
if (typeof path == "object") {
|
||
node = path;
|
||
} else {
|
||
path = PATH.normalize(path);
|
||
try {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: !(flags & 131072)
|
||
});
|
||
node = lookup.node;
|
||
} catch (e) {}
|
||
}
|
||
var created = false;
|
||
if (flags & 64) {
|
||
if (node) {
|
||
if (flags & 128) {
|
||
throw new FS.ErrnoError(20);
|
||
}
|
||
} else {
|
||
node = FS.mknod(path, mode, 0);
|
||
created = true;
|
||
}
|
||
}
|
||
if (!node) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
if (FS.isChrdev(node.mode)) {
|
||
flags &= ~512;
|
||
}
|
||
if (flags & 65536 && !FS.isDir(node.mode)) {
|
||
throw new FS.ErrnoError(54);
|
||
}
|
||
if (!created) {
|
||
var errCode = FS.mayOpen(node, flags);
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
}
|
||
if (flags & 512 && !created) {
|
||
FS.truncate(node, 0);
|
||
}
|
||
flags &= ~(128 | 512 | 131072);
|
||
var stream = FS.createStream({
|
||
node: node,
|
||
path: FS.getPath(node),
|
||
flags: flags,
|
||
seekable: true,
|
||
position: 0,
|
||
stream_ops: node.stream_ops,
|
||
ungotten: [],
|
||
error: false
|
||
});
|
||
if (stream.stream_ops.open) {
|
||
stream.stream_ops.open(stream);
|
||
}
|
||
if (Module["logReadFiles"] && !(flags & 1)) {
|
||
if (!FS.readFiles) FS.readFiles = {};
|
||
if (!(path in FS.readFiles)) {
|
||
FS.readFiles[path] = 1;
|
||
}
|
||
}
|
||
return stream;
|
||
},
|
||
close: stream => {
|
||
if (FS.isClosed(stream)) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if (stream.getdents) stream.getdents = null;
|
||
try {
|
||
if (stream.stream_ops.close) {
|
||
stream.stream_ops.close(stream);
|
||
}
|
||
} catch (e) {
|
||
throw e;
|
||
} finally {
|
||
FS.closeStream(stream.fd);
|
||
}
|
||
stream.fd = null;
|
||
},
|
||
isClosed: stream => {
|
||
return stream.fd === null;
|
||
},
|
||
llseek: (stream, offset, whence) => {
|
||
if (FS.isClosed(stream)) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if (!stream.seekable || !stream.stream_ops.llseek) {
|
||
throw new FS.ErrnoError(70);
|
||
}
|
||
if (whence != 0 && whence != 1 && whence != 2) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
stream.position = stream.stream_ops.llseek(stream, offset, whence);
|
||
stream.ungotten = [];
|
||
return stream.position;
|
||
},
|
||
read: (stream, buffer, offset, length, position) => {
|
||
if (length < 0 || position < 0) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
if (FS.isClosed(stream)) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if ((stream.flags & 2097155) === 1) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if (FS.isDir(stream.node.mode)) {
|
||
throw new FS.ErrnoError(31);
|
||
}
|
||
if (!stream.stream_ops.read) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
var seeking = typeof position != "undefined";
|
||
if (!seeking) {
|
||
position = stream.position;
|
||
} else if (!stream.seekable) {
|
||
throw new FS.ErrnoError(70);
|
||
}
|
||
var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
|
||
if (!seeking) stream.position += bytesRead;
|
||
return bytesRead;
|
||
},
|
||
write: (stream, buffer, offset, length, position, canOwn) => {
|
||
if (length < 0 || position < 0) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
if (FS.isClosed(stream)) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if ((stream.flags & 2097155) === 0) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if (FS.isDir(stream.node.mode)) {
|
||
throw new FS.ErrnoError(31);
|
||
}
|
||
if (!stream.stream_ops.write) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
if (stream.seekable && stream.flags & 1024) {
|
||
FS.llseek(stream, 0, 2);
|
||
}
|
||
var seeking = typeof position != "undefined";
|
||
if (!seeking) {
|
||
position = stream.position;
|
||
} else if (!stream.seekable) {
|
||
throw new FS.ErrnoError(70);
|
||
}
|
||
var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
|
||
if (!seeking) stream.position += bytesWritten;
|
||
return bytesWritten;
|
||
},
|
||
allocate: (stream, offset, length) => {
|
||
if (FS.isClosed(stream)) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if (offset < 0 || length <= 0) {
|
||
throw new FS.ErrnoError(28);
|
||
}
|
||
if ((stream.flags & 2097155) === 0) {
|
||
throw new FS.ErrnoError(8);
|
||
}
|
||
if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
|
||
throw new FS.ErrnoError(43);
|
||
}
|
||
if (!stream.stream_ops.allocate) {
|
||
throw new FS.ErrnoError(138);
|
||
}
|
||
stream.stream_ops.allocate(stream, offset, length);
|
||
},
|
||
mmap: (stream, length, position, prot, flags) => {
|
||
if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
|
||
throw new FS.ErrnoError(2);
|
||
}
|
||
if ((stream.flags & 2097155) === 1) {
|
||
throw new FS.ErrnoError(2);
|
||
}
|
||
if (!stream.stream_ops.mmap) {
|
||
throw new FS.ErrnoError(43);
|
||
}
|
||
return stream.stream_ops.mmap(stream, length, position, prot, flags);
|
||
},
|
||
msync: (stream, buffer, offset, length, mmapFlags) => {
|
||
if (!stream || !stream.stream_ops.msync) {
|
||
return 0;
|
||
}
|
||
return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
|
||
},
|
||
munmap: stream => 0,
|
||
ioctl: (stream, cmd, arg) => {
|
||
if (!stream.stream_ops.ioctl) {
|
||
throw new FS.ErrnoError(59);
|
||
}
|
||
return stream.stream_ops.ioctl(stream, cmd, arg);
|
||
},
|
||
readFile: function (path) {
|
||
let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
opts.flags = opts.flags || 0;
|
||
opts.encoding = opts.encoding || "binary";
|
||
if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
|
||
throw new Error('Invalid encoding type "' + opts.encoding + '"');
|
||
}
|
||
var ret;
|
||
var stream = FS.open(path, opts.flags);
|
||
var stat = FS.stat(path);
|
||
var length = stat.size;
|
||
var buf = new Uint8Array(length);
|
||
FS.read(stream, buf, 0, length, 0);
|
||
if (opts.encoding === "utf8") {
|
||
ret = UTF8ArrayToString(buf, 0);
|
||
} else if (opts.encoding === "binary") {
|
||
ret = buf;
|
||
}
|
||
FS.close(stream);
|
||
return ret;
|
||
},
|
||
writeFile: function (path, data) {
|
||
let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
||
opts.flags = opts.flags || 577;
|
||
var stream = FS.open(path, opts.flags, opts.mode);
|
||
if (typeof data == "string") {
|
||
var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
|
||
var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
|
||
FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
|
||
} else if (ArrayBuffer.isView(data)) {
|
||
FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
|
||
} else {
|
||
throw new Error("Unsupported data type");
|
||
}
|
||
FS.close(stream);
|
||
},
|
||
cwd: () => FS.currentPath,
|
||
chdir: path => {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: true
|
||
});
|
||
if (lookup.node === null) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
if (!FS.isDir(lookup.node.mode)) {
|
||
throw new FS.ErrnoError(54);
|
||
}
|
||
var errCode = FS.nodePermissions(lookup.node, "x");
|
||
if (errCode) {
|
||
throw new FS.ErrnoError(errCode);
|
||
}
|
||
FS.currentPath = lookup.path;
|
||
},
|
||
createDefaultDirectories: () => {
|
||
FS.mkdir("/tmp");
|
||
FS.mkdir("/home");
|
||
FS.mkdir("/home/web_user");
|
||
},
|
||
createDefaultDevices: () => {
|
||
FS.mkdir("/dev");
|
||
FS.registerDevice(FS.makedev(1, 3), {
|
||
read: () => 0,
|
||
write: (stream, buffer, offset, length, pos) => length
|
||
});
|
||
FS.mkdev("/dev/null", FS.makedev(1, 3));
|
||
TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
|
||
TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
|
||
FS.mkdev("/dev/tty", FS.makedev(5, 0));
|
||
FS.mkdev("/dev/tty1", FS.makedev(6, 0));
|
||
var random_device = getRandomDevice();
|
||
FS.createDevice("/dev", "random", random_device);
|
||
FS.createDevice("/dev", "urandom", random_device);
|
||
FS.mkdir("/dev/shm");
|
||
FS.mkdir("/dev/shm/tmp");
|
||
},
|
||
createSpecialDirectories: () => {
|
||
FS.mkdir("/proc");
|
||
var proc_self = FS.mkdir("/proc/self");
|
||
FS.mkdir("/proc/self/fd");
|
||
FS.mount({
|
||
mount: () => {
|
||
var node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
|
||
node.node_ops = {
|
||
lookup: (parent, name) => {
|
||
var fd = +name;
|
||
var stream = FS.getStream(fd);
|
||
if (!stream) throw new FS.ErrnoError(8);
|
||
var ret = {
|
||
parent: null,
|
||
mount: {
|
||
mountpoint: "fake"
|
||
},
|
||
node_ops: {
|
||
readlink: () => stream.path
|
||
}
|
||
};
|
||
ret.parent = ret;
|
||
return ret;
|
||
}
|
||
};
|
||
return node;
|
||
}
|
||
}, {}, "/proc/self/fd");
|
||
},
|
||
createStandardStreams: () => {
|
||
if (Module["stdin"]) {
|
||
FS.createDevice("/dev", "stdin", Module["stdin"]);
|
||
} else {
|
||
FS.symlink("/dev/tty", "/dev/stdin");
|
||
}
|
||
if (Module["stdout"]) {
|
||
FS.createDevice("/dev", "stdout", null, Module["stdout"]);
|
||
} else {
|
||
FS.symlink("/dev/tty", "/dev/stdout");
|
||
}
|
||
if (Module["stderr"]) {
|
||
FS.createDevice("/dev", "stderr", null, Module["stderr"]);
|
||
} else {
|
||
FS.symlink("/dev/tty1", "/dev/stderr");
|
||
}
|
||
FS.open("/dev/stdin", 0);
|
||
FS.open("/dev/stdout", 1);
|
||
FS.open("/dev/stderr", 1);
|
||
},
|
||
ensureErrnoError: () => {
|
||
if (FS.ErrnoError) return;
|
||
FS.ErrnoError = function ErrnoError(errno, node) {
|
||
this.node = node;
|
||
this.setErrno = function (errno) {
|
||
this.errno = errno;
|
||
};
|
||
this.setErrno(errno);
|
||
this.message = "FS error";
|
||
};
|
||
FS.ErrnoError.prototype = new Error();
|
||
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
|
||
[44].forEach(code => {
|
||
FS.genericErrors[code] = new FS.ErrnoError(code);
|
||
FS.genericErrors[code].stack = "<generic error, no stack>";
|
||
});
|
||
},
|
||
staticInit: () => {
|
||
FS.ensureErrnoError();
|
||
FS.nameTable = new Array(4096);
|
||
FS.mount(MEMFS, {}, "/");
|
||
FS.createDefaultDirectories();
|
||
FS.createDefaultDevices();
|
||
FS.createSpecialDirectories();
|
||
FS.filesystems = {
|
||
"MEMFS": MEMFS
|
||
};
|
||
},
|
||
init: (input, output, error) => {
|
||
FS.init.initialized = true;
|
||
FS.ensureErrnoError();
|
||
Module["stdin"] = input || Module["stdin"];
|
||
Module["stdout"] = output || Module["stdout"];
|
||
Module["stderr"] = error || Module["stderr"];
|
||
FS.createStandardStreams();
|
||
},
|
||
quit: () => {
|
||
FS.init.initialized = false;
|
||
for (var i = 0; i < FS.streams.length; i++) {
|
||
var stream = FS.streams[i];
|
||
if (!stream) {
|
||
continue;
|
||
}
|
||
FS.close(stream);
|
||
}
|
||
},
|
||
getMode: (canRead, canWrite) => {
|
||
var mode = 0;
|
||
if (canRead) mode |= 292 | 73;
|
||
if (canWrite) mode |= 146;
|
||
return mode;
|
||
},
|
||
findObject: (path, dontResolveLastLink) => {
|
||
var ret = FS.analyzePath(path, dontResolveLastLink);
|
||
if (!ret.exists) {
|
||
return null;
|
||
}
|
||
return ret.object;
|
||
},
|
||
analyzePath: (path, dontResolveLastLink) => {
|
||
try {
|
||
var lookup = FS.lookupPath(path, {
|
||
follow: !dontResolveLastLink
|
||
});
|
||
path = lookup.path;
|
||
} catch (e) {}
|
||
var ret = {
|
||
isRoot: false,
|
||
exists: false,
|
||
error: 0,
|
||
name: null,
|
||
path: null,
|
||
object: null,
|
||
parentExists: false,
|
||
parentPath: null,
|
||
parentObject: null
|
||
};
|
||
try {
|
||
var lookup = FS.lookupPath(path, {
|
||
parent: true
|
||
});
|
||
ret.parentExists = true;
|
||
ret.parentPath = lookup.path;
|
||
ret.parentObject = lookup.node;
|
||
ret.name = PATH.basename(path);
|
||
lookup = FS.lookupPath(path, {
|
||
follow: !dontResolveLastLink
|
||
});
|
||
ret.exists = true;
|
||
ret.path = lookup.path;
|
||
ret.object = lookup.node;
|
||
ret.name = lookup.node.name;
|
||
ret.isRoot = lookup.path === "/";
|
||
} catch (e) {
|
||
ret.error = e.errno;
|
||
}
|
||
return ret;
|
||
},
|
||
createPath: (parent, path, canRead, canWrite) => {
|
||
parent = typeof parent == "string" ? parent : FS.getPath(parent);
|
||
var parts = path.split("/").reverse();
|
||
while (parts.length) {
|
||
var part = parts.pop();
|
||
if (!part) continue;
|
||
var current = PATH.join2(parent, part);
|
||
try {
|
||
FS.mkdir(current);
|
||
} catch (e) {}
|
||
parent = current;
|
||
}
|
||
return current;
|
||
},
|
||
createFile: (parent, name, properties, canRead, canWrite) => {
|
||
var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
|
||
var mode = FS.getMode(canRead, canWrite);
|
||
return FS.create(path, mode);
|
||
},
|
||
createDataFile: (parent, name, data, canRead, canWrite, canOwn) => {
|
||
var path = name;
|
||
if (parent) {
|
||
parent = typeof parent == "string" ? parent : FS.getPath(parent);
|
||
path = name ? PATH.join2(parent, name) : parent;
|
||
}
|
||
var mode = FS.getMode(canRead, canWrite);
|
||
var node = FS.create(path, mode);
|
||
if (data) {
|
||
if (typeof data == "string") {
|
||
var arr = new Array(data.length);
|
||
for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
|
||
data = arr;
|
||
}
|
||
FS.chmod(node, mode | 146);
|
||
var stream = FS.open(node, 577);
|
||
FS.write(stream, data, 0, data.length, 0, canOwn);
|
||
FS.close(stream);
|
||
FS.chmod(node, mode);
|
||
}
|
||
return node;
|
||
},
|
||
createDevice: (parent, name, input, output) => {
|
||
var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
|
||
var mode = FS.getMode(!!input, !!output);
|
||
if (!FS.createDevice.major) FS.createDevice.major = 64;
|
||
var dev = FS.makedev(FS.createDevice.major++, 0);
|
||
FS.registerDevice(dev, {
|
||
open: stream => {
|
||
stream.seekable = false;
|
||
},
|
||
close: stream => {
|
||
if (output && output.buffer && output.buffer.length) {
|
||
output(10);
|
||
}
|
||
},
|
||
read: (stream, buffer, offset, length, pos) => {
|
||
var bytesRead = 0;
|
||
for (var i = 0; i < length; i++) {
|
||
var result;
|
||
try {
|
||
result = input();
|
||
} catch (e) {
|
||
throw new FS.ErrnoError(29);
|
||
}
|
||
if (result === undefined && bytesRead === 0) {
|
||
throw new FS.ErrnoError(6);
|
||
}
|
||
if (result === null || result === undefined) break;
|
||
bytesRead++;
|
||
buffer[offset + i] = result;
|
||
}
|
||
if (bytesRead) {
|
||
stream.node.timestamp = Date.now();
|
||
}
|
||
return bytesRead;
|
||
},
|
||
write: (stream, buffer, offset, length, pos) => {
|
||
for (var i = 0; i < length; i++) {
|
||
try {
|
||
output(buffer[offset + i]);
|
||
} catch (e) {
|
||
throw new FS.ErrnoError(29);
|
||
}
|
||
}
|
||
if (length) {
|
||
stream.node.timestamp = Date.now();
|
||
}
|
||
return i;
|
||
}
|
||
});
|
||
return FS.mkdev(path, mode, dev);
|
||
},
|
||
forceLoadFile: obj => {
|
||
if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
|
||
if (typeof XMLHttpRequest != "undefined") {
|
||
throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
|
||
} else if (read_) {
|
||
try {
|
||
obj.contents = intArrayFromString(read_(obj.url), true);
|
||
obj.usedBytes = obj.contents.length;
|
||
} catch (e) {
|
||
throw new FS.ErrnoError(29);
|
||
}
|
||
} else {
|
||
throw new Error("Cannot load without read() or XMLHttpRequest.");
|
||
}
|
||
},
|
||
createLazyFile: (parent, name, url, canRead, canWrite) => {
|
||
function LazyUint8Array() {
|
||
this.lengthKnown = false;
|
||
this.chunks = [];
|
||
}
|
||
LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
|
||
if (idx > this.length - 1 || idx < 0) {
|
||
return undefined;
|
||
}
|
||
var chunkOffset = idx % this.chunkSize;
|
||
var chunkNum = idx / this.chunkSize | 0;
|
||
return this.getter(chunkNum)[chunkOffset];
|
||
};
|
||
LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
|
||
this.getter = getter;
|
||
};
|
||
LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("HEAD", url, false);
|
||
xhr.send(null);
|
||
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
|
||
var datalength = Number(xhr.getResponseHeader("Content-length"));
|
||
var header;
|
||
var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
|
||
var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
|
||
var chunkSize = 1024 * 1024;
|
||
if (!hasByteServing) chunkSize = datalength;
|
||
var doXHR = (from, to) => {
|
||
if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
|
||
if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
|
||
var xhr = new XMLHttpRequest();
|
||
xhr.open("GET", url, false);
|
||
if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
|
||
xhr.responseType = "arraybuffer";
|
||
if (xhr.overrideMimeType) {
|
||
xhr.overrideMimeType("text/plain; charset=x-user-defined");
|
||
}
|
||
xhr.send(null);
|
||
if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
|
||
if (xhr.response !== undefined) {
|
||
return new Uint8Array(xhr.response || []);
|
||
}
|
||
return intArrayFromString(xhr.responseText || "", true);
|
||
};
|
||
var lazyArray = this;
|
||
lazyArray.setDataGetter(chunkNum => {
|
||
var start = chunkNum * chunkSize;
|
||
var end = (chunkNum + 1) * chunkSize - 1;
|
||
end = Math.min(end, datalength - 1);
|
||
if (typeof lazyArray.chunks[chunkNum] == "undefined") {
|
||
lazyArray.chunks[chunkNum] = doXHR(start, end);
|
||
}
|
||
if (typeof lazyArray.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!");
|
||
return lazyArray.chunks[chunkNum];
|
||
});
|
||
if (usesGzip || !datalength) {
|
||
chunkSize = datalength = 1;
|
||
datalength = this.getter(0).length;
|
||
chunkSize = datalength;
|
||
out("LazyFiles on gzip forces download of the whole file when length is accessed");
|
||
}
|
||
this._length = datalength;
|
||
this._chunkSize = chunkSize;
|
||
this.lengthKnown = true;
|
||
};
|
||
if (typeof XMLHttpRequest != "undefined") {
|
||
if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
|
||
var lazyArray = new LazyUint8Array();
|
||
Object.defineProperties(lazyArray, {
|
||
length: {
|
||
get: function () {
|
||
if (!this.lengthKnown) {
|
||
this.cacheLength();
|
||
}
|
||
return this._length;
|
||
}
|
||
},
|
||
chunkSize: {
|
||
get: function () {
|
||
if (!this.lengthKnown) {
|
||
this.cacheLength();
|
||
}
|
||
return this._chunkSize;
|
||
}
|
||
}
|
||
});
|
||
var properties = {
|
||
isDevice: false,
|
||
contents: lazyArray
|
||
};
|
||
} else {
|
||
var properties = {
|
||
isDevice: false,
|
||
url: url
|
||
};
|
||
}
|
||
var node = FS.createFile(parent, name, properties, canRead, canWrite);
|
||
if (properties.contents) {
|
||
node.contents = properties.contents;
|
||
} else if (properties.url) {
|
||
node.contents = null;
|
||
node.url = properties.url;
|
||
}
|
||
Object.defineProperties(node, {
|
||
usedBytes: {
|
||
get: function () {
|
||
return this.contents.length;
|
||
}
|
||
}
|
||
});
|
||
var stream_ops = {};
|
||
var keys = Object.keys(node.stream_ops);
|
||
keys.forEach(key => {
|
||
var fn = node.stream_ops[key];
|
||
stream_ops[key] = function forceLoadLazyFile() {
|
||
FS.forceLoadFile(node);
|
||
return fn.apply(null, arguments);
|
||
};
|
||
});
|
||
function writeChunks(stream, buffer, offset, length, position) {
|
||
var contents = stream.node.contents;
|
||
if (position >= contents.length) return 0;
|
||
var size = Math.min(contents.length - position, length);
|
||
if (contents.slice) {
|
||
for (var i = 0; i < size; i++) {
|
||
buffer[offset + i] = contents[position + i];
|
||
}
|
||
} else {
|
||
for (var i = 0; i < size; i++) {
|
||
buffer[offset + i] = contents.get(position + i);
|
||
}
|
||
}
|
||
return size;
|
||
}
|
||
stream_ops.read = (stream, buffer, offset, length, position) => {
|
||
FS.forceLoadFile(node);
|
||
return writeChunks(stream, buffer, offset, length, position);
|
||
};
|
||
stream_ops.mmap = (stream, length, position, prot, flags) => {
|
||
FS.forceLoadFile(node);
|
||
var ptr = mmapAlloc(length);
|
||
if (!ptr) {
|
||
throw new FS.ErrnoError(48);
|
||
}
|
||
writeChunks(stream, HEAP8, ptr, length, position);
|
||
return {
|
||
ptr: ptr,
|
||
allocated: true
|
||
};
|
||
};
|
||
node.stream_ops = stream_ops;
|
||
return node;
|
||
},
|
||
createPreloadedFile: (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
|
||
var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
|
||
function processData(byteArray) {
|
||
function finish(byteArray) {
|
||
if (preFinish) preFinish();
|
||
if (!dontCreateFile) {
|
||
FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
|
||
}
|
||
if (onload) onload();
|
||
removeRunDependency();
|
||
}
|
||
if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => {
|
||
if (onerror) onerror();
|
||
removeRunDependency();
|
||
})) {
|
||
return;
|
||
}
|
||
finish(byteArray);
|
||
}
|
||
addRunDependency();
|
||
if (typeof url == "string") {
|
||
asyncLoad(url, byteArray => processData(byteArray), onerror);
|
||
} else {
|
||
processData(url);
|
||
}
|
||
},
|
||
indexedDB: () => {
|
||
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
||
},
|
||
DB_NAME: () => {
|
||
return "EM_FS_" + window.location.pathname;
|
||
},
|
||
DB_VERSION: 20,
|
||
DB_STORE_NAME: "FILE_DATA",
|
||
saveFilesToDB: (paths, onload, onerror) => {
|
||
onload = onload || (() => {});
|
||
onerror = onerror || (() => {});
|
||
var indexedDB = FS.indexedDB();
|
||
try {
|
||
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
||
} catch (e) {
|
||
return onerror(e);
|
||
}
|
||
openRequest.onupgradeneeded = () => {
|
||
out("creating db");
|
||
var db = openRequest.result;
|
||
db.createObjectStore(FS.DB_STORE_NAME);
|
||
};
|
||
openRequest.onsuccess = () => {
|
||
var db = openRequest.result;
|
||
var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite");
|
||
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
||
var ok = 0,
|
||
fail = 0,
|
||
total = paths.length;
|
||
function finish() {
|
||
if (fail == 0) onload();else onerror();
|
||
}
|
||
paths.forEach(path => {
|
||
var putRequest = files.put(FS.analyzePath(path).object.contents, path);
|
||
putRequest.onsuccess = () => {
|
||
ok++;
|
||
if (ok + fail == total) finish();
|
||
};
|
||
putRequest.onerror = () => {
|
||
fail++;
|
||
if (ok + fail == total) finish();
|
||
};
|
||
});
|
||
transaction.onerror = onerror;
|
||
};
|
||
openRequest.onerror = onerror;
|
||
},
|
||
loadFilesFromDB: (paths, onload, onerror) => {
|
||
onload = onload || (() => {});
|
||
onerror = onerror || (() => {});
|
||
var indexedDB = FS.indexedDB();
|
||
try {
|
||
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
||
} catch (e) {
|
||
return onerror(e);
|
||
}
|
||
openRequest.onupgradeneeded = onerror;
|
||
openRequest.onsuccess = () => {
|
||
var db = openRequest.result;
|
||
try {
|
||
var transaction = db.transaction([FS.DB_STORE_NAME], "readonly");
|
||
} catch (e) {
|
||
onerror(e);
|
||
return;
|
||
}
|
||
var files = transaction.objectStore(FS.DB_STORE_NAME);
|
||
var ok = 0,
|
||
fail = 0,
|
||
total = paths.length;
|
||
function finish() {
|
||
if (fail == 0) onload();else onerror();
|
||
}
|
||
paths.forEach(path => {
|
||
var getRequest = files.get(path);
|
||
getRequest.onsuccess = () => {
|
||
if (FS.analyzePath(path).exists) {
|
||
FS.unlink(path);
|
||
}
|
||
FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
|
||
ok++;
|
||
if (ok + fail == total) finish();
|
||
};
|
||
getRequest.onerror = () => {
|
||
fail++;
|
||
if (ok + fail == total) finish();
|
||
};
|
||
});
|
||
transaction.onerror = onerror;
|
||
};
|
||
openRequest.onerror = onerror;
|
||
}
|
||
};
|
||
var SYSCALLS = {
|
||
DEFAULT_POLLMASK: 5,
|
||
calculateAt: function (dirfd, path, allowEmpty) {
|
||
if (PATH.isAbs(path)) {
|
||
return path;
|
||
}
|
||
var dir;
|
||
if (dirfd === -100) {
|
||
dir = FS.cwd();
|
||
} else {
|
||
var dirstream = FS.getStream(dirfd);
|
||
if (!dirstream) throw new FS.ErrnoError(8);
|
||
dir = dirstream.path;
|
||
}
|
||
if (path.length == 0) {
|
||
if (!allowEmpty) {
|
||
throw new FS.ErrnoError(44);
|
||
}
|
||
return dir;
|
||
}
|
||
return PATH.join2(dir, path);
|
||
},
|
||
doStat: function (func, path, buf) {
|
||
try {
|
||
var stat = func(path);
|
||
} catch (e) {
|
||
if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
|
||
return -54;
|
||
}
|
||
throw e;
|
||
}
|
||
HEAP32[buf >> 2] = stat.dev;
|
||
HEAP32[buf + 4 >> 2] = 0;
|
||
HEAP32[buf + 8 >> 2] = stat.ino;
|
||
HEAP32[buf + 12 >> 2] = stat.mode;
|
||
HEAP32[buf + 16 >> 2] = stat.nlink;
|
||
HEAP32[buf + 20 >> 2] = stat.uid;
|
||
HEAP32[buf + 24 >> 2] = stat.gid;
|
||
HEAP32[buf + 28 >> 2] = stat.rdev;
|
||
HEAP32[buf + 32 >> 2] = 0;
|
||
tempI64 = [stat.size >>> 0, (tempDouble = stat.size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 40 >> 2] = tempI64[0], HEAP32[buf + 44 >> 2] = tempI64[1];
|
||
HEAP32[buf + 48 >> 2] = 4096;
|
||
HEAP32[buf + 52 >> 2] = stat.blocks;
|
||
tempI64 = [Math.floor(stat.atime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.atime.getTime() / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 56 >> 2] = tempI64[0], HEAP32[buf + 60 >> 2] = tempI64[1];
|
||
HEAP32[buf + 64 >> 2] = 0;
|
||
tempI64 = [Math.floor(stat.mtime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.mtime.getTime() / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 72 >> 2] = tempI64[0], HEAP32[buf + 76 >> 2] = tempI64[1];
|
||
HEAP32[buf + 80 >> 2] = 0;
|
||
tempI64 = [Math.floor(stat.ctime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.ctime.getTime() / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 88 >> 2] = tempI64[0], HEAP32[buf + 92 >> 2] = tempI64[1];
|
||
HEAP32[buf + 96 >> 2] = 0;
|
||
tempI64 = [stat.ino >>> 0, (tempDouble = stat.ino, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 104 >> 2] = tempI64[0], HEAP32[buf + 108 >> 2] = tempI64[1];
|
||
return 0;
|
||
},
|
||
doMsync: function (addr, stream, len, flags, offset) {
|
||
var buffer = HEAPU8.slice(addr, addr + len);
|
||
FS.msync(stream, buffer, offset, len, flags);
|
||
},
|
||
varargs: undefined,
|
||
get: function () {
|
||
SYSCALLS.varargs += 4;
|
||
var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
|
||
return ret;
|
||
},
|
||
getStr: function (ptr) {
|
||
var ret = UTF8ToString(ptr);
|
||
return ret;
|
||
},
|
||
getStreamFromFD: function (fd) {
|
||
var stream = FS.getStream(fd);
|
||
if (!stream) throw new FS.ErrnoError(8);
|
||
return stream;
|
||
}
|
||
};
|
||
function ___syscall_fcntl64(fd, cmd, varargs) {
|
||
SYSCALLS.varargs = varargs;
|
||
try {
|
||
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
switch (cmd) {
|
||
case 0:
|
||
{
|
||
var arg = SYSCALLS.get();
|
||
if (arg < 0) {
|
||
return -28;
|
||
}
|
||
var newStream;
|
||
newStream = FS.createStream(stream, arg);
|
||
return newStream.fd;
|
||
}
|
||
case 1:
|
||
case 2:
|
||
return 0;
|
||
case 3:
|
||
return stream.flags;
|
||
case 4:
|
||
{
|
||
var arg = SYSCALLS.get();
|
||
stream.flags |= arg;
|
||
return 0;
|
||
}
|
||
case 5:
|
||
{
|
||
var arg = SYSCALLS.get();
|
||
var offset = 0;
|
||
HEAP16[arg + offset >> 1] = 2;
|
||
return 0;
|
||
}
|
||
case 6:
|
||
case 7:
|
||
return 0;
|
||
case 16:
|
||
case 8:
|
||
return -28;
|
||
case 9:
|
||
setErrNo(28);
|
||
return -1;
|
||
default:
|
||
{
|
||
return -28;
|
||
}
|
||
}
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return -e.errno;
|
||
}
|
||
}
|
||
function ___syscall_openat(dirfd, path, flags, varargs) {
|
||
SYSCALLS.varargs = varargs;
|
||
try {
|
||
path = SYSCALLS.getStr(path);
|
||
path = SYSCALLS.calculateAt(dirfd, path);
|
||
var mode = varargs ? SYSCALLS.get() : 0;
|
||
return FS.open(path, flags, mode).fd;
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return -e.errno;
|
||
}
|
||
}
|
||
function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {}
|
||
function getShiftFromSize(size) {
|
||
switch (size) {
|
||
case 1:
|
||
return 0;
|
||
case 2:
|
||
return 1;
|
||
case 4:
|
||
return 2;
|
||
case 8:
|
||
return 3;
|
||
default:
|
||
throw new TypeError("Unknown type size: " + size);
|
||
}
|
||
}
|
||
function embind_init_charCodes() {
|
||
var codes = new Array(256);
|
||
for (var i = 0; i < 256; ++i) {
|
||
codes[i] = String.fromCharCode(i);
|
||
}
|
||
embind_charCodes = codes;
|
||
}
|
||
var embind_charCodes = undefined;
|
||
function readLatin1String(ptr) {
|
||
var ret = "";
|
||
var c = ptr;
|
||
while (HEAPU8[c]) {
|
||
ret += embind_charCodes[HEAPU8[c++]];
|
||
}
|
||
return ret;
|
||
}
|
||
var awaitingDependencies = {};
|
||
var registeredTypes = {};
|
||
var typeDependencies = {};
|
||
var char_0 = 48;
|
||
var char_9 = 57;
|
||
function makeLegalFunctionName(name) {
|
||
if (undefined === name) {
|
||
return "_unknown";
|
||
}
|
||
name = name.replace(/[^a-zA-Z0-9_]/g, "$");
|
||
var f = name.charCodeAt(0);
|
||
if (f >= char_0 && f <= char_9) {
|
||
return "_" + name;
|
||
}
|
||
return name;
|
||
}
|
||
function createNamedFunction(name, body) {
|
||
name = makeLegalFunctionName(name);
|
||
return new Function("body", "return function " + name + "() {\n" + ' "use strict";' + " return body.apply(this, arguments);\n" + "};\n")(body);
|
||
}
|
||
function extendError(baseErrorType, errorName) {
|
||
var errorClass = createNamedFunction(errorName, function (message) {
|
||
this.name = errorName;
|
||
this.message = message;
|
||
var stack = new Error(message).stack;
|
||
if (stack !== undefined) {
|
||
this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
|
||
}
|
||
});
|
||
errorClass.prototype = Object.create(baseErrorType.prototype);
|
||
errorClass.prototype.constructor = errorClass;
|
||
errorClass.prototype.toString = function () {
|
||
if (this.message === undefined) {
|
||
return this.name;
|
||
} else {
|
||
return this.name + ": " + this.message;
|
||
}
|
||
};
|
||
return errorClass;
|
||
}
|
||
var BindingError = undefined;
|
||
function throwBindingError(message) {
|
||
throw new BindingError(message);
|
||
}
|
||
var InternalError = undefined;
|
||
function throwInternalError(message) {
|
||
throw new InternalError(message);
|
||
}
|
||
function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
|
||
myTypes.forEach(function (type) {
|
||
typeDependencies[type] = dependentTypes;
|
||
});
|
||
function onComplete(typeConverters) {
|
||
var myTypeConverters = getTypeConverters(typeConverters);
|
||
if (myTypeConverters.length !== myTypes.length) {
|
||
throwInternalError("Mismatched type converter count");
|
||
}
|
||
for (var i = 0; i < myTypes.length; ++i) {
|
||
registerType(myTypes[i], myTypeConverters[i]);
|
||
}
|
||
}
|
||
var typeConverters = new Array(dependentTypes.length);
|
||
var unregisteredTypes = [];
|
||
var registered = 0;
|
||
dependentTypes.forEach((dt, i) => {
|
||
if (registeredTypes.hasOwnProperty(dt)) {
|
||
typeConverters[i] = registeredTypes[dt];
|
||
} else {
|
||
unregisteredTypes.push(dt);
|
||
if (!awaitingDependencies.hasOwnProperty(dt)) {
|
||
awaitingDependencies[dt] = [];
|
||
}
|
||
awaitingDependencies[dt].push(() => {
|
||
typeConverters[i] = registeredTypes[dt];
|
||
++registered;
|
||
if (registered === unregisteredTypes.length) {
|
||
onComplete(typeConverters);
|
||
}
|
||
});
|
||
}
|
||
});
|
||
if (0 === unregisteredTypes.length) {
|
||
onComplete(typeConverters);
|
||
}
|
||
}
|
||
function registerType(rawType, registeredInstance) {
|
||
let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
||
if (!("argPackAdvance" in registeredInstance)) {
|
||
throw new TypeError("registerType registeredInstance requires argPackAdvance");
|
||
}
|
||
var name = registeredInstance.name;
|
||
if (!rawType) {
|
||
throwBindingError('type "' + name + '" must have a positive integer typeid pointer');
|
||
}
|
||
if (registeredTypes.hasOwnProperty(rawType)) {
|
||
if (options.ignoreDuplicateRegistrations) {
|
||
return;
|
||
} else {
|
||
throwBindingError("Cannot register type '" + name + "' twice");
|
||
}
|
||
}
|
||
registeredTypes[rawType] = registeredInstance;
|
||
delete typeDependencies[rawType];
|
||
if (awaitingDependencies.hasOwnProperty(rawType)) {
|
||
var callbacks = awaitingDependencies[rawType];
|
||
delete awaitingDependencies[rawType];
|
||
callbacks.forEach(cb => cb());
|
||
}
|
||
}
|
||
function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
|
||
var shift = getShiftFromSize(size);
|
||
name = readLatin1String(name);
|
||
registerType(rawType, {
|
||
name: name,
|
||
"fromWireType": function (wt) {
|
||
return !!wt;
|
||
},
|
||
"toWireType": function (destructors, o) {
|
||
return o ? trueValue : falseValue;
|
||
},
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": function (pointer) {
|
||
var heap;
|
||
if (size === 1) {
|
||
heap = HEAP8;
|
||
} else if (size === 2) {
|
||
heap = HEAP16;
|
||
} else if (size === 4) {
|
||
heap = HEAP32;
|
||
} else {
|
||
throw new TypeError("Unknown boolean type size: " + name);
|
||
}
|
||
return this["fromWireType"](heap[pointer >> shift]);
|
||
},
|
||
destructorFunction: null
|
||
});
|
||
}
|
||
function ClassHandle_isAliasOf(other) {
|
||
if (!(this instanceof ClassHandle)) {
|
||
return false;
|
||
}
|
||
if (!(other instanceof ClassHandle)) {
|
||
return false;
|
||
}
|
||
var leftClass = this.$$.ptrType.registeredClass;
|
||
var left = this.$$.ptr;
|
||
var rightClass = other.$$.ptrType.registeredClass;
|
||
var right = other.$$.ptr;
|
||
while (leftClass.baseClass) {
|
||
left = leftClass.upcast(left);
|
||
leftClass = leftClass.baseClass;
|
||
}
|
||
while (rightClass.baseClass) {
|
||
right = rightClass.upcast(right);
|
||
rightClass = rightClass.baseClass;
|
||
}
|
||
return leftClass === rightClass && left === right;
|
||
}
|
||
function shallowCopyInternalPointer(o) {
|
||
return {
|
||
count: o.count,
|
||
deleteScheduled: o.deleteScheduled,
|
||
preservePointerOnDelete: o.preservePointerOnDelete,
|
||
ptr: o.ptr,
|
||
ptrType: o.ptrType,
|
||
smartPtr: o.smartPtr,
|
||
smartPtrType: o.smartPtrType
|
||
};
|
||
}
|
||
function throwInstanceAlreadyDeleted(obj) {
|
||
function getInstanceTypeName(handle) {
|
||
return handle.$$.ptrType.registeredClass.name;
|
||
}
|
||
throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
|
||
}
|
||
var finalizationRegistry = false;
|
||
function detachFinalizer(handle) {}
|
||
function runDestructor($$) {
|
||
if ($$.smartPtr) {
|
||
$$.smartPtrType.rawDestructor($$.smartPtr);
|
||
} else {
|
||
$$.ptrType.registeredClass.rawDestructor($$.ptr);
|
||
}
|
||
}
|
||
function releaseClassHandle($$) {
|
||
$$.count.value -= 1;
|
||
var toDelete = 0 === $$.count.value;
|
||
if (toDelete) {
|
||
runDestructor($$);
|
||
}
|
||
}
|
||
function downcastPointer(ptr, ptrClass, desiredClass) {
|
||
if (ptrClass === desiredClass) {
|
||
return ptr;
|
||
}
|
||
if (undefined === desiredClass.baseClass) {
|
||
return null;
|
||
}
|
||
var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
|
||
if (rv === null) {
|
||
return null;
|
||
}
|
||
return desiredClass.downcast(rv);
|
||
}
|
||
var registeredPointers = {};
|
||
function getInheritedInstanceCount() {
|
||
return Object.keys(registeredInstances).length;
|
||
}
|
||
function getLiveInheritedInstances() {
|
||
var rv = [];
|
||
for (var k in registeredInstances) {
|
||
if (registeredInstances.hasOwnProperty(k)) {
|
||
rv.push(registeredInstances[k]);
|
||
}
|
||
}
|
||
return rv;
|
||
}
|
||
var deletionQueue = [];
|
||
function flushPendingDeletes() {
|
||
while (deletionQueue.length) {
|
||
var obj = deletionQueue.pop();
|
||
obj.$$.deleteScheduled = false;
|
||
obj["delete"]();
|
||
}
|
||
}
|
||
var delayFunction = undefined;
|
||
function setDelayFunction(fn) {
|
||
delayFunction = fn;
|
||
if (deletionQueue.length && delayFunction) {
|
||
delayFunction(flushPendingDeletes);
|
||
}
|
||
}
|
||
function init_embind() {
|
||
Module["getInheritedInstanceCount"] = getInheritedInstanceCount;
|
||
Module["getLiveInheritedInstances"] = getLiveInheritedInstances;
|
||
Module["flushPendingDeletes"] = flushPendingDeletes;
|
||
Module["setDelayFunction"] = setDelayFunction;
|
||
}
|
||
var registeredInstances = {};
|
||
function getBasestPointer(class_, ptr) {
|
||
if (ptr === undefined) {
|
||
throwBindingError("ptr should not be undefined");
|
||
}
|
||
while (class_.baseClass) {
|
||
ptr = class_.upcast(ptr);
|
||
class_ = class_.baseClass;
|
||
}
|
||
return ptr;
|
||
}
|
||
function getInheritedInstance(class_, ptr) {
|
||
ptr = getBasestPointer(class_, ptr);
|
||
return registeredInstances[ptr];
|
||
}
|
||
function makeClassHandle(prototype, record) {
|
||
if (!record.ptrType || !record.ptr) {
|
||
throwInternalError("makeClassHandle requires ptr and ptrType");
|
||
}
|
||
var hasSmartPtrType = !!record.smartPtrType;
|
||
var hasSmartPtr = !!record.smartPtr;
|
||
if (hasSmartPtrType !== hasSmartPtr) {
|
||
throwInternalError("Both smartPtrType and smartPtr must be specified");
|
||
}
|
||
record.count = {
|
||
value: 1
|
||
};
|
||
return attachFinalizer(Object.create(prototype, {
|
||
$$: {
|
||
value: record
|
||
}
|
||
}));
|
||
}
|
||
function RegisteredPointer_fromWireType(ptr) {
|
||
var rawPointer = this.getPointee(ptr);
|
||
if (!rawPointer) {
|
||
this.destructor(ptr);
|
||
return null;
|
||
}
|
||
var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
|
||
if (undefined !== registeredInstance) {
|
||
if (0 === registeredInstance.$$.count.value) {
|
||
registeredInstance.$$.ptr = rawPointer;
|
||
registeredInstance.$$.smartPtr = ptr;
|
||
return registeredInstance["clone"]();
|
||
} else {
|
||
var rv = registeredInstance["clone"]();
|
||
this.destructor(ptr);
|
||
return rv;
|
||
}
|
||
}
|
||
function makeDefaultHandle() {
|
||
if (this.isSmartPointer) {
|
||
return makeClassHandle(this.registeredClass.instancePrototype, {
|
||
ptrType: this.pointeeType,
|
||
ptr: rawPointer,
|
||
smartPtrType: this,
|
||
smartPtr: ptr
|
||
});
|
||
} else {
|
||
return makeClassHandle(this.registeredClass.instancePrototype, {
|
||
ptrType: this,
|
||
ptr: ptr
|
||
});
|
||
}
|
||
}
|
||
var actualType = this.registeredClass.getActualType(rawPointer);
|
||
var registeredPointerRecord = registeredPointers[actualType];
|
||
if (!registeredPointerRecord) {
|
||
return makeDefaultHandle.call(this);
|
||
}
|
||
var toType;
|
||
if (this.isConst) {
|
||
toType = registeredPointerRecord.constPointerType;
|
||
} else {
|
||
toType = registeredPointerRecord.pointerType;
|
||
}
|
||
var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
|
||
if (dp === null) {
|
||
return makeDefaultHandle.call(this);
|
||
}
|
||
if (this.isSmartPointer) {
|
||
return makeClassHandle(toType.registeredClass.instancePrototype, {
|
||
ptrType: toType,
|
||
ptr: dp,
|
||
smartPtrType: this,
|
||
smartPtr: ptr
|
||
});
|
||
} else {
|
||
return makeClassHandle(toType.registeredClass.instancePrototype, {
|
||
ptrType: toType,
|
||
ptr: dp
|
||
});
|
||
}
|
||
}
|
||
function attachFinalizer(handle) {
|
||
if ("undefined" === typeof FinalizationRegistry) {
|
||
attachFinalizer = handle => handle;
|
||
return handle;
|
||
}
|
||
finalizationRegistry = new FinalizationRegistry(info => {
|
||
releaseClassHandle(info.$$);
|
||
});
|
||
attachFinalizer = handle => {
|
||
var $$ = handle.$$;
|
||
var hasSmartPtr = !!$$.smartPtr;
|
||
if (hasSmartPtr) {
|
||
var info = {
|
||
$$: $$
|
||
};
|
||
finalizationRegistry.register(handle, info, handle);
|
||
}
|
||
return handle;
|
||
};
|
||
detachFinalizer = handle => finalizationRegistry.unregister(handle);
|
||
return attachFinalizer(handle);
|
||
}
|
||
function ClassHandle_clone() {
|
||
if (!this.$$.ptr) {
|
||
throwInstanceAlreadyDeleted(this);
|
||
}
|
||
if (this.$$.preservePointerOnDelete) {
|
||
this.$$.count.value += 1;
|
||
return this;
|
||
} else {
|
||
var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), {
|
||
$$: {
|
||
value: shallowCopyInternalPointer(this.$$)
|
||
}
|
||
}));
|
||
clone.$$.count.value += 1;
|
||
clone.$$.deleteScheduled = false;
|
||
return clone;
|
||
}
|
||
}
|
||
function ClassHandle_delete() {
|
||
if (!this.$$.ptr) {
|
||
throwInstanceAlreadyDeleted(this);
|
||
}
|
||
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
|
||
throwBindingError("Object already scheduled for deletion");
|
||
}
|
||
detachFinalizer(this);
|
||
releaseClassHandle(this.$$);
|
||
if (!this.$$.preservePointerOnDelete) {
|
||
this.$$.smartPtr = undefined;
|
||
this.$$.ptr = undefined;
|
||
}
|
||
}
|
||
function ClassHandle_isDeleted() {
|
||
return !this.$$.ptr;
|
||
}
|
||
function ClassHandle_deleteLater() {
|
||
if (!this.$$.ptr) {
|
||
throwInstanceAlreadyDeleted(this);
|
||
}
|
||
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
|
||
throwBindingError("Object already scheduled for deletion");
|
||
}
|
||
deletionQueue.push(this);
|
||
if (deletionQueue.length === 1 && delayFunction) {
|
||
delayFunction(flushPendingDeletes);
|
||
}
|
||
this.$$.deleteScheduled = true;
|
||
return this;
|
||
}
|
||
function init_ClassHandle() {
|
||
ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf;
|
||
ClassHandle.prototype["clone"] = ClassHandle_clone;
|
||
ClassHandle.prototype["delete"] = ClassHandle_delete;
|
||
ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted;
|
||
ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater;
|
||
}
|
||
function ClassHandle() {}
|
||
function ensureOverloadTable(proto, methodName, humanName) {
|
||
if (undefined === proto[methodName].overloadTable) {
|
||
var prevFunc = proto[methodName];
|
||
proto[methodName] = function () {
|
||
if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
|
||
throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
|
||
}
|
||
return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
|
||
};
|
||
proto[methodName].overloadTable = [];
|
||
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
|
||
}
|
||
}
|
||
function exposePublicSymbol(name, value, numArguments) {
|
||
if (Module.hasOwnProperty(name)) {
|
||
if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
|
||
throwBindingError("Cannot register public name '" + name + "' twice");
|
||
}
|
||
ensureOverloadTable(Module, name, name);
|
||
if (Module.hasOwnProperty(numArguments)) {
|
||
throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
|
||
}
|
||
Module[name].overloadTable[numArguments] = value;
|
||
} else {
|
||
Module[name] = value;
|
||
if (undefined !== numArguments) {
|
||
Module[name].numArguments = numArguments;
|
||
}
|
||
}
|
||
}
|
||
function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
|
||
this.name = name;
|
||
this.constructor = constructor;
|
||
this.instancePrototype = instancePrototype;
|
||
this.rawDestructor = rawDestructor;
|
||
this.baseClass = baseClass;
|
||
this.getActualType = getActualType;
|
||
this.upcast = upcast;
|
||
this.downcast = downcast;
|
||
this.pureVirtualFunctions = [];
|
||
}
|
||
function upcastPointer(ptr, ptrClass, desiredClass) {
|
||
while (ptrClass !== desiredClass) {
|
||
if (!ptrClass.upcast) {
|
||
throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name);
|
||
}
|
||
ptr = ptrClass.upcast(ptr);
|
||
ptrClass = ptrClass.baseClass;
|
||
}
|
||
return ptr;
|
||
}
|
||
function constNoSmartPtrRawPointerToWireType(destructors, handle) {
|
||
if (handle === null) {
|
||
if (this.isReference) {
|
||
throwBindingError("null is not a valid " + this.name);
|
||
}
|
||
return 0;
|
||
}
|
||
if (!handle.$$) {
|
||
throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name);
|
||
}
|
||
if (!handle.$$.ptr) {
|
||
throwBindingError("Cannot pass deleted object as a pointer of type " + this.name);
|
||
}
|
||
var handleClass = handle.$$.ptrType.registeredClass;
|
||
var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
|
||
return ptr;
|
||
}
|
||
function genericPointerToWireType(destructors, handle) {
|
||
var ptr;
|
||
if (handle === null) {
|
||
if (this.isReference) {
|
||
throwBindingError("null is not a valid " + this.name);
|
||
}
|
||
if (this.isSmartPointer) {
|
||
ptr = this.rawConstructor();
|
||
if (destructors !== null) {
|
||
destructors.push(this.rawDestructor, ptr);
|
||
}
|
||
return ptr;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
if (!handle.$$) {
|
||
throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name);
|
||
}
|
||
if (!handle.$$.ptr) {
|
||
throwBindingError("Cannot pass deleted object as a pointer of type " + this.name);
|
||
}
|
||
if (!this.isConst && handle.$$.ptrType.isConst) {
|
||
throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name);
|
||
}
|
||
var handleClass = handle.$$.ptrType.registeredClass;
|
||
ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
|
||
if (this.isSmartPointer) {
|
||
if (undefined === handle.$$.smartPtr) {
|
||
throwBindingError("Passing raw pointer to smart pointer is illegal");
|
||
}
|
||
switch (this.sharingPolicy) {
|
||
case 0:
|
||
if (handle.$$.smartPtrType === this) {
|
||
ptr = handle.$$.smartPtr;
|
||
} else {
|
||
throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name);
|
||
}
|
||
break;
|
||
case 1:
|
||
ptr = handle.$$.smartPtr;
|
||
break;
|
||
case 2:
|
||
if (handle.$$.smartPtrType === this) {
|
||
ptr = handle.$$.smartPtr;
|
||
} else {
|
||
var clonedHandle = handle["clone"]();
|
||
ptr = this.rawShare(ptr, Emval.toHandle(function () {
|
||
clonedHandle["delete"]();
|
||
}));
|
||
if (destructors !== null) {
|
||
destructors.push(this.rawDestructor, ptr);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
throwBindingError("Unsupporting sharing policy");
|
||
}
|
||
}
|
||
return ptr;
|
||
}
|
||
function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
|
||
if (handle === null) {
|
||
if (this.isReference) {
|
||
throwBindingError("null is not a valid " + this.name);
|
||
}
|
||
return 0;
|
||
}
|
||
if (!handle.$$) {
|
||
throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name);
|
||
}
|
||
if (!handle.$$.ptr) {
|
||
throwBindingError("Cannot pass deleted object as a pointer of type " + this.name);
|
||
}
|
||
if (handle.$$.ptrType.isConst) {
|
||
throwBindingError("Cannot convert argument of type " + handle.$$.ptrType.name + " to parameter type " + this.name);
|
||
}
|
||
var handleClass = handle.$$.ptrType.registeredClass;
|
||
var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
|
||
return ptr;
|
||
}
|
||
function simpleReadValueFromPointer(pointer) {
|
||
return this["fromWireType"](HEAP32[pointer >> 2]);
|
||
}
|
||
function RegisteredPointer_getPointee(ptr) {
|
||
if (this.rawGetPointee) {
|
||
ptr = this.rawGetPointee(ptr);
|
||
}
|
||
return ptr;
|
||
}
|
||
function RegisteredPointer_destructor(ptr) {
|
||
if (this.rawDestructor) {
|
||
this.rawDestructor(ptr);
|
||
}
|
||
}
|
||
function RegisteredPointer_deleteObject(handle) {
|
||
if (handle !== null) {
|
||
handle["delete"]();
|
||
}
|
||
}
|
||
function init_RegisteredPointer() {
|
||
RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
|
||
RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
|
||
RegisteredPointer.prototype["argPackAdvance"] = 8;
|
||
RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer;
|
||
RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject;
|
||
RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType;
|
||
}
|
||
function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
|
||
this.name = name;
|
||
this.registeredClass = registeredClass;
|
||
this.isReference = isReference;
|
||
this.isConst = isConst;
|
||
this.isSmartPointer = isSmartPointer;
|
||
this.pointeeType = pointeeType;
|
||
this.sharingPolicy = sharingPolicy;
|
||
this.rawGetPointee = rawGetPointee;
|
||
this.rawConstructor = rawConstructor;
|
||
this.rawShare = rawShare;
|
||
this.rawDestructor = rawDestructor;
|
||
if (!isSmartPointer && registeredClass.baseClass === undefined) {
|
||
if (isConst) {
|
||
this["toWireType"] = constNoSmartPtrRawPointerToWireType;
|
||
this.destructorFunction = null;
|
||
} else {
|
||
this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType;
|
||
this.destructorFunction = null;
|
||
}
|
||
} else {
|
||
this["toWireType"] = genericPointerToWireType;
|
||
}
|
||
}
|
||
function replacePublicSymbol(name, value, numArguments) {
|
||
if (!Module.hasOwnProperty(name)) {
|
||
throwInternalError("Replacing nonexistant public symbol");
|
||
}
|
||
if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
|
||
Module[name].overloadTable[numArguments] = value;
|
||
} else {
|
||
Module[name] = value;
|
||
Module[name].argCount = numArguments;
|
||
}
|
||
}
|
||
function dynCallLegacy(sig, ptr, args) {
|
||
var f = Module["dynCall_" + sig];
|
||
return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
|
||
}
|
||
var wasmTableMirror = [];
|
||
function getWasmTableEntry(funcPtr) {
|
||
var func = wasmTableMirror[funcPtr];
|
||
if (!func) {
|
||
if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
|
||
wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
|
||
}
|
||
return func;
|
||
}
|
||
function dynCall(sig, ptr, args) {
|
||
if (sig.includes("j")) {
|
||
return dynCallLegacy(sig, ptr, args);
|
||
}
|
||
var rtn = getWasmTableEntry(ptr).apply(null, args);
|
||
return rtn;
|
||
}
|
||
function getDynCaller(sig, ptr) {
|
||
var argCache = [];
|
||
return function () {
|
||
argCache.length = 0;
|
||
Object.assign(argCache, arguments);
|
||
return dynCall(sig, ptr, argCache);
|
||
};
|
||
}
|
||
function embind__requireFunction(signature, rawFunction) {
|
||
signature = readLatin1String(signature);
|
||
function makeDynCaller() {
|
||
if (signature.includes("j")) {
|
||
return getDynCaller(signature, rawFunction);
|
||
}
|
||
return getWasmTableEntry(rawFunction);
|
||
}
|
||
var fp = makeDynCaller();
|
||
if (typeof fp != "function") {
|
||
throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
|
||
}
|
||
return fp;
|
||
}
|
||
var UnboundTypeError = undefined;
|
||
function getTypeName(type) {
|
||
var ptr = ___getTypeName(type);
|
||
var rv = readLatin1String(ptr);
|
||
_free(ptr);
|
||
return rv;
|
||
}
|
||
function throwUnboundTypeError(message, types) {
|
||
var unboundTypes = [];
|
||
var seen = {};
|
||
function visit(type) {
|
||
if (seen[type]) {
|
||
return;
|
||
}
|
||
if (registeredTypes[type]) {
|
||
return;
|
||
}
|
||
if (typeDependencies[type]) {
|
||
typeDependencies[type].forEach(visit);
|
||
return;
|
||
}
|
||
unboundTypes.push(type);
|
||
seen[type] = true;
|
||
}
|
||
types.forEach(visit);
|
||
throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "]));
|
||
}
|
||
function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
|
||
name = readLatin1String(name);
|
||
getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
|
||
if (upcast) {
|
||
upcast = embind__requireFunction(upcastSignature, upcast);
|
||
}
|
||
if (downcast) {
|
||
downcast = embind__requireFunction(downcastSignature, downcast);
|
||
}
|
||
rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
|
||
var legalFunctionName = makeLegalFunctionName(name);
|
||
exposePublicSymbol(legalFunctionName, function () {
|
||
throwUnboundTypeError("Cannot construct " + name + " due to unbound types", [baseClassRawType]);
|
||
});
|
||
whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function (base) {
|
||
base = base[0];
|
||
var baseClass;
|
||
var basePrototype;
|
||
if (baseClassRawType) {
|
||
baseClass = base.registeredClass;
|
||
basePrototype = baseClass.instancePrototype;
|
||
} else {
|
||
basePrototype = ClassHandle.prototype;
|
||
}
|
||
var constructor = createNamedFunction(legalFunctionName, function () {
|
||
if (Object.getPrototypeOf(this) !== instancePrototype) {
|
||
throw new BindingError("Use 'new' to construct " + name);
|
||
}
|
||
if (undefined === registeredClass.constructor_body) {
|
||
throw new BindingError(name + " has no accessible constructor");
|
||
}
|
||
var body = registeredClass.constructor_body[arguments.length];
|
||
if (undefined === body) {
|
||
throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!");
|
||
}
|
||
return body.apply(this, arguments);
|
||
});
|
||
var instancePrototype = Object.create(basePrototype, {
|
||
constructor: {
|
||
value: constructor
|
||
}
|
||
});
|
||
constructor.prototype = instancePrototype;
|
||
var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
|
||
var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
|
||
var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
|
||
var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false);
|
||
registeredPointers[rawType] = {
|
||
pointerType: pointerConverter,
|
||
constPointerType: constPointerConverter
|
||
};
|
||
replacePublicSymbol(legalFunctionName, constructor);
|
||
return [referenceConverter, pointerConverter, constPointerConverter];
|
||
});
|
||
}
|
||
function heap32VectorToArray(count, firstElement) {
|
||
var array = [];
|
||
for (var i = 0; i < count; i++) {
|
||
array.push(HEAPU32[firstElement + i * 4 >> 2]);
|
||
}
|
||
return array;
|
||
}
|
||
function runDestructors(destructors) {
|
||
while (destructors.length) {
|
||
var ptr = destructors.pop();
|
||
var del = destructors.pop();
|
||
del(ptr);
|
||
}
|
||
}
|
||
function new_(constructor, argumentList) {
|
||
if (!(constructor instanceof Function)) {
|
||
throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function");
|
||
}
|
||
var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function () {});
|
||
dummy.prototype = constructor.prototype;
|
||
var obj = new dummy();
|
||
var r = constructor.apply(obj, argumentList);
|
||
return r instanceof Object ? r : obj;
|
||
}
|
||
function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
|
||
var argCount = argTypes.length;
|
||
if (argCount < 2) {
|
||
throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
|
||
}
|
||
var isClassMethodFunc = argTypes[1] !== null && classType !== null;
|
||
var needsDestructorStack = false;
|
||
for (var i = 1; i < argTypes.length; ++i) {
|
||
if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
|
||
needsDestructorStack = true;
|
||
break;
|
||
}
|
||
}
|
||
var returns = argTypes[0].name !== "void";
|
||
var argsList = "";
|
||
var argsListWired = "";
|
||
for (var i = 0; i < argCount - 2; ++i) {
|
||
argsList += (i !== 0 ? ", " : "") + "arg" + i;
|
||
argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
|
||
}
|
||
var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n";
|
||
if (needsDestructorStack) {
|
||
invokerFnBody += "var destructors = [];\n";
|
||
}
|
||
var dtorStack = needsDestructorStack ? "destructors" : "null";
|
||
var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
|
||
var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
|
||
if (isClassMethodFunc) {
|
||
invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
|
||
}
|
||
for (var i = 0; i < argCount - 2; ++i) {
|
||
invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
|
||
args1.push("argType" + i);
|
||
args2.push(argTypes[i + 2]);
|
||
}
|
||
if (isClassMethodFunc) {
|
||
argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
|
||
}
|
||
invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
|
||
if (needsDestructorStack) {
|
||
invokerFnBody += "runDestructors(destructors);\n";
|
||
} else {
|
||
for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
|
||
var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
|
||
if (argTypes[i].destructorFunction !== null) {
|
||
invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
|
||
args1.push(paramName + "_dtor");
|
||
args2.push(argTypes[i].destructorFunction);
|
||
}
|
||
}
|
||
}
|
||
if (returns) {
|
||
invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n";
|
||
}
|
||
invokerFnBody += "}\n";
|
||
args1.push(invokerFnBody);
|
||
var invokerFunction = new_(Function, args1).apply(null, args2);
|
||
return invokerFunction;
|
||
}
|
||
function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
|
||
assert(argCount > 0);
|
||
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
|
||
invoker = embind__requireFunction(invokerSignature, invoker);
|
||
whenDependentTypesAreResolved([], [rawClassType], function (classType) {
|
||
classType = classType[0];
|
||
var humanName = "constructor " + classType.name;
|
||
if (undefined === classType.registeredClass.constructor_body) {
|
||
classType.registeredClass.constructor_body = [];
|
||
}
|
||
if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {
|
||
throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount - 1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!");
|
||
}
|
||
classType.registeredClass.constructor_body[argCount - 1] = () => {
|
||
throwUnboundTypeError("Cannot construct " + classType.name + " due to unbound types", rawArgTypes);
|
||
};
|
||
whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
|
||
argTypes.splice(1, 0, null);
|
||
classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
|
||
return [];
|
||
});
|
||
return [];
|
||
});
|
||
}
|
||
function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual) {
|
||
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
|
||
methodName = readLatin1String(methodName);
|
||
rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
|
||
whenDependentTypesAreResolved([], [rawClassType], function (classType) {
|
||
classType = classType[0];
|
||
var humanName = classType.name + "." + methodName;
|
||
if (methodName.startsWith("@@")) {
|
||
methodName = Symbol[methodName.substring(2)];
|
||
}
|
||
if (isPureVirtual) {
|
||
classType.registeredClass.pureVirtualFunctions.push(methodName);
|
||
}
|
||
function unboundTypesHandler() {
|
||
throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes);
|
||
}
|
||
var proto = classType.registeredClass.instancePrototype;
|
||
var method = proto[methodName];
|
||
if (undefined === method || undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {
|
||
unboundTypesHandler.argCount = argCount - 2;
|
||
unboundTypesHandler.className = classType.name;
|
||
proto[methodName] = unboundTypesHandler;
|
||
} else {
|
||
ensureOverloadTable(proto, methodName, humanName);
|
||
proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
|
||
}
|
||
whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
|
||
var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context);
|
||
if (undefined === proto[methodName].overloadTable) {
|
||
memberFunction.argCount = argCount - 2;
|
||
proto[methodName] = memberFunction;
|
||
} else {
|
||
proto[methodName].overloadTable[argCount - 2] = memberFunction;
|
||
}
|
||
return [];
|
||
});
|
||
return [];
|
||
});
|
||
}
|
||
var emval_free_list = [];
|
||
var emval_handle_array = [{}, {
|
||
value: undefined
|
||
}, {
|
||
value: null
|
||
}, {
|
||
value: true
|
||
}, {
|
||
value: false
|
||
}];
|
||
function __emval_decref(handle) {
|
||
if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
|
||
emval_handle_array[handle] = undefined;
|
||
emval_free_list.push(handle);
|
||
}
|
||
}
|
||
function count_emval_handles() {
|
||
var count = 0;
|
||
for (var i = 5; i < emval_handle_array.length; ++i) {
|
||
if (emval_handle_array[i] !== undefined) {
|
||
++count;
|
||
}
|
||
}
|
||
return count;
|
||
}
|
||
function get_first_emval() {
|
||
for (var i = 5; i < emval_handle_array.length; ++i) {
|
||
if (emval_handle_array[i] !== undefined) {
|
||
return emval_handle_array[i];
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function init_emval() {
|
||
Module["count_emval_handles"] = count_emval_handles;
|
||
Module["get_first_emval"] = get_first_emval;
|
||
}
|
||
var Emval = {
|
||
toValue: handle => {
|
||
if (!handle) {
|
||
throwBindingError("Cannot use deleted val. handle = " + handle);
|
||
}
|
||
return emval_handle_array[handle].value;
|
||
},
|
||
toHandle: value => {
|
||
switch (value) {
|
||
case undefined:
|
||
return 1;
|
||
case null:
|
||
return 2;
|
||
case true:
|
||
return 3;
|
||
case false:
|
||
return 4;
|
||
default:
|
||
{
|
||
var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
|
||
emval_handle_array[handle] = {
|
||
refcount: 1,
|
||
value: value
|
||
};
|
||
return handle;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
function __embind_register_emval(rawType, name) {
|
||
name = readLatin1String(name);
|
||
registerType(rawType, {
|
||
name: name,
|
||
"fromWireType": function (handle) {
|
||
var rv = Emval.toValue(handle);
|
||
__emval_decref(handle);
|
||
return rv;
|
||
},
|
||
"toWireType": function (destructors, value) {
|
||
return Emval.toHandle(value);
|
||
},
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": simpleReadValueFromPointer,
|
||
destructorFunction: null
|
||
});
|
||
}
|
||
function embindRepr(v) {
|
||
if (v === null) {
|
||
return "null";
|
||
}
|
||
var t = typeof v;
|
||
if (t === "object" || t === "array" || t === "function") {
|
||
return v.toString();
|
||
} else {
|
||
return "" + v;
|
||
}
|
||
}
|
||
function floatReadValueFromPointer(name, shift) {
|
||
switch (shift) {
|
||
case 2:
|
||
return function (pointer) {
|
||
return this["fromWireType"](HEAPF32[pointer >> 2]);
|
||
};
|
||
case 3:
|
||
return function (pointer) {
|
||
return this["fromWireType"](HEAPF64[pointer >> 3]);
|
||
};
|
||
default:
|
||
throw new TypeError("Unknown float type: " + name);
|
||
}
|
||
}
|
||
function __embind_register_float(rawType, name, size) {
|
||
var shift = getShiftFromSize(size);
|
||
name = readLatin1String(name);
|
||
registerType(rawType, {
|
||
name: name,
|
||
"fromWireType": function (value) {
|
||
return value;
|
||
},
|
||
"toWireType": function (destructors, value) {
|
||
return value;
|
||
},
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": floatReadValueFromPointer(name, shift),
|
||
destructorFunction: null
|
||
});
|
||
}
|
||
function integerReadValueFromPointer(name, shift, signed) {
|
||
switch (shift) {
|
||
case 0:
|
||
return signed ? function readS8FromPointer(pointer) {
|
||
return HEAP8[pointer];
|
||
} : function readU8FromPointer(pointer) {
|
||
return HEAPU8[pointer];
|
||
};
|
||
case 1:
|
||
return signed ? function readS16FromPointer(pointer) {
|
||
return HEAP16[pointer >> 1];
|
||
} : function readU16FromPointer(pointer) {
|
||
return HEAPU16[pointer >> 1];
|
||
};
|
||
case 2:
|
||
return signed ? function readS32FromPointer(pointer) {
|
||
return HEAP32[pointer >> 2];
|
||
} : function readU32FromPointer(pointer) {
|
||
return HEAPU32[pointer >> 2];
|
||
};
|
||
default:
|
||
throw new TypeError("Unknown integer type: " + name);
|
||
}
|
||
}
|
||
function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
|
||
name = readLatin1String(name);
|
||
var shift = getShiftFromSize(size);
|
||
var fromWireType = value => value;
|
||
if (minRange === 0) {
|
||
var bitshift = 32 - 8 * size;
|
||
fromWireType = value => value << bitshift >>> bitshift;
|
||
}
|
||
var isUnsignedType = name.includes("unsigned");
|
||
var checkAssertions = (value, toTypeName) => {};
|
||
var toWireType;
|
||
if (isUnsignedType) {
|
||
toWireType = function (destructors, value) {
|
||
checkAssertions(value, this.name);
|
||
return value >>> 0;
|
||
};
|
||
} else {
|
||
toWireType = function (destructors, value) {
|
||
checkAssertions(value, this.name);
|
||
return value;
|
||
};
|
||
}
|
||
registerType(primitiveType, {
|
||
name: name,
|
||
"fromWireType": fromWireType,
|
||
"toWireType": toWireType,
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0),
|
||
destructorFunction: null
|
||
});
|
||
}
|
||
function __embind_register_memory_view(rawType, dataTypeIndex, name) {
|
||
var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
|
||
var TA = typeMapping[dataTypeIndex];
|
||
function decodeMemoryView(handle) {
|
||
handle = handle >> 2;
|
||
var heap = HEAPU32;
|
||
var size = heap[handle];
|
||
var data = heap[handle + 1];
|
||
return new TA(buffer, data, size);
|
||
}
|
||
name = readLatin1String(name);
|
||
registerType(rawType, {
|
||
name: name,
|
||
"fromWireType": decodeMemoryView,
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": decodeMemoryView
|
||
}, {
|
||
ignoreDuplicateRegistrations: true
|
||
});
|
||
}
|
||
function __embind_register_std_string(rawType, name) {
|
||
name = readLatin1String(name);
|
||
var stdStringIsUTF8 = name === "std::string";
|
||
registerType(rawType, {
|
||
name: name,
|
||
"fromWireType": function (value) {
|
||
var length = HEAPU32[value >> 2];
|
||
var payload = value + 4;
|
||
var str;
|
||
if (stdStringIsUTF8) {
|
||
var decodeStartPtr = payload;
|
||
for (var i = 0; i <= length; ++i) {
|
||
var currentBytePtr = payload + i;
|
||
if (i == length || HEAPU8[currentBytePtr] == 0) {
|
||
var maxRead = currentBytePtr - decodeStartPtr;
|
||
var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
|
||
if (str === undefined) {
|
||
str = stringSegment;
|
||
} else {
|
||
str += String.fromCharCode(0);
|
||
str += stringSegment;
|
||
}
|
||
decodeStartPtr = currentBytePtr + 1;
|
||
}
|
||
}
|
||
} else {
|
||
var a = new Array(length);
|
||
for (var i = 0; i < length; ++i) {
|
||
a[i] = String.fromCharCode(HEAPU8[payload + i]);
|
||
}
|
||
str = a.join("");
|
||
}
|
||
_free(value);
|
||
return str;
|
||
},
|
||
"toWireType": function (destructors, value) {
|
||
if (value instanceof ArrayBuffer) {
|
||
value = new Uint8Array(value);
|
||
}
|
||
var length;
|
||
var valueIsOfTypeString = typeof value == "string";
|
||
if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
|
||
throwBindingError("Cannot pass non-string to std::string");
|
||
}
|
||
if (stdStringIsUTF8 && valueIsOfTypeString) {
|
||
length = lengthBytesUTF8(value);
|
||
} else {
|
||
length = value.length;
|
||
}
|
||
var base = _malloc(4 + length + 1);
|
||
var ptr = base + 4;
|
||
HEAPU32[base >> 2] = length;
|
||
if (stdStringIsUTF8 && valueIsOfTypeString) {
|
||
stringToUTF8(value, ptr, length + 1);
|
||
} else {
|
||
if (valueIsOfTypeString) {
|
||
for (var i = 0; i < length; ++i) {
|
||
var charCode = value.charCodeAt(i);
|
||
if (charCode > 255) {
|
||
_free(ptr);
|
||
throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
|
||
}
|
||
HEAPU8[ptr + i] = charCode;
|
||
}
|
||
} else {
|
||
for (var i = 0; i < length; ++i) {
|
||
HEAPU8[ptr + i] = value[i];
|
||
}
|
||
}
|
||
}
|
||
if (destructors !== null) {
|
||
destructors.push(_free, base);
|
||
}
|
||
return base;
|
||
},
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": simpleReadValueFromPointer,
|
||
destructorFunction: function (ptr) {
|
||
_free(ptr);
|
||
}
|
||
});
|
||
}
|
||
var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;
|
||
function UTF16ToString(ptr, maxBytesToRead) {
|
||
var endPtr = ptr;
|
||
var idx = endPtr >> 1;
|
||
var maxIdx = idx + maxBytesToRead / 2;
|
||
while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
|
||
endPtr = idx << 1;
|
||
if (endPtr - ptr > 32 && UTF16Decoder) {
|
||
return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
|
||
} else {
|
||
var str = "";
|
||
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
|
||
var codeUnit = HEAP16[ptr + i * 2 >> 1];
|
||
if (codeUnit == 0) break;
|
||
str += String.fromCharCode(codeUnit);
|
||
}
|
||
return str;
|
||
}
|
||
}
|
||
function stringToUTF16(str, outPtr, maxBytesToWrite) {
|
||
if (maxBytesToWrite === undefined) {
|
||
maxBytesToWrite = 2147483647;
|
||
}
|
||
if (maxBytesToWrite < 2) return 0;
|
||
maxBytesToWrite -= 2;
|
||
var startPtr = outPtr;
|
||
var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
|
||
for (var i = 0; i < numCharsToWrite; ++i) {
|
||
var codeUnit = str.charCodeAt(i);
|
||
HEAP16[outPtr >> 1] = codeUnit;
|
||
outPtr += 2;
|
||
}
|
||
HEAP16[outPtr >> 1] = 0;
|
||
return outPtr - startPtr;
|
||
}
|
||
function lengthBytesUTF16(str) {
|
||
return str.length * 2;
|
||
}
|
||
function UTF32ToString(ptr, maxBytesToRead) {
|
||
var i = 0;
|
||
var str = "";
|
||
while (!(i >= maxBytesToRead / 4)) {
|
||
var utf32 = HEAP32[ptr + i * 4 >> 2];
|
||
if (utf32 == 0) break;
|
||
++i;
|
||
if (utf32 >= 65536) {
|
||
var ch = utf32 - 65536;
|
||
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
|
||
} else {
|
||
str += String.fromCharCode(utf32);
|
||
}
|
||
}
|
||
return str;
|
||
}
|
||
function stringToUTF32(str, outPtr, maxBytesToWrite) {
|
||
if (maxBytesToWrite === undefined) {
|
||
maxBytesToWrite = 2147483647;
|
||
}
|
||
if (maxBytesToWrite < 4) return 0;
|
||
var startPtr = outPtr;
|
||
var endPtr = startPtr + maxBytesToWrite - 4;
|
||
for (var i = 0; i < str.length; ++i) {
|
||
var codeUnit = str.charCodeAt(i);
|
||
if (codeUnit >= 55296 && codeUnit <= 57343) {
|
||
var trailSurrogate = str.charCodeAt(++i);
|
||
codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
|
||
}
|
||
HEAP32[outPtr >> 2] = codeUnit;
|
||
outPtr += 4;
|
||
if (outPtr + 4 > endPtr) break;
|
||
}
|
||
HEAP32[outPtr >> 2] = 0;
|
||
return outPtr - startPtr;
|
||
}
|
||
function lengthBytesUTF32(str) {
|
||
var len = 0;
|
||
for (var i = 0; i < str.length; ++i) {
|
||
var codeUnit = str.charCodeAt(i);
|
||
if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
|
||
len += 4;
|
||
}
|
||
return len;
|
||
}
|
||
function __embind_register_std_wstring(rawType, charSize, name) {
|
||
name = readLatin1String(name);
|
||
var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
|
||
if (charSize === 2) {
|
||
decodeString = UTF16ToString;
|
||
encodeString = stringToUTF16;
|
||
lengthBytesUTF = lengthBytesUTF16;
|
||
getHeap = () => HEAPU16;
|
||
shift = 1;
|
||
} else if (charSize === 4) {
|
||
decodeString = UTF32ToString;
|
||
encodeString = stringToUTF32;
|
||
lengthBytesUTF = lengthBytesUTF32;
|
||
getHeap = () => HEAPU32;
|
||
shift = 2;
|
||
}
|
||
registerType(rawType, {
|
||
name: name,
|
||
"fromWireType": function (value) {
|
||
var length = HEAPU32[value >> 2];
|
||
var HEAP = getHeap();
|
||
var str;
|
||
var decodeStartPtr = value + 4;
|
||
for (var i = 0; i <= length; ++i) {
|
||
var currentBytePtr = value + 4 + i * charSize;
|
||
if (i == length || HEAP[currentBytePtr >> shift] == 0) {
|
||
var maxReadBytes = currentBytePtr - decodeStartPtr;
|
||
var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
|
||
if (str === undefined) {
|
||
str = stringSegment;
|
||
} else {
|
||
str += String.fromCharCode(0);
|
||
str += stringSegment;
|
||
}
|
||
decodeStartPtr = currentBytePtr + charSize;
|
||
}
|
||
}
|
||
_free(value);
|
||
return str;
|
||
},
|
||
"toWireType": function (destructors, value) {
|
||
if (!(typeof value == "string")) {
|
||
throwBindingError("Cannot pass non-string to C++ string type " + name);
|
||
}
|
||
var length = lengthBytesUTF(value);
|
||
var ptr = _malloc(4 + length + charSize);
|
||
HEAPU32[ptr >> 2] = length >> shift;
|
||
encodeString(value, ptr + 4, length + charSize);
|
||
if (destructors !== null) {
|
||
destructors.push(_free, ptr);
|
||
}
|
||
return ptr;
|
||
},
|
||
"argPackAdvance": 8,
|
||
"readValueFromPointer": simpleReadValueFromPointer,
|
||
destructorFunction: function (ptr) {
|
||
_free(ptr);
|
||
}
|
||
});
|
||
}
|
||
function __embind_register_void(rawType, name) {
|
||
name = readLatin1String(name);
|
||
registerType(rawType, {
|
||
isVoid: true,
|
||
name: name,
|
||
"argPackAdvance": 0,
|
||
"fromWireType": function () {
|
||
return undefined;
|
||
},
|
||
"toWireType": function (destructors, o) {
|
||
return undefined;
|
||
}
|
||
});
|
||
}
|
||
function __emscripten_date_now() {
|
||
return Date.now();
|
||
}
|
||
var emval_symbols = {};
|
||
function getStringOrSymbol(address) {
|
||
var symbol = emval_symbols[address];
|
||
if (symbol === undefined) {
|
||
return readLatin1String(address);
|
||
}
|
||
return symbol;
|
||
}
|
||
var emval_methodCallers = [];
|
||
function __emval_call_void_method(caller, handle, methodName, args) {
|
||
caller = emval_methodCallers[caller];
|
||
handle = Emval.toValue(handle);
|
||
methodName = getStringOrSymbol(methodName);
|
||
caller(handle, methodName, null, args);
|
||
}
|
||
function emval_addMethodCaller(caller) {
|
||
var id = emval_methodCallers.length;
|
||
emval_methodCallers.push(caller);
|
||
return id;
|
||
}
|
||
function requireRegisteredType(rawType, humanName) {
|
||
var impl = registeredTypes[rawType];
|
||
if (undefined === impl) {
|
||
throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
|
||
}
|
||
return impl;
|
||
}
|
||
function emval_lookupTypes(argCount, argTypes) {
|
||
var a = new Array(argCount);
|
||
for (var i = 0; i < argCount; ++i) {
|
||
a[i] = requireRegisteredType(HEAPU32[argTypes + i * POINTER_SIZE >> 2], "parameter " + i);
|
||
}
|
||
return a;
|
||
}
|
||
var emval_registeredMethods = [];
|
||
function __emval_get_method_caller(argCount, argTypes) {
|
||
var types = emval_lookupTypes(argCount, argTypes);
|
||
var retType = types[0];
|
||
var signatureName = retType.name + "_$" + types.slice(1).map(function (t) {
|
||
return t.name;
|
||
}).join("_") + "$";
|
||
var returnId = emval_registeredMethods[signatureName];
|
||
if (returnId !== undefined) {
|
||
return returnId;
|
||
}
|
||
var params = ["retType"];
|
||
var args = [retType];
|
||
var argsList = "";
|
||
for (var i = 0; i < argCount - 1; ++i) {
|
||
argsList += (i !== 0 ? ", " : "") + "arg" + i;
|
||
params.push("argType" + i);
|
||
args.push(types[1 + i]);
|
||
}
|
||
var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
|
||
var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n";
|
||
var offset = 0;
|
||
for (var i = 0; i < argCount - 1; ++i) {
|
||
functionBody += " var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? "+" + offset : "") + ");\n";
|
||
offset += types[i + 1]["argPackAdvance"];
|
||
}
|
||
functionBody += " var rv = handle[name](" + argsList + ");\n";
|
||
for (var i = 0; i < argCount - 1; ++i) {
|
||
if (types[i + 1]["deleteObject"]) {
|
||
functionBody += " argType" + i + ".deleteObject(arg" + i + ");\n";
|
||
}
|
||
}
|
||
if (!retType.isVoid) {
|
||
functionBody += " return retType.toWireType(destructors, rv);\n";
|
||
}
|
||
functionBody += "};\n";
|
||
params.push(functionBody);
|
||
var invokerFunction = new_(Function, params).apply(null, args);
|
||
returnId = emval_addMethodCaller(invokerFunction);
|
||
emval_registeredMethods[signatureName] = returnId;
|
||
return returnId;
|
||
}
|
||
function _abort() {
|
||
abort("");
|
||
}
|
||
function _emscripten_memcpy_big(dest, src, num) {
|
||
HEAPU8.copyWithin(dest, src, src + num);
|
||
}
|
||
function abortOnCannotGrowMemory(requestedSize) {
|
||
abort("OOM");
|
||
}
|
||
function _emscripten_resize_heap(requestedSize) {
|
||
HEAPU8.length;
|
||
abortOnCannotGrowMemory();
|
||
}
|
||
var ENV = {};
|
||
function getExecutableName() {
|
||
return thisProgram || "./this.program";
|
||
}
|
||
function getEnvStrings() {
|
||
if (!getEnvStrings.strings) {
|
||
var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
|
||
var env = {
|
||
"USER": "web_user",
|
||
"LOGNAME": "web_user",
|
||
"PATH": "/",
|
||
"PWD": "/",
|
||
"HOME": "/home/web_user",
|
||
"LANG": lang,
|
||
"_": getExecutableName()
|
||
};
|
||
for (var x in ENV) {
|
||
if (ENV[x] === undefined) delete env[x];else env[x] = ENV[x];
|
||
}
|
||
var strings = [];
|
||
for (var x in env) {
|
||
strings.push(x + "=" + env[x]);
|
||
}
|
||
getEnvStrings.strings = strings;
|
||
}
|
||
return getEnvStrings.strings;
|
||
}
|
||
function writeAsciiToMemory(str, buffer, dontAddNull) {
|
||
for (var i = 0; i < str.length; ++i) {
|
||
HEAP8[buffer++ >> 0] = str.charCodeAt(i);
|
||
}
|
||
if (!dontAddNull) HEAP8[buffer >> 0] = 0;
|
||
}
|
||
function _environ_get(__environ, environ_buf) {
|
||
var bufSize = 0;
|
||
getEnvStrings().forEach(function (string, i) {
|
||
var ptr = environ_buf + bufSize;
|
||
HEAPU32[__environ + i * 4 >> 2] = ptr;
|
||
writeAsciiToMemory(string, ptr);
|
||
bufSize += string.length + 1;
|
||
});
|
||
return 0;
|
||
}
|
||
function _environ_sizes_get(penviron_count, penviron_buf_size) {
|
||
var strings = getEnvStrings();
|
||
HEAPU32[penviron_count >> 2] = strings.length;
|
||
var bufSize = 0;
|
||
strings.forEach(function (string) {
|
||
bufSize += string.length + 1;
|
||
});
|
||
HEAPU32[penviron_buf_size >> 2] = bufSize;
|
||
return 0;
|
||
}
|
||
function _fd_close(fd) {
|
||
try {
|
||
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
FS.close(stream);
|
||
return 0;
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return e.errno;
|
||
}
|
||
}
|
||
function _fd_fdstat_get(fd, pbuf) {
|
||
try {
|
||
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
|
||
HEAP8[pbuf >> 0] = type;
|
||
return 0;
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return e.errno;
|
||
}
|
||
}
|
||
function doReadv(stream, iov, iovcnt, offset) {
|
||
var ret = 0;
|
||
for (var i = 0; i < iovcnt; i++) {
|
||
var ptr = HEAPU32[iov >> 2];
|
||
var len = HEAPU32[iov + 4 >> 2];
|
||
iov += 8;
|
||
var curr = FS.read(stream, HEAP8, ptr, len, offset);
|
||
if (curr < 0) return -1;
|
||
ret += curr;
|
||
if (curr < len) break;
|
||
}
|
||
return ret;
|
||
}
|
||
function _fd_read(fd, iov, iovcnt, pnum) {
|
||
try {
|
||
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
var num = doReadv(stream, iov, iovcnt);
|
||
HEAP32[pnum >> 2] = num;
|
||
return 0;
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return e.errno;
|
||
}
|
||
}
|
||
function convertI32PairToI53Checked(lo, hi) {
|
||
return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
|
||
}
|
||
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
|
||
try {
|
||
var offset = convertI32PairToI53Checked(offset_low, offset_high);
|
||
if (isNaN(offset)) return 61;
|
||
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
FS.llseek(stream, offset, whence);
|
||
tempI64 = [stream.position >>> 0, (tempDouble = stream.position, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[newOffset >> 2] = tempI64[0], HEAP32[newOffset + 4 >> 2] = tempI64[1];
|
||
if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
|
||
return 0;
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return e.errno;
|
||
}
|
||
}
|
||
function doWritev(stream, iov, iovcnt, offset) {
|
||
var ret = 0;
|
||
for (var i = 0; i < iovcnt; i++) {
|
||
var ptr = HEAPU32[iov >> 2];
|
||
var len = HEAPU32[iov + 4 >> 2];
|
||
iov += 8;
|
||
var curr = FS.write(stream, HEAP8, ptr, len, offset);
|
||
if (curr < 0) return -1;
|
||
ret += curr;
|
||
}
|
||
return ret;
|
||
}
|
||
function _fd_write(fd, iov, iovcnt, pnum) {
|
||
try {
|
||
var stream = SYSCALLS.getStreamFromFD(fd);
|
||
var num = doWritev(stream, iov, iovcnt);
|
||
HEAPU32[pnum >> 2] = num;
|
||
return 0;
|
||
} catch (e) {
|
||
if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
|
||
return e.errno;
|
||
}
|
||
}
|
||
function _setTempRet0(val) {
|
||
}
|
||
var FSNode = function (parent, name, mode, rdev) {
|
||
if (!parent) {
|
||
parent = this;
|
||
}
|
||
this.parent = parent;
|
||
this.mount = parent.mount;
|
||
this.mounted = null;
|
||
this.id = FS.nextInode++;
|
||
this.name = name;
|
||
this.mode = mode;
|
||
this.node_ops = {};
|
||
this.stream_ops = {};
|
||
this.rdev = rdev;
|
||
};
|
||
var readMode = 292 | 73;
|
||
var writeMode = 146;
|
||
Object.defineProperties(FSNode.prototype, {
|
||
read: {
|
||
get: function () {
|
||
return (this.mode & readMode) === readMode;
|
||
},
|
||
set: function (val) {
|
||
val ? this.mode |= readMode : this.mode &= ~readMode;
|
||
}
|
||
},
|
||
write: {
|
||
get: function () {
|
||
return (this.mode & writeMode) === writeMode;
|
||
},
|
||
set: function (val) {
|
||
val ? this.mode |= writeMode : this.mode &= ~writeMode;
|
||
}
|
||
},
|
||
isFolder: {
|
||
get: function () {
|
||
return FS.isDir(this.mode);
|
||
}
|
||
},
|
||
isDevice: {
|
||
get: function () {
|
||
return FS.isChrdev(this.mode);
|
||
}
|
||
}
|
||
});
|
||
FS.FSNode = FSNode;
|
||
FS.staticInit();
|
||
embind_init_charCodes();
|
||
BindingError = Module["BindingError"] = extendError(Error, "BindingError");
|
||
InternalError = Module["InternalError"] = extendError(Error, "InternalError");
|
||
init_ClassHandle();
|
||
init_embind();
|
||
init_RegisteredPointer();
|
||
UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
|
||
init_emval();
|
||
var asmLibraryArg = {
|
||
"s": ___cxa_allocate_exception,
|
||
"r": ___cxa_throw,
|
||
"C": ___syscall_fcntl64,
|
||
"v": ___syscall_openat,
|
||
"u": __embind_register_bigint,
|
||
"E": __embind_register_bool,
|
||
"m": __embind_register_class,
|
||
"l": __embind_register_class_constructor,
|
||
"d": __embind_register_class_function,
|
||
"D": __embind_register_emval,
|
||
"o": __embind_register_float,
|
||
"c": __embind_register_integer,
|
||
"b": __embind_register_memory_view,
|
||
"p": __embind_register_std_string,
|
||
"k": __embind_register_std_wstring,
|
||
"q": __embind_register_void,
|
||
"j": __emscripten_date_now,
|
||
"g": __emval_call_void_method,
|
||
"e": __emval_decref,
|
||
"f": __emval_get_method_caller,
|
||
"a": _abort,
|
||
"z": _emscripten_memcpy_big,
|
||
"i": _emscripten_resize_heap,
|
||
"x": _environ_get,
|
||
"y": _environ_sizes_get,
|
||
"n": _fd_close,
|
||
"w": _fd_fdstat_get,
|
||
"B": _fd_read,
|
||
"t": _fd_seek,
|
||
"A": _fd_write,
|
||
"h": _setTempRet0
|
||
};
|
||
createWasm();
|
||
Module["___wasm_call_ctors"] = function () {
|
||
return (Module["___wasm_call_ctors"] = Module["asm"]["G"]).apply(null, arguments);
|
||
};
|
||
var _free = Module["_free"] = function () {
|
||
return (_free = Module["_free"] = Module["asm"]["H"]).apply(null, arguments);
|
||
};
|
||
var _malloc = Module["_malloc"] = function () {
|
||
return (_malloc = Module["_malloc"] = Module["asm"]["I"]).apply(null, arguments);
|
||
};
|
||
var ___errno_location = Module["___errno_location"] = function () {
|
||
return (___errno_location = Module["___errno_location"] = Module["asm"]["K"]).apply(null, arguments);
|
||
};
|
||
var ___getTypeName = Module["___getTypeName"] = function () {
|
||
return (___getTypeName = Module["___getTypeName"] = Module["asm"]["L"]).apply(null, arguments);
|
||
};
|
||
Module["___embind_register_native_and_builtin_types"] = function () {
|
||
return (Module["___embind_register_native_and_builtin_types"] = Module["asm"]["M"]).apply(null, arguments);
|
||
};
|
||
var _emscripten_builtin_memalign = Module["_emscripten_builtin_memalign"] = function () {
|
||
return (_emscripten_builtin_memalign = Module["_emscripten_builtin_memalign"] = Module["asm"]["N"]).apply(null, arguments);
|
||
};
|
||
var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = function () {
|
||
return (___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = Module["asm"]["O"]).apply(null, arguments);
|
||
};
|
||
Module["dynCall_viiijj"] = function () {
|
||
return (Module["dynCall_viiijj"] = Module["asm"]["P"]).apply(null, arguments);
|
||
};
|
||
Module["dynCall_jij"] = function () {
|
||
return (Module["dynCall_jij"] = Module["asm"]["Q"]).apply(null, arguments);
|
||
};
|
||
Module["dynCall_jii"] = function () {
|
||
return (Module["dynCall_jii"] = Module["asm"]["R"]).apply(null, arguments);
|
||
};
|
||
Module["dynCall_jiji"] = function () {
|
||
return (Module["dynCall_jiji"] = Module["asm"]["S"]).apply(null, arguments);
|
||
};
|
||
Module["_ff_h264_cabac_tables"] = 215420;
|
||
var calledRun;
|
||
dependenciesFulfilled = function runCaller() {
|
||
if (!calledRun) run();
|
||
if (!calledRun) dependenciesFulfilled = runCaller;
|
||
};
|
||
function run(args) {
|
||
if (runDependencies > 0) {
|
||
return;
|
||
}
|
||
preRun();
|
||
if (runDependencies > 0) {
|
||
return;
|
||
}
|
||
function doRun() {
|
||
if (calledRun) return;
|
||
calledRun = true;
|
||
Module["calledRun"] = true;
|
||
if (ABORT) return;
|
||
initRuntime();
|
||
if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
|
||
postRun();
|
||
}
|
||
if (Module["setStatus"]) {
|
||
Module["setStatus"]("Running...");
|
||
setTimeout(function () {
|
||
setTimeout(function () {
|
||
Module["setStatus"]("");
|
||
}, 1);
|
||
doRun();
|
||
}, 1);
|
||
} else {
|
||
doRun();
|
||
}
|
||
}
|
||
if (Module["preInit"]) {
|
||
if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
|
||
while (Module["preInit"].length > 0) {
|
||
Module["preInit"].pop()();
|
||
}
|
||
}
|
||
run();
|
||
module.exports = Module;
|
||
});
|
||
|
||
/**
|
||
* Common utilities
|
||
* @module glMatrix
|
||
*/
|
||
// Configuration Constants
|
||
var EPSILON = 0.000001;
|
||
var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
|
||
if (!Math.hypot) Math.hypot = function () {
|
||
var y = 0,
|
||
i = arguments.length;
|
||
|
||
while (i--) {
|
||
y += arguments[i] * arguments[i];
|
||
}
|
||
|
||
return Math.sqrt(y);
|
||
};
|
||
|
||
/**
|
||
* 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
|
||
* @module mat4
|
||
*/
|
||
|
||
/**
|
||
* Creates a new identity mat4
|
||
*
|
||
* @returns {mat4} a new 4x4 matrix
|
||
*/
|
||
|
||
function create$1() {
|
||
var out = new ARRAY_TYPE(16);
|
||
|
||
if (ARRAY_TYPE != Float32Array) {
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = 0;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
out[8] = 0;
|
||
out[9] = 0;
|
||
out[11] = 0;
|
||
out[12] = 0;
|
||
out[13] = 0;
|
||
out[14] = 0;
|
||
}
|
||
|
||
out[0] = 1;
|
||
out[5] = 1;
|
||
out[10] = 1;
|
||
out[15] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Set a mat4 to the identity matrix
|
||
*
|
||
* @param {mat4} out the receiving matrix
|
||
* @returns {mat4} out
|
||
*/
|
||
|
||
function identity(out) {
|
||
out[0] = 1;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = 0;
|
||
out[5] = 1;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
out[8] = 0;
|
||
out[9] = 0;
|
||
out[10] = 1;
|
||
out[11] = 0;
|
||
out[12] = 0;
|
||
out[13] = 0;
|
||
out[14] = 0;
|
||
out[15] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Generates a orthogonal projection matrix with the given bounds.
|
||
* The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],
|
||
* which matches WebGL/OpenGL's clip volume.
|
||
*
|
||
* @param {mat4} out mat4 frustum matrix will be written into
|
||
* @param {number} left Left bound of the frustum
|
||
* @param {number} right Right bound of the frustum
|
||
* @param {number} bottom Bottom bound of the frustum
|
||
* @param {number} top Top bound of the frustum
|
||
* @param {number} near Near bound of the frustum
|
||
* @param {number} far Far bound of the frustum
|
||
* @returns {mat4} out
|
||
*/
|
||
|
||
function orthoNO(out, left, right, bottom, top, near, far) {
|
||
var lr = 1 / (left - right);
|
||
var bt = 1 / (bottom - top);
|
||
var nf = 1 / (near - far);
|
||
out[0] = -2 * lr;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 0;
|
||
out[4] = 0;
|
||
out[5] = -2 * bt;
|
||
out[6] = 0;
|
||
out[7] = 0;
|
||
out[8] = 0;
|
||
out[9] = 0;
|
||
out[10] = 2 * nf;
|
||
out[11] = 0;
|
||
out[12] = (left + right) * lr;
|
||
out[13] = (top + bottom) * bt;
|
||
out[14] = (far + near) * nf;
|
||
out[15] = 1;
|
||
return out;
|
||
}
|
||
/**
|
||
* Alias for {@link mat4.orthoNO}
|
||
* @function
|
||
*/
|
||
|
||
var ortho = orthoNO;
|
||
/**
|
||
* Generates a look-at matrix with the given eye position, focal point, and up axis.
|
||
* If you want a matrix that actually makes an object look at another object, you should use targetTo instead.
|
||
*
|
||
* @param {mat4} out mat4 frustum matrix will be written into
|
||
* @param {ReadonlyVec3} eye Position of the viewer
|
||
* @param {ReadonlyVec3} center Point the viewer is looking at
|
||
* @param {ReadonlyVec3} up vec3 pointing up
|
||
* @returns {mat4} out
|
||
*/
|
||
|
||
function lookAt(out, eye, center, up) {
|
||
var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
|
||
var eyex = eye[0];
|
||
var eyey = eye[1];
|
||
var eyez = eye[2];
|
||
var upx = up[0];
|
||
var upy = up[1];
|
||
var upz = up[2];
|
||
var centerx = center[0];
|
||
var centery = center[1];
|
||
var centerz = center[2];
|
||
|
||
if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {
|
||
return identity(out);
|
||
}
|
||
|
||
z0 = eyex - centerx;
|
||
z1 = eyey - centery;
|
||
z2 = eyez - centerz;
|
||
len = 1 / Math.hypot(z0, z1, z2);
|
||
z0 *= len;
|
||
z1 *= len;
|
||
z2 *= len;
|
||
x0 = upy * z2 - upz * z1;
|
||
x1 = upz * z0 - upx * z2;
|
||
x2 = upx * z1 - upy * z0;
|
||
len = Math.hypot(x0, x1, x2);
|
||
|
||
if (!len) {
|
||
x0 = 0;
|
||
x1 = 0;
|
||
x2 = 0;
|
||
} else {
|
||
len = 1 / len;
|
||
x0 *= len;
|
||
x1 *= len;
|
||
x2 *= len;
|
||
}
|
||
|
||
y0 = z1 * x2 - z2 * x1;
|
||
y1 = z2 * x0 - z0 * x2;
|
||
y2 = z0 * x1 - z1 * x0;
|
||
len = Math.hypot(y0, y1, y2);
|
||
|
||
if (!len) {
|
||
y0 = 0;
|
||
y1 = 0;
|
||
y2 = 0;
|
||
} else {
|
||
len = 1 / len;
|
||
y0 *= len;
|
||
y1 *= len;
|
||
y2 *= len;
|
||
}
|
||
|
||
out[0] = x0;
|
||
out[1] = y0;
|
||
out[2] = z0;
|
||
out[3] = 0;
|
||
out[4] = x1;
|
||
out[5] = y1;
|
||
out[6] = z1;
|
||
out[7] = 0;
|
||
out[8] = x2;
|
||
out[9] = y2;
|
||
out[10] = z2;
|
||
out[11] = 0;
|
||
out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
|
||
out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
|
||
out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
|
||
out[15] = 1;
|
||
return out;
|
||
}
|
||
|
||
/**
|
||
* 3 Dimensional Vector
|
||
* @module vec3
|
||
*/
|
||
|
||
/**
|
||
* Creates a new, empty vec3
|
||
*
|
||
* @returns {vec3} a new 3D vector
|
||
*/
|
||
|
||
function create() {
|
||
var out = new ARRAY_TYPE(3);
|
||
|
||
if (ARRAY_TYPE != Float32Array) {
|
||
out[0] = 0;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
}
|
||
|
||
return out;
|
||
}
|
||
/**
|
||
* Creates a new vec3 initialized with the given values
|
||
*
|
||
* @param {Number} x X component
|
||
* @param {Number} y Y component
|
||
* @param {Number} z Z component
|
||
* @returns {vec3} a new 3D vector
|
||
*/
|
||
|
||
function fromValues(x, y, z) {
|
||
var out = new ARRAY_TYPE(3);
|
||
out[0] = x;
|
||
out[1] = y;
|
||
out[2] = z;
|
||
return out;
|
||
}
|
||
/**
|
||
* Perform some operation over an array of vec3s.
|
||
*
|
||
* @param {Array} a the array of vectors to iterate over
|
||
* @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed
|
||
* @param {Number} offset Number of elements to skip at the beginning of the array
|
||
* @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array
|
||
* @param {Function} fn Function to call for each vector in the array
|
||
* @param {Object} [arg] additional argument to pass to fn
|
||
* @returns {Array} a
|
||
* @function
|
||
*/
|
||
|
||
(function () {
|
||
var vec = create();
|
||
return function (a, stride, offset, count, fn, arg) {
|
||
var i, l;
|
||
|
||
if (!stride) {
|
||
stride = 3;
|
||
}
|
||
|
||
if (!offset) {
|
||
offset = 0;
|
||
}
|
||
|
||
if (count) {
|
||
l = Math.min(count * stride + offset, a.length);
|
||
} else {
|
||
l = a.length;
|
||
}
|
||
|
||
for (i = offset; i < l; i += stride) {
|
||
vec[0] = a[i];
|
||
vec[1] = a[i + 1];
|
||
vec[2] = a[i + 2];
|
||
fn(vec, vec, arg);
|
||
a[i] = vec[0];
|
||
a[i + 1] = vec[1];
|
||
a[i + 2] = vec[2];
|
||
}
|
||
|
||
return a;
|
||
};
|
||
})();
|
||
|
||
var createWebGL = ((gl, openWebglAlignment) => {
|
||
const vertexShaderScript = `
|
||
attribute vec4 aVertexPosition;
|
||
attribute vec2 aTexturePosition;
|
||
uniform mat4 uModelMatrix;
|
||
uniform mat4 uViewMatrix;
|
||
uniform mat4 uProjectionMatrix;
|
||
varying lowp vec2 vTexturePosition;
|
||
void main(void) {
|
||
gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * aVertexPosition;
|
||
vTexturePosition = aTexturePosition;
|
||
}
|
||
`;
|
||
const fragmentShaderScript = `
|
||
precision highp float;
|
||
varying highp vec2 vTexturePosition;
|
||
uniform int isyuv;
|
||
uniform sampler2D rgbaTexture;
|
||
uniform sampler2D yTexture;
|
||
uniform sampler2D uTexture;
|
||
uniform sampler2D vTexture;
|
||
|
||
const mat4 YUV2RGB = mat4( 1.1643828125, 0, 1.59602734375, -.87078515625,
|
||
1.1643828125, -.39176171875, -.81296875, .52959375,
|
||
1.1643828125, 2.017234375, 0, -1.081390625,
|
||
0, 0, 0, 1);
|
||
|
||
|
||
void main(void) {
|
||
|
||
if (isyuv>0) {
|
||
|
||
highp float y = texture2D(yTexture, vTexturePosition).r;
|
||
highp float u = texture2D(uTexture, vTexturePosition).r;
|
||
highp float v = texture2D(vTexture, vTexturePosition).r;
|
||
gl_FragColor = vec4(y, u, v, 1) * YUV2RGB;
|
||
|
||
} else {
|
||
gl_FragColor = texture2D(rgbaTexture, vTexturePosition);
|
||
}
|
||
}
|
||
`;
|
||
if (openWebglAlignment) {
|
||
gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
|
||
}
|
||
const shaderProgram = _initShaderProgram();
|
||
const _programInfo = {
|
||
program: shaderProgram,
|
||
attribLocations: {
|
||
vertexPosition: gl.getAttribLocation(shaderProgram, 'aVertexPosition'),
|
||
texturePosition: gl.getAttribLocation(shaderProgram, 'aTexturePosition')
|
||
},
|
||
uniformLocations: {
|
||
projectionMatrix: gl.getUniformLocation(shaderProgram, 'uProjectionMatrix'),
|
||
modelMatrix: gl.getUniformLocation(shaderProgram, 'uModelMatrix'),
|
||
viewMatrix: gl.getUniformLocation(shaderProgram, 'uViewMatrix'),
|
||
rgbatexture: gl.getUniformLocation(shaderProgram, 'rgbaTexture'),
|
||
ytexture: gl.getUniformLocation(shaderProgram, 'yTexture'),
|
||
utexture: gl.getUniformLocation(shaderProgram, 'uTexture'),
|
||
vtexture: gl.getUniformLocation(shaderProgram, 'vTexture'),
|
||
isyuv: gl.getUniformLocation(shaderProgram, 'isyuv')
|
||
}
|
||
};
|
||
const _buffers = _initBuffers();
|
||
const _rgbatexture = _createTexture();
|
||
const _ytexture = _createTexture();
|
||
const _utexture = _createTexture();
|
||
const _vtexture = _createTexture();
|
||
function _initBuffers() {
|
||
// Create a buffer for the cube's vertex positions.
|
||
const positionBuffer = gl.createBuffer();
|
||
|
||
// Select the positionBuffer as the one to apply buffer
|
||
// operations to from here out.
|
||
|
||
gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
|
||
|
||
// Now create an array of positions for the cube.
|
||
|
||
const positions = [
|
||
// Front face
|
||
-1.0, -1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0];
|
||
|
||
// Now pass the list of positions into WebGL to build the
|
||
// shape. We do this by creating a Float32Array from the
|
||
// JavaScript array, then use it to fill the current buffer.
|
||
|
||
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);
|
||
|
||
// Now set up the colors for the faces. We'll use solid colors
|
||
// for each face.
|
||
|
||
// const facePos = [
|
||
// [0.0, 0.0],
|
||
// [1.0, 0.0],
|
||
// [1.0, 1.0],
|
||
// [0.0, 1.0]
|
||
// ];
|
||
|
||
const facePos = [[0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [0.0, 0.0]];
|
||
|
||
// Convert the array of colors into a table for all the vertices.
|
||
|
||
var texturePos = [];
|
||
texturePos = texturePos.concat(...facePos);
|
||
const texpositionBuffer = gl.createBuffer();
|
||
gl.bindBuffer(gl.ARRAY_BUFFER, texpositionBuffer);
|
||
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(texturePos), gl.STATIC_DRAW);
|
||
|
||
// Build the element array buffer; this specifies the indices
|
||
// into the vertex arrays for each face's vertices.
|
||
|
||
const indexBuffer = gl.createBuffer();
|
||
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
|
||
|
||
// This array defines each face as two triangles, using the
|
||
// indices into the vertex array to specify each triangle's
|
||
// position.
|
||
|
||
const indices = [0, 1, 2, 0, 2, 3];
|
||
|
||
// Now send the element array to GL
|
||
|
||
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
|
||
return {
|
||
position: positionBuffer,
|
||
texPosition: texpositionBuffer,
|
||
indices: indexBuffer
|
||
};
|
||
}
|
||
function _createTexture() {
|
||
let texture = gl.createTexture();
|
||
gl.bindTexture(gl.TEXTURE_2D, texture);
|
||
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
|
||
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
|
||
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
|
||
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
|
||
return texture;
|
||
}
|
||
function _loadShader(type, source) {
|
||
const shader = gl.createShader(type);
|
||
|
||
// Send the source to the shader object
|
||
|
||
gl.shaderSource(shader, source);
|
||
|
||
// Compile the shader program
|
||
|
||
gl.compileShader(shader);
|
||
|
||
// See if it compiled successfully
|
||
|
||
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
|
||
console.log('An error occurred compiling the shaders: ' + gl.getShaderInfoLog(shader));
|
||
gl.deleteShader(shader);
|
||
return null;
|
||
}
|
||
return shader;
|
||
}
|
||
function _initShaderProgram() {
|
||
const vertexShader = _loadShader(gl.VERTEX_SHADER, vertexShaderScript);
|
||
const fragmentShader = _loadShader(gl.FRAGMENT_SHADER, fragmentShaderScript);
|
||
|
||
// Create the shader program
|
||
|
||
const shaderProgram = gl.createProgram();
|
||
gl.attachShader(shaderProgram, vertexShader);
|
||
gl.attachShader(shaderProgram, fragmentShader);
|
||
gl.linkProgram(shaderProgram);
|
||
|
||
// If creating the shader program failed, alert
|
||
|
||
if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
|
||
console.log('Unable to initialize the shader program: ' + gl.getProgramInfoLog(shaderProgram));
|
||
return null;
|
||
}
|
||
return shaderProgram;
|
||
}
|
||
function _drawScene(w, h) {
|
||
gl.viewport(0, 0, w, h);
|
||
gl.clearColor(0.0, 0.0, 0.0, 0.0); // Clear to black, fully opaque
|
||
gl.clearDepth(1.0); // Clear everything
|
||
gl.enable(gl.DEPTH_TEST); // Enable depth testing
|
||
gl.depthFunc(gl.LEQUAL); // Near things obscure far things
|
||
|
||
// Clear the canvas before we start drawing on it.
|
||
|
||
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
|
||
const zNear = 0.1;
|
||
const zFar = 100.0;
|
||
const projectionMatrix = create$1();
|
||
ortho(projectionMatrix, -1, 1, -1, 1, zNear, zFar);
|
||
|
||
// Set the drawing position to the "identity" point, which is
|
||
// the center of the scene.
|
||
const modelMatrix = create$1();
|
||
identity(modelMatrix);
|
||
const viewMatrix = create$1();
|
||
lookAt(viewMatrix, fromValues(0, 0, 0), fromValues(0, 0, -1), fromValues(0, 1, 0));
|
||
|
||
// Tell WebGL how to pull out the positions from the position
|
||
// buffer into the vertexPosition attribute
|
||
{
|
||
const numComponents = 3;
|
||
const type = gl.FLOAT;
|
||
const normalize = false;
|
||
const stride = 0;
|
||
const offset = 0;
|
||
gl.bindBuffer(gl.ARRAY_BUFFER, _buffers.position);
|
||
gl.vertexAttribPointer(_programInfo.attribLocations.vertexPosition, numComponents, type, normalize, stride, offset);
|
||
gl.enableVertexAttribArray(_programInfo.attribLocations.vertexPosition);
|
||
}
|
||
|
||
// Tell WebGL how to pull out the colors from the color buffer
|
||
// into the vertexColor attribute.
|
||
{
|
||
const numComponents = 2;
|
||
const type = gl.FLOAT;
|
||
const normalize = false;
|
||
const stride = 0;
|
||
const offset = 0;
|
||
gl.bindBuffer(gl.ARRAY_BUFFER, _buffers.texPosition);
|
||
gl.vertexAttribPointer(_programInfo.attribLocations.texturePosition, numComponents, type, normalize, stride, offset);
|
||
gl.enableVertexAttribArray(_programInfo.attribLocations.texturePosition);
|
||
}
|
||
let rgbatextunit = 2;
|
||
let ytextunit = rgbatextunit + 1;
|
||
let utextunit = rgbatextunit + 2;
|
||
let vtextunit = rgbatextunit + 3;
|
||
gl.activeTexture(gl.TEXTURE0 + ytextunit);
|
||
gl.bindTexture(gl.TEXTURE_2D, _ytexture);
|
||
gl.activeTexture(gl.TEXTURE0 + utextunit);
|
||
gl.bindTexture(gl.TEXTURE_2D, _utexture);
|
||
gl.activeTexture(gl.TEXTURE0 + vtextunit);
|
||
gl.bindTexture(gl.TEXTURE_2D, _vtexture);
|
||
|
||
// Tell WebGL which indices to use to index the vertices
|
||
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, _buffers.indices);
|
||
|
||
// Tell WebGL to use our program when drawing
|
||
|
||
gl.useProgram(_programInfo.program);
|
||
|
||
// Set the shader uniforms
|
||
|
||
gl.uniformMatrix4fv(_programInfo.uniformLocations.projectionMatrix, false, projectionMatrix);
|
||
gl.uniformMatrix4fv(_programInfo.uniformLocations.modelMatrix, false, modelMatrix);
|
||
gl.uniformMatrix4fv(_programInfo.uniformLocations.viewMatrix, false, viewMatrix);
|
||
gl.uniform1i(_programInfo.uniformLocations.rgbatexture, rgbatextunit);
|
||
gl.uniform1i(_programInfo.uniformLocations.ytexture, ytextunit);
|
||
gl.uniform1i(_programInfo.uniformLocations.utexture, utextunit);
|
||
gl.uniform1i(_programInfo.uniformLocations.vtexture, vtextunit);
|
||
gl.uniform1i(_programInfo.uniformLocations.isyuv, 1);
|
||
{
|
||
const vertexCount = 6;
|
||
const type = gl.UNSIGNED_SHORT;
|
||
const offset = 0;
|
||
gl.drawElements(gl.TRIANGLES, vertexCount, type, offset);
|
||
}
|
||
|
||
// Update the rotation for the next draw
|
||
}
|
||
|
||
return {
|
||
render: function (width, height, y, u, v) {
|
||
gl.activeTexture(gl.TEXTURE0);
|
||
gl.bindTexture(gl.TEXTURE_2D, _ytexture);
|
||
gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width, height, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, y);
|
||
gl.activeTexture(gl.TEXTURE1);
|
||
gl.bindTexture(gl.TEXTURE_2D, _utexture);
|
||
gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width / 2, height / 2, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, u);
|
||
gl.activeTexture(gl.TEXTURE2);
|
||
gl.bindTexture(gl.TEXTURE_2D, _vtexture);
|
||
gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width / 2, height / 2, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, v);
|
||
_drawScene(width, height);
|
||
},
|
||
renderYUV: function (width, height, data) {
|
||
let y = data.slice(0, width * height);
|
||
let u = data.slice(width * height, width * height * 5 / 4);
|
||
let v = data.slice(width * height * 5 / 4, width * height * 3 / 2);
|
||
gl.activeTexture(gl.TEXTURE0);
|
||
gl.bindTexture(gl.TEXTURE_2D, _ytexture);
|
||
gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width, height, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, y);
|
||
gl.activeTexture(gl.TEXTURE1);
|
||
gl.bindTexture(gl.TEXTURE_2D, _utexture);
|
||
gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width / 2, height / 2, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, u);
|
||
gl.activeTexture(gl.TEXTURE2);
|
||
gl.bindTexture(gl.TEXTURE_2D, _vtexture);
|
||
gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width / 2, height / 2, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, v);
|
||
_drawScene(width, height);
|
||
},
|
||
destroy: function () {
|
||
gl.deleteProgram(_programInfo.program);
|
||
gl.deleteBuffer(_buffers.position);
|
||
gl.deleteBuffer(_buffers.texPosition);
|
||
gl.deleteBuffer(_buffers.indices);
|
||
gl.deleteTexture(_rgbatexture);
|
||
gl.deleteTexture(_ytexture);
|
||
gl.deleteTexture(_utexture);
|
||
gl.deleteTexture(_vtexture);
|
||
}
|
||
};
|
||
});
|
||
|
||
// 播放协议
|
||
const PLAYER_PLAY_PROTOCOL = {
|
||
websocket: 1,
|
||
fetch: 2,
|
||
hls: 3,
|
||
webrtc: 4,
|
||
webTransport: 5
|
||
};
|
||
|
||
// 播放
|
||
const PLAY_TYPE = {
|
||
player: "player",
|
||
playbackTF: 'playbackTF'
|
||
};
|
||
const FILE_SUFFIX = {
|
||
mp4: 'mp4',
|
||
webm: 'webm'
|
||
};
|
||
const DEMUX_TYPE = {
|
||
flv: 'flv',
|
||
m7s: 'm7s',
|
||
hls: 'hls',
|
||
webrtc: 'webrtc',
|
||
webTransport: 'webTransport',
|
||
nakedFlow: 'nakedFlow'
|
||
};
|
||
const DEBUG_LEVEL = {
|
||
debug: 'debug',
|
||
warn: 'warn'
|
||
};
|
||
const PTZ_ACTIVE_EVENT_TYPE = {
|
||
click: 'click',
|
||
mouseDownAndUp: 'mouseDownAndUp'
|
||
};
|
||
const DEFAULT_PLAYBACK_FORWARD_MAX_RATE_DECODE_IFRAME = 4; // default playback forward max rate decode iframe
|
||
|
||
const FRAME_TS_MAX_DIFF = 1000 * 60 * 60; // 1 hour
|
||
|
||
const SIMD_H264_DECODE_MAX_WIDTH = 4080;
|
||
|
||
// default player options
|
||
const DEFAULT_PLAYER_OPTIONS = {
|
||
playType: PLAY_TYPE.player,
|
||
//
|
||
container: '',
|
||
//
|
||
videoBuffer: 1 * 1000,
|
||
// 1* 1000ms == 1 second
|
||
videoBufferDelay: 1 * 1000,
|
||
// 1 * 1000ms
|
||
networkDelay: 10 * 1000,
|
||
// 10 * 1000ms
|
||
isResize: true,
|
||
//
|
||
isFullResize: false,
|
||
// full resize
|
||
isFlv: false,
|
||
// flv
|
||
isHls: false,
|
||
// hls（inner）
|
||
isWebrtc: false,
|
||
// webrtc (inner)
|
||
isWebrtcForZLM: false,
|
||
// webrtc for ZLM (inner)
|
||
isNakedFlow: false,
|
||
// 是否是裸流（264、265）
|
||
debug: false,
|
||
// debug log
|
||
debugLevel: DEBUG_LEVEL.warn,
|
||
// log level
|
||
debugUuid: '',
|
||
// debug uuid (inner)
|
||
isMulti: false,
|
||
// 是否多实例播放
|
||
hotKey: false,
|
||
// 快捷键
|
||
loadingTimeout: 10,
|
||
// loading timeout
|
||
heartTimeout: 10,
|
||
// heart timeout
|
||
timeout: 10,
|
||
// second
|
||
pageVisibilityHiddenTimeout: 5 * 60,
|
||
// 5 * 60 = 5 minute
|
||
loadingTimeoutReplay: true,
|
||
// loading timeout replay
|
||
heartTimeoutReplay: true,
|
||
// heart timeout replay。
|
||
loadingTimeoutReplayTimes: 3,
|
||
// loading timeout replay fail times
|
||
heartTimeoutReplayTimes: 3,
|
||
// heart timeout replay fail times
|
||
heartTimeoutReplayUseLastFrameShow: false,
|
||
// heart timeout replay use last frame
|
||
supportDblclickFullscreen: false,
|
||
showBandwidth: false,
|
||
//
|
||
showPerformance: false,
|
||
// 是否显示性能面板
|
||
keepScreenOn: true,
|
||
isNotMute: false,
|
||
hasAudio: true,
|
||
hasVideo: true,
|
||
operateBtns: {
|
||
fullscreen: false,
|
||
screenshot: false,
|
||
play: false,
|
||
audio: false,
|
||
record: false,
|
||
ptz: false,
|
||
quality: false,
|
||
zoom: false,
|
||
close: false,
|
||
scale: false,
|
||
performance: false,
|
||
aiFace: false,
|
||
aiObject: false,
|
||
fullscreenFn: null,
|
||
fullscreenExitFn: null,
|
||
screenshotFn: null,
|
||
playFn: null,
|
||
pauseFn: null,
|
||
recordFn: null,
|
||
recordStopFn: null
|
||
},
|
||
extendOperateBtns: [],
|
||
contextmenuBtns: [],
|
||
watermarkConfig: {},
|
||
// 局部水印设置
|
||
controlAutoHide: false,
|
||
hasControl: false,
|
||
// 内部参数
|
||
loadingIcon: true,
|
||
loadingText: '',
|
||
background: '',
|
||
backgroundLoadingShow: false,
|
||
// 加载过程中是否显示背景
|
||
loadingBackground: '',
|
||
// 内部参数 重新播放过程中，显示播放失败前的最后一帧数据。
|
||
decoder: 'decoder-pro.js',
|
||
decoderWASM: '',
|
||
url: '',
|
||
// 内部参数
|
||
rotate: 0,
|
||
mirrorRotate: 'none',
|
||
// 镜像xx
|
||
playbackConfig: {
|
||
playList: [],
|
||
// {start:xx,end:xx}
|
||
fps: '',
|
||
// fps值
|
||
showControl: true,
|
||
showRateBtn: false,
|
||
rateConfig: [],
|
||
// 播放倍率切换，支持[{label:'正常',value:1},{label:'2倍',value:2}]
|
||
isCacheBeforeDecodeForFpsRender: false,
|
||
// rfs渲染时，是否在解码前缓存数据
|
||
uiUsePlaybackPause: false,
|
||
// ui上面是否使用 playbackPause 方法
|
||
isPlaybackPauseClearCache: true,
|
||
// playbackPause是否清除缓存数据
|
||
isUseFpsRender: false,
|
||
// 是否使用固定的fps渲染，如果设置的fps小于流推过来的，会造成内存堆积甚至溢出
|
||
isUseLocalCalculateTime: false,
|
||
// 是否使用本地时间来计算playback时间
|
||
localOneFrameTimestamp: 40,
|
||
// 一帧 40ms, isUseLocalCalculateTime 为 true 生效。
|
||
supportWheel: false // 是否支持滚动轴切换精度。
|
||
},
|
||
|
||
qualityConfig: [],
|
||
// 支持 ['高清','超清','4K']
|
||
defaultStreamQuality: '',
|
||
scaleConfig: ['拉伸', '缩放', '正常'],
|
||
// text: '',
|
||
forceNoOffscreen: true,
|
||
// 默认是不采用
|
||
hiddenAutoPause: false,
|
||
protocol: PLAYER_PLAY_PROTOCOL.fetch,
|
||
// 内部参数
|
||
demuxType: DEMUX_TYPE.flv,
|
||
// 内部参数
|
||
useWasm: false,
|
||
//wasm 解码 （inner）默认
|
||
useWCS: false,
|
||
//
|
||
useSIMD: true,
|
||
// pro 默认优先使用wasm simd解码，不支持则使用wasm解码
|
||
wcsUseVideoRender: true,
|
||
// wcs 是否使用 video 渲染
|
||
wasmUseVideoRender: true,
|
||
// wasm 用video标签渲染
|
||
mseUseCanvasRender: false,
|
||
//mse 用canvas标签渲染
|
||
hlsUseCanvasRender: false,
|
||
// hls 用canvas标签渲染
|
||
useMSE: false,
|
||
//
|
||
useOffscreen: false,
|
||
// 内部参数
|
||
mseDecodeErrorReplay: true,
|
||
// mse 解码失败重新播放
|
||
wcsDecodeErrorReplay: true,
|
||
// wcs 解码失败重新播放
|
||
wasmDecodeErrorReplay: true,
|
||
// 解码失败重新播放。
|
||
autoWasm: true,
|
||
// 自动降级到 wasm 模式
|
||
webglAlignmentErrorReplay: true,
|
||
// webgl对齐失败重新播放。
|
||
openWebglAlignment: false,
|
||
// https://github.com/langhuihui/jessibuca/issues/152
|
||
syncAudioAndVideo: false,
|
||
// 音视频同步
|
||
// playback config
|
||
playbackDelayTime: 1000,
|
||
// TF卡流播放延迟时间 Inner
|
||
playbackFps: 25,
|
||
// Inner
|
||
playbackForwardMaxRateDecodeIFrame: DEFAULT_PLAYBACK_FORWARD_MAX_RATE_DECODE_IFRAME,
|
||
// max rate render i frame , Inner
|
||
playbackCurrentTimeMove: true,
|
||
// Inner
|
||
|
||
useVideoRender: true,
|
||
// 使用video标签渲染
|
||
useCanvasRender: false,
|
||
// 使用canvas渲染
|
||
networkDelayTimeoutReplay: false,
|
||
// 网络延迟重连
|
||
recordType: FILE_SUFFIX.mp4,
|
||
checkFirstIFrame: true,
|
||
// 检查第一帧是否是I帧
|
||
nakedFlowFps: 25,
|
||
// 裸流fps
|
||
audioEngine: null,
|
||
// 音频引擎
|
||
isShowRecordingUI: true,
|
||
// 是否显示录制中
|
||
isShowZoomingUI: true,
|
||
// 是否显示缩放中
|
||
useFaceDetector: false,
|
||
// 使用人脸检测
|
||
useObjectDetector: false,
|
||
// 使用物体检测
|
||
ptzClickType: PTZ_ACTIVE_EVENT_TYPE.click,
|
||
// PTZ 点击类型
|
||
// 微信安卓音频播放块大小
|
||
// 计算规则 48000 * ms / 1000 = size,
|
||
// 48000 * 200 /1000 = 9600 播放时长200ms
|
||
// 48000 * 175 /1000 = 8400 播放时长175ms
|
||
// 48000 * 150 /1000 = 7200 播放时长150ms
|
||
// 48000 * 125 /1000 = 6000 播放时长125ms
|
||
// 48000 * 100 /1000 = 4800 播放时长100ms default
|
||
// 48000 * 50 /1000 = 2400 播放时长50ms
|
||
// 48000 * 25 /1000 = 1200 播放时长25ms
|
||
// 48000 * 10 /1000 = 480 播放时长10ms
|
||
weiXinInAndroidAudioBufferSize: 4800,
|
||
isCrypto: false,
|
||
// 是否加密
|
||
cryptoKey: '',
|
||
// 加密key
|
||
cryptoIV: '',
|
||
// 加密iv
|
||
cryptoKeyUrl: '',
|
||
// 加密key获取域名
|
||
autoResize: false,
|
||
// 自动调整大小 inner
|
||
useWebFullScreen: false,
|
||
// 使用web全屏(旋转播放器90度)(只会在移动端生效)
|
||
ptsMaxDiff: 60 * 60,
|
||
//单位(秒)，默认值是1H
|
||
aiFaceDetectWidth: 192,
|
||
// 人脸检测宽度
|
||
aiObjectDetectWidth: 192,
|
||
// 物体检测宽度
|
||
videoRenderSupportScale: true,
|
||
// video渲染支持Scale
|
||
mediaSourceTsIsMaxDiffReplay: true // 当ts间隔超过最大值之后，重新播放
|
||
};
|
||
|
||
const WORKER_CMD_TYPE = {
|
||
init: 'init',
|
||
initVideo: 'initVideo',
|
||
render: 'render',
|
||
playAudio: 'playAudio',
|
||
initAudio: 'initAudio',
|
||
kBps: 'kBps',
|
||
decode: 'decode',
|
||
audioCode: 'audioCode',
|
||
videoCode: 'videoCode',
|
||
videoCodec: 'videoCodec',
|
||
videoNalu: 'videoNalu',
|
||
wasmError: 'wasmError',
|
||
workerFetch: 'workerFetch',
|
||
iframeIntervalTs: 'iframeIntervalTs',
|
||
workerEnd: 'workerEnd',
|
||
networkDelay: 'networkDelay',
|
||
playbackStreamVideoFps: 'playbackStreamVideoFps',
|
||
wasmDecodeVideoNoResponseError: 'wasmDecodeVideoNoResponseError',
|
||
simdH264DecodeVideoWidthIsTooLarge: 'simdH264DecodeVideoWidthIsTooLarge',
|
||
websocketOpen: 'websocketOpen',
|
||
closeEnd: 'closeEnd'
|
||
};
|
||
|
||
const MEDIA_TYPE = {
|
||
audio: 1,
|
||
video: 2
|
||
};
|
||
const FLV_MEDIA_TYPE = {
|
||
audio: 8,
|
||
video: 9,
|
||
scriptData: 18
|
||
};
|
||
const WORKER_SEND_TYPE = {
|
||
init: 'init',
|
||
decode: 'decode',
|
||
audioDecode: 'audioDecode',
|
||
videoDecode: 'videoDecode',
|
||
initAudioCodec: 'initAudioCodec',
|
||
initVideoCodec: 'initVideoCodec',
|
||
close: 'close',
|
||
updateConfig: 'updateConfig',
|
||
resetDecode: 'resetDecode',
|
||
clearBuffer: 'clearBuffer',
|
||
resetAudioDecode: 'resetAudioDecode',
|
||
resetVideoDecode: 'resetVideoDecode',
|
||
fetchStream: 'fetchStream',
|
||
sendWsMessage: 'sendWsMessage'
|
||
};
|
||
|
||
// inner events
|
||
const EVENTS = {
|
||
fullscreen: 'fullscreen$2',
|
||
webFullscreen: 'webFullscreen',
|
||
decoderWorkerInit: 'decoderWorkerInit',
|
||
play: 'play',
|
||
playing: 'playing',
|
||
pause: 'pause',
|
||
mute: 'mute',
|
||
load: 'load',
|
||
loading: 'loading',
|
||
zooming: 'zooming',
|
||
videoInfo: 'videoInfo',
|
||
timeUpdate: 'timeUpdate',
|
||
audioInfo: "audioInfo",
|
||
log: 'log',
|
||
error: "error",
|
||
kBps: 'kBps',
|
||
timeout: 'timeout',
|
||
delayTimeout: 'delayTimeout',
|
||
delayTimeoutRetryEnd: 'delayTimeoutRetryEnd',
|
||
loadingTimeout: 'loadingTimeout',
|
||
loadingTimeoutRetryEnd: 'loadingTimeoutRetryEnd',
|
||
stats: 'stats',
|
||
performance: "performance",
|
||
faceDetectActive: 'faceDetectActive',
|
||
objectDetectActive: 'objectDetectActive',
|
||
// record
|
||
record: 'record',
|
||
recording: 'recording',
|
||
recordingTimestamp: 'recordingTimestamp',
|
||
recordStart: 'recordStart',
|
||
recordEnd: 'recordEnd',
|
||
recordCreateError: 'recordCreateError',
|
||
recordBlob: 'recordBlob',
|
||
buffer: 'buffer',
|
||
videoFrame: 'videoFrame',
|
||
start: 'start',
|
||
metadata: 'metadata',
|
||
resize: 'resize',
|
||
volumechange: 'volumechange',
|
||
destroy: 'destroy',
|
||
beforeDestroy: 'beforeDestroy',
|
||
// stream
|
||
streamEnd: 'streamEnd',
|
||
streamRate: 'streamRate',
|
||
streamAbps: 'streamAbps',
|
||
streamVbps: 'streamVbps',
|
||
streamDts: 'streamDts',
|
||
streamSuccess: 'streamSuccess',
|
||
streamMessage: 'streamMessage',
|
||
streamError: 'streamError',
|
||
streamStats: 'streamStats',
|
||
// MSE
|
||
mseSourceOpen: 'mseSourceOpen',
|
||
mseSourceClose: 'mseSourceClose',
|
||
mseSourceended: 'mseSourceended',
|
||
mseSourceBufferError: 'mseSourceBufferError',
|
||
mseSourceBufferBusy: 'mseSourceBufferBusy',
|
||
mseSourceBufferFull: 'mseSourceBufferFull',
|
||
// VIDEO
|
||
videoWaiting: 'videoWaiting',
|
||
videoTimeUpdate: 'videoTimeUpdate',
|
||
videoSyncAudio: 'videoSyncAudio',
|
||
//
|
||
playToRenderTimes: 'playToRenderTimes',
|
||
playbackTime: 'playbackTime',
|
||
playbackTimestamp: 'playbackTimestamp',
|
||
playbackPrecision: 'playbackPrecision',
|
||
playbackJustTime: 'playbackJustTime',
|
||
playbackStats: 'playbackStats',
|
||
playbackSeek: 'playbackSeek',
|
||
playbackPause: 'playbackPause',
|
||
playbackPauseOrResume: 'playbackPauseOrResume',
|
||
playbackRateChange: 'playbackRateChange',
|
||
playbackPreRateChange: 'playbackPreRateChange',
|
||
ptz: 'ptz',
|
||
streamQualityChange: 'streamQualityChange',
|
||
visibilityChange: "visibilityChange",
|
||
netBuf: 'netBuf',
|
||
close: 'close',
|
||
networkDelayTimeout: 'networkDelayTimeout',
|
||
togglePerformancePanel: 'togglePerformancePanel',
|
||
viewResizeChange: 'viewResizeChange',
|
||
flvDemuxBufferSizeTooLarge: 'flvDemuxBufferSizeTooLarge',
|
||
// talk
|
||
talkGetUserMediaSuccess: 'talkGetUserMediaSuccess',
|
||
talkGetUserMediaFail: 'talkGetUserMediaFail',
|
||
talkGetUserMediaTimeout: 'talkGetUserMediaTimeout',
|
||
talkStreamStart: 'talkStreamStart',
|
||
talkStreamOpen: 'talkStreamOpen',
|
||
talkStreamClose: 'talkStreamClose',
|
||
talkStreamError: 'talkStreamError',
|
||
talkStreamInactive: 'talkStreamInactive',
|
||
webrtcDisconnect: 'webrtcDisconnect',
|
||
webrtcFailed: 'webrtcFailed',
|
||
webrtcClosed: 'webrtcClosed',
|
||
// crash
|
||
crashLog: 'crashLog',
|
||
// dom
|
||
focus: 'focus',
|
||
blur: 'blur',
|
||
visibilityHiddenTimeout: 'visibilityHiddenTimeout',
|
||
// websocket
|
||
websocketOpen: 'websocketOpen',
|
||
websocketClose: 'websocketClose',
|
||
websocketError: 'websocketError',
|
||
websocketMessage: 'websocketMessage',
|
||
// ai
|
||
|
||
aiObjectDetectorInfo: 'aiObjectDetectorInfo',
|
||
aiFaceDetector: 'aiFaceDetector',
|
||
//
|
||
playFailedAndPaused: 'playFailedAndPaused'
|
||
};
|
||
const EVENTS_ERROR = {
|
||
playError: 'playIsNotPauseOrUrlIsNull',
|
||
fetchError: "fetchError",
|
||
websocketError: 'websocketError',
|
||
webcodecsH265NotSupport: 'webcodecsH265NotSupport',
|
||
webcodecsDecodeError: 'webcodecsDecodeError',
|
||
mediaSourceH265NotSupport: 'mediaSourceH265NotSupport',
|
||
mediaSourceDecoderConfigurationError: 'mediaSourceDecoderConfigurationError',
|
||
mediaSourceFull: EVENTS.mseSourceBufferFull,
|
||
mseSourceBufferError: EVENTS.mseSourceBufferError,
|
||
mediaSourceAppendBufferError: 'mediaSourceAppendBufferError',
|
||
mediaSourceBufferListLarge: 'mediaSourceBufferListLarge',
|
||
mediaSourceAppendBufferEndTimeout: 'mediaSourceAppendBufferEndTimeout',
|
||
mediaSourceTsIsMaxDiff: 'mediaSourceTsIsMaxDiff',
|
||
wasmDecodeError: 'wasmDecodeError',
|
||
hlsError: 'hlsError',
|
||
webrtcError: 'webrtcError',
|
||
webglAlignmentError: 'webglAlignmentError',
|
||
webcodecsWidthOrHeightChange: 'webcodecsWidthOrHeightChange',
|
||
tallWebsocketClosedByError: 'tallWebsocketClosedByError',
|
||
flvDemuxBufferSizeTooLarge: EVENTS.flvDemuxBufferSizeTooLarge,
|
||
wasmDecodeVideoNoResponseError: 'wasmDecodeVideoNoResponseError',
|
||
audioChannelError: 'audioChannelError',
|
||
simdH264DecodeVideoWidthIsTooLarge: 'simdH264DecodeVideoWidthIsTooLarge'
|
||
};
|
||
const WEBSOCKET_STATUS_CODE = {
|
||
connecting: 0,
|
||
open: 1,
|
||
closing: 2,
|
||
closed: 3
|
||
};
|
||
|
||
const VIDEO_ENC_CODE = {
|
||
h264: 7,
|
||
h265: 12
|
||
};
|
||
const VIDEO_ENC_TYPE_SHOW = {
|
||
h264: 'H264(AVC)',
|
||
h265: 'H265(HEVC)'
|
||
};
|
||
const AUDIO_ENC_CODE = {
|
||
AAC: 10,
|
||
ALAW: 7,
|
||
MULAW: 8,
|
||
MP3: 2
|
||
};
|
||
const H264_NAL_TYPE = {
|
||
sps: 7,
|
||
pps: 8,
|
||
iFrame: 5,
|
||
kUnspecified: 0,
|
||
kSliceNonIDR: 1,
|
||
kSliceDPA: 2,
|
||
kSliceDPB: 3,
|
||
kSliceDPC: 4,
|
||
kSliceIDR: 5,
|
||
kSliceSEI: 6,
|
||
kSliceSPS: 7,
|
||
kSlicePPS: 8,
|
||
kSliceAUD: 9,
|
||
kEndOfSequence: 10,
|
||
kEndOfStream: 11,
|
||
kFiller: 12,
|
||
kSPSExt: 13,
|
||
kReserved0: 14
|
||
};
|
||
const H265_NAL_TYPE = {
|
||
vps: 32,
|
||
// 语义为视频参数集
|
||
sps: 33,
|
||
// 语义为序列参数集
|
||
pps: 34,
|
||
// 语义为图像参数集
|
||
sei: 39 //SEI 语义为补充增强信息
|
||
//iFrame: 19, // 语义为可能有RADL图像的IDR图像的SS编码数据 IDR
|
||
//pFrame: 1, // 语义为被参考的后置图像，且非TSA、非STSA的SS编码数据
|
||
//nLp: 20, // kSliceIDR_N_LP
|
||
};
|
||
const ENCODED_VIDEO_TYPE = {
|
||
key: 'key',
|
||
delta: 'delta'
|
||
};
|
||
const FETCH_ERROR = {
|
||
abortError: 'The user aborted a request',
|
||
abortError2: 'AbortError',
|
||
abort: 'AbortError'
|
||
};
|
||
const AVC_PACKET_TYPE = {
|
||
sequenceHeader: 0,
|
||
nalu: 1
|
||
};
|
||
const FRAME_TYPE = {
|
||
keyFrame: 1,
|
||
interFrame: 2
|
||
};
|
||
|
||
var screenfull = createCommonjsModule(function (module) {
|
||
/*!
|
||
* screenfull
|
||
* v5.1.0 - 2020-12-24
|
||
* (c) Sindre Sorhus; MIT License
|
||
*/
|
||
(function () {
|
||
|
||
var document = typeof window !== 'undefined' && typeof window.document !== 'undefined' ? window.document : {};
|
||
var isCommonjs = module.exports;
|
||
|
||
var fn = (function () {
|
||
var val;
|
||
|
||
var fnMap = [
|
||
[
|
||
'requestFullscreen',
|
||
'exitFullscreen',
|
||
'fullscreenElement',
|
||
'fullscreenEnabled',
|
||
'fullscreenchange',
|
||
'fullscreenerror'
|
||
],
|
||
// New WebKit
|
||
[
|
||
'webkitRequestFullscreen',
|
||
'webkitExitFullscreen',
|
||
'webkitFullscreenElement',
|
||
'webkitFullscreenEnabled',
|
||
'webkitfullscreenchange',
|
||
'webkitfullscreenerror'
|
||
|
||
],
|
||
// Old WebKit
|
||
[
|
||
'webkitRequestFullScreen',
|
||
'webkitCancelFullScreen',
|
||
'webkitCurrentFullScreenElement',
|
||
'webkitCancelFullScreen',
|
||
'webkitfullscreenchange',
|
||
'webkitfullscreenerror'
|
||
|
||
],
|
||
[
|
||
'mozRequestFullScreen',
|
||
'mozCancelFullScreen',
|
||
'mozFullScreenElement',
|
||
'mozFullScreenEnabled',
|
||
'mozfullscreenchange',
|
||
'mozfullscreenerror'
|
||
],
|
||
[
|
||
'msRequestFullscreen',
|
||
'msExitFullscreen',
|
||
'msFullscreenElement',
|
||
'msFullscreenEnabled',
|
||
'MSFullscreenChange',
|
||
'MSFullscreenError'
|
||
]
|
||
];
|
||
|
||
var i = 0;
|
||
var l = fnMap.length;
|
||
var ret = {};
|
||
|
||
for (; i < l; i++) {
|
||
val = fnMap[i];
|
||
if (val && val[1] in document) {
|
||
for (i = 0; i < val.length; i++) {
|
||
ret[fnMap[0][i]] = val[i];
|
||
}
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
})();
|
||
|
||
var eventNameMap = {
|
||
change: fn.fullscreenchange,
|
||
error: fn.fullscreenerror
|
||
};
|
||
|
||
var screenfull = {
|
||
request: function (element, options) {
|
||
return new Promise(function (resolve, reject) {
|
||
var onFullScreenEntered = function () {
|
||
this.off('change', onFullScreenEntered);
|
||
resolve();
|
||
}.bind(this);
|
||
|
||
this.on('change', onFullScreenEntered);
|
||
|
||
element = element || document.documentElement;
|
||
|
||
var returnPromise = element[fn.requestFullscreen](options);
|
||
|
||
if (returnPromise instanceof Promise) {
|
||
returnPromise.then(onFullScreenEntered).catch(reject);
|
||
}
|
||
}.bind(this));
|
||
},
|
||
exit: function () {
|
||
return new Promise(function (resolve, reject) {
|
||
if (!this.isFullscreen) {
|
||
resolve();
|
||
return;
|
||
}
|
||
|
||
var onFullScreenExit = function () {
|
||
this.off('change', onFullScreenExit);
|
||
resolve();
|
||
}.bind(this);
|
||
|
||
this.on('change', onFullScreenExit);
|
||
|
||
var returnPromise = document[fn.exitFullscreen]();
|
||
|
||
if (returnPromise instanceof Promise) {
|
||
returnPromise.then(onFullScreenExit).catch(reject);
|
||
}
|
||
}.bind(this));
|
||
},
|
||
toggle: function (element, options) {
|
||
return this.isFullscreen ? this.exit() : this.request(element, options);
|
||
},
|
||
onchange: function (callback) {
|
||
this.on('change', callback);
|
||
},
|
||
onerror: function (callback) {
|
||
this.on('error', callback);
|
||
},
|
||
on: function (event, callback) {
|
||
var eventName = eventNameMap[event];
|
||
if (eventName) {
|
||
document.addEventListener(eventName, callback, false);
|
||
}
|
||
},
|
||
off: function (event, callback) {
|
||
var eventName = eventNameMap[event];
|
||
if (eventName) {
|
||
document.removeEventListener(eventName, callback, false);
|
||
}
|
||
},
|
||
raw: fn
|
||
};
|
||
|
||
if (!fn) {
|
||
if (isCommonjs) {
|
||
module.exports = {isEnabled: false};
|
||
} else {
|
||
window.screenfull = {isEnabled: false};
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
Object.defineProperties(screenfull, {
|
||
isFullscreen: {
|
||
get: function () {
|
||
return Boolean(document[fn.fullscreenElement]);
|
||
}
|
||
},
|
||
element: {
|
||
enumerable: true,
|
||
get: function () {
|
||
return document[fn.fullscreenElement];
|
||
}
|
||
},
|
||
isEnabled: {
|
||
enumerable: true,
|
||
get: function () {
|
||
// Coerce to boolean in case of old WebKit
|
||
return Boolean(document[fn.fullscreenEnabled]);
|
||
}
|
||
}
|
||
});
|
||
|
||
if (isCommonjs) {
|
||
module.exports = screenfull;
|
||
} else {
|
||
window.screenfull = screenfull;
|
||
}
|
||
})();
|
||
});
|
||
screenfull.isEnabled;
|
||
|
||
/**
|
||
*
|
||
* @param payload
|
||
* @returns {boolean}
|
||
*/
|
||
function isAacCodecPacket(payload) {
|
||
return payload[0] >> 4 === AUDIO_ENC_CODE.AAC && payload[1] === AVC_PACKET_TYPE.sequenceHeader;
|
||
}
|
||
|
||
function now() {
|
||
return new Date().getTime();
|
||
}
|
||
(() => {
|
||
try {
|
||
if (typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function") {
|
||
const module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
|
||
if (module instanceof WebAssembly.Module) return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
|
||
}
|
||
} catch (e) {}
|
||
return false;
|
||
})();
|
||
function getNowTime() {
|
||
if (performance && typeof performance.now === 'function') {
|
||
return performance.now();
|
||
}
|
||
return Date.now();
|
||
}
|
||
function calculationRate(callback) {
|
||
let totalSize = 0;
|
||
let lastTime = getNowTime();
|
||
return size => {
|
||
if (!isNumber(size)) {
|
||
return;
|
||
}
|
||
totalSize += size;
|
||
const thisTime = getNowTime();
|
||
const diffTime = thisTime - lastTime;
|
||
if (diffTime >= 1000) {
|
||
callback(totalSize / diffTime * 1000);
|
||
lastTime = thisTime;
|
||
totalSize = 0;
|
||
}
|
||
};
|
||
}
|
||
function formatVideoDecoderConfigure(avcC) {
|
||
let codecArray = avcC.subarray(1, 4);
|
||
let codecString = "avc1.";
|
||
for (let j = 0; j < 3; j++) {
|
||
let h = codecArray[j].toString(16);
|
||
if (h.length < 2) {
|
||
h = "0" + h;
|
||
}
|
||
codecString += h;
|
||
}
|
||
return {
|
||
codec: codecString,
|
||
description: avcC
|
||
};
|
||
}
|
||
function isNumber(value) {
|
||
const toString = Object.prototype.toString;
|
||
return toString.call(value) === "[object Number]";
|
||
}
|
||
function isEmpty(value) {
|
||
return value === null || value === undefined;
|
||
}
|
||
function isFunction(fn) {
|
||
return typeof fn === "function";
|
||
}
|
||
function checkNaluType(naluBuffer) {
|
||
let result = null;
|
||
let type = naluBuffer[0] & 0b0001_1111;
|
||
if (type === H264_NAL_TYPE.sps || type === H264_NAL_TYPE.pps) {
|
||
result = VIDEO_ENC_TYPE_SHOW.h264;
|
||
}
|
||
if (!result) {
|
||
type = (naluBuffer[0] & 0x7E) >> 1;
|
||
if (type === H265_NAL_TYPE.vps || type === H265_NAL_TYPE.sps || type === H265_NAL_TYPE.pps) {
|
||
result = VIDEO_ENC_TYPE_SHOW.h265;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function supportWritableStream() {
|
||
return typeof WritableStream !== 'undefined';
|
||
}
|
||
function calcStreamFpsByBufferList(bufferList, type) {
|
||
if (type) {
|
||
bufferList = bufferList.filter(item => item.type === type);
|
||
}
|
||
let firstItem = bufferList[0];
|
||
let oneSecondLength = null;
|
||
let nextIndex = 1;
|
||
if (bufferList.length > 0) {
|
||
let nextItem = bufferList[1];
|
||
if (nextItem && nextItem.ts - firstItem.ts > 100000) {
|
||
firstItem = nextItem;
|
||
nextIndex = 2;
|
||
}
|
||
}
|
||
if (firstItem) {
|
||
// next start
|
||
for (let i = nextIndex; i < bufferList.length; i++) {
|
||
let tempItem = bufferList[i];
|
||
if (type && tempItem.type !== type) {
|
||
tempItem = null;
|
||
}
|
||
if (tempItem) {
|
||
const diff = tempItem.ts - firstItem.ts;
|
||
if (diff >= 1000) {
|
||
const prevTempItem = bufferList[i - 1];
|
||
const diff2 = prevTempItem.ts - firstItem.ts;
|
||
if (diff2 < 1000) {
|
||
oneSecondLength = i + 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return oneSecondLength;
|
||
}
|
||
function isFetchSuccess(res) {
|
||
return res.ok && res.status >= 200 && res.status <= 299;
|
||
}
|
||
function clone(obj) {
|
||
let result = '';
|
||
//
|
||
if (typeof obj === 'object') {
|
||
try {
|
||
result = JSON.stringify(obj);
|
||
result = JSON.parse(result);
|
||
} catch (e) {
|
||
result = obj;
|
||
}
|
||
} else {
|
||
result = obj;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @returns {object:DEFAULT_PLAYER_OPTIONS}
|
||
*/
|
||
function getDefaultPlayerOptions() {
|
||
return clone(DEFAULT_PLAYER_OPTIONS);
|
||
}
|
||
|
||
var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
const Types = [[Uint8Array, Int8Array], [Uint16Array, Int16Array], [Uint32Array, Int32Array, Float32Array], [Float64Array]];
|
||
const U32 = Symbol(32);
|
||
const U16 = Symbol(16);
|
||
const U8 = Symbol(8);
|
||
const OPutMap = new Map();
|
||
Types.forEach((t, i) => t.forEach((t) => OPutMap.set(t, i)));
|
||
class OPut {
|
||
constructor(g) {
|
||
this.g = g;
|
||
this.consumed = 0;
|
||
if (g)
|
||
this.need = g.next().value;
|
||
}
|
||
fillFromReader(source) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const { done, value } = yield source.read();
|
||
if (done) {
|
||
this.close();
|
||
return;
|
||
}
|
||
else {
|
||
this.write(value);
|
||
return this.fillFromReader(source);
|
||
}
|
||
});
|
||
}
|
||
;
|
||
consume() {
|
||
if (this.buffer && this.consumed) {
|
||
this.buffer.copyWithin(0, this.consumed);
|
||
this.buffer = this.buffer.subarray(0, this.buffer.length - this.consumed);
|
||
this.consumed = 0;
|
||
}
|
||
}
|
||
demand(n, consume) {
|
||
if (consume)
|
||
this.consume();
|
||
this.need = n;
|
||
return this.flush();
|
||
}
|
||
read(need) {
|
||
return new Promise((resolve, reject) => {
|
||
if (this.resolve)
|
||
return reject("last read not complete yet");
|
||
this.resolve = (data) => {
|
||
delete this.resolve;
|
||
delete this.need;
|
||
resolve(data);
|
||
};
|
||
this.demand(need, true);
|
||
});
|
||
}
|
||
readU32() {
|
||
return this.read(U32);
|
||
}
|
||
readU16() {
|
||
return this.read(U16);
|
||
}
|
||
readU8() {
|
||
return this.read(U8);
|
||
}
|
||
close() {
|
||
if (this.g)
|
||
this.g.return();
|
||
}
|
||
flush() {
|
||
if (!this.buffer || !this.need)
|
||
return;
|
||
let returnValue = null;
|
||
const unread = this.buffer.subarray(this.consumed);
|
||
let n = 0;
|
||
const notEnough = (x) => unread.length < (n = x);
|
||
if (typeof this.need === 'number') {
|
||
if (notEnough(this.need))
|
||
return;
|
||
returnValue = unread.subarray(0, n);
|
||
}
|
||
else if (this.need instanceof ArrayBuffer) {
|
||
if (notEnough(this.need.byteLength))
|
||
return;
|
||
new Uint8Array(this.need).set(unread.subarray(0, n));
|
||
returnValue = this.need;
|
||
}
|
||
else if (this.need === U32) {
|
||
if (notEnough(4))
|
||
return;
|
||
returnValue = (unread[0] << 24) | (unread[1] << 16) | (unread[2] << 8) | unread[3];
|
||
}
|
||
else if (this.need === U16) {
|
||
if (notEnough(2))
|
||
return;
|
||
returnValue = (unread[0] << 8) | unread[1];
|
||
}
|
||
else if (this.need === U8) {
|
||
if (notEnough(1))
|
||
return;
|
||
returnValue = unread[0];
|
||
}
|
||
else if (OPutMap.has(this.need.constructor)) {
|
||
if (notEnough(this.need.length << OPutMap.get(this.need.constructor)))
|
||
return;
|
||
new Uint8Array(this.need.buffer, this.need.byteOffset).set(unread.subarray(0, n));
|
||
returnValue = this.need;
|
||
}
|
||
else if (this.g) {
|
||
this.g.throw(new Error('Unsupported type'));
|
||
return;
|
||
}
|
||
this.consumed += n;
|
||
if (this.g)
|
||
this.demand(this.g.next(returnValue).value, true);
|
||
else if (this.resolve)
|
||
this.resolve(returnValue);
|
||
return returnValue;
|
||
}
|
||
write(value) {
|
||
if (value instanceof ArrayBuffer) {
|
||
this.malloc(value.byteLength).set(new Uint8Array(value));
|
||
}
|
||
else {
|
||
this.malloc(value.byteLength).set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
|
||
}
|
||
if (this.g || this.resolve)
|
||
this.flush();
|
||
}
|
||
writeU32(value) {
|
||
this.malloc(4).set([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff]);
|
||
this.flush();
|
||
}
|
||
writeU16(value) {
|
||
this.malloc(2).set([(value >> 8) & 0xff, value & 0xff]);
|
||
this.flush();
|
||
}
|
||
writeU8(value) {
|
||
this.malloc(1)[0] = value;
|
||
this.flush();
|
||
}
|
||
malloc(size) {
|
||
if (this.buffer) {
|
||
const l = this.buffer.length;
|
||
const nl = l + size;
|
||
if (nl <= this.buffer.buffer.byteLength - this.buffer.byteOffset) {
|
||
this.buffer = new Uint8Array(this.buffer.buffer, this.buffer.byteOffset, nl);
|
||
}
|
||
else {
|
||
const n = new Uint8Array(nl);
|
||
n.set(this.buffer);
|
||
this.buffer = n;
|
||
}
|
||
return this.buffer.subarray(l, nl);
|
||
}
|
||
else {
|
||
this.buffer = new Uint8Array(size);
|
||
return this.buffer;
|
||
}
|
||
}
|
||
}
|
||
OPut.U32 = U32;
|
||
OPut.U16 = U16;
|
||
OPut.U8 = U8;
|
||
|
||
class Debug {
|
||
constructor(master) {
|
||
this.log = function (name) {
|
||
if (master._opt.debug && master._opt.debugLevel == DEBUG_LEVEL.debug) {
|
||
const prefix = master._opt.debugUuid ? `[${master._opt.debugUuid}]` : '';
|
||
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
args[_key - 1] = arguments[_key];
|
||
}
|
||
console.log(`JessibucaPro${prefix}:[\u2705\u2705\u2705][${name}]`, ...args);
|
||
}
|
||
};
|
||
this.warn = function (name) {
|
||
if (master._opt.debug && (master._opt.debugLevel == DEBUG_LEVEL.debug || master._opt.debugLevel == DEBUG_LEVEL.warn)) {
|
||
const prefix = master._opt.debugUuid ? `[${master._opt.debugUuid}]` : '';
|
||
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
||
args[_key2 - 1] = arguments[_key2];
|
||
}
|
||
console.log(`JessibucaPro${prefix}:[\u2757\u2757\u2757][${name}]`, ...args);
|
||
}
|
||
};
|
||
this.error = function (name) {
|
||
const prefix = master._opt.debugUuid ? `[${master._opt.debugUuid}]` : '';
|
||
for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
||
args[_key3 - 1] = arguments[_key3];
|
||
}
|
||
console.error(`JessibucaPro${prefix}:[\u274C\u274C\u274C][${name}]`, ...args);
|
||
};
|
||
}
|
||
}
|
||
|
||
// Exponential-Golomb buffer decoder
|
||
class ExpGolomb {
|
||
constructor(uint8array) {
|
||
this._buffer = uint8array;
|
||
this._buffer_index = 0;
|
||
this._total_bytes = uint8array.byteLength;
|
||
this._total_bits = uint8array.byteLength * 8;
|
||
this._current_word = 0;
|
||
this._current_word_bits_left = 0;
|
||
}
|
||
destroy() {
|
||
this._buffer = null;
|
||
}
|
||
_fillCurrentWord() {
|
||
let buffer_bytes_left = this._total_bytes - this._buffer_index;
|
||
if (buffer_bytes_left <= 0) {
|
||
// throw new IllegalStateException('ExpGolomb: _fillCurrentWord() but no bytes available');
|
||
console.error('ExpGolomb: _fillCurrentWord() but no bytes available', this._total_bytes, this._buffer_index);
|
||
return;
|
||
}
|
||
let bytes_read = Math.min(4, buffer_bytes_left);
|
||
let word = new Uint8Array(4);
|
||
word.set(this._buffer.subarray(this._buffer_index, this._buffer_index + bytes_read));
|
||
this._current_word = new DataView(word.buffer).getUint32(0, false);
|
||
this._buffer_index += bytes_read;
|
||
this._current_word_bits_left = bytes_read * 8;
|
||
}
|
||
readBits(bits) {
|
||
if (bits > 32) {
|
||
// throw new InvalidArgumentException('ExpGolomb: readBits() bits exceeded max 32bits!');
|
||
console.error('ExpGolomb: readBits() bits exceeded max 32bits!');
|
||
}
|
||
if (bits <= this._current_word_bits_left) {
|
||
let result = this._current_word >>> 32 - bits;
|
||
this._current_word <<= bits;
|
||
this._current_word_bits_left -= bits;
|
||
return result;
|
||
}
|
||
let result = this._current_word_bits_left ? this._current_word : 0;
|
||
result = result >>> 32 - this._current_word_bits_left;
|
||
let bits_need_left = bits - this._current_word_bits_left;
|
||
this._fillCurrentWord();
|
||
let bits_read_next = Math.min(bits_need_left, this._current_word_bits_left);
|
||
let result2 = this._current_word >>> 32 - bits_read_next;
|
||
this._current_word <<= bits_read_next;
|
||
this._current_word_bits_left -= bits_read_next;
|
||
result = result << bits_read_next | result2;
|
||
return result;
|
||
}
|
||
readBool() {
|
||
return this.readBits(1) === 1;
|
||
}
|
||
readByte() {
|
||
return this.readBits(8);
|
||
}
|
||
_skipLeadingZero() {
|
||
let zero_count;
|
||
for (zero_count = 0; zero_count < this._current_word_bits_left; zero_count++) {
|
||
if (0 !== (this._current_word & 0x80000000 >>> zero_count)) {
|
||
this._current_word <<= zero_count;
|
||
this._current_word_bits_left -= zero_count;
|
||
return zero_count;
|
||
}
|
||
}
|
||
this._fillCurrentWord();
|
||
return zero_count + this._skipLeadingZero();
|
||
}
|
||
readUEG() {
|
||
// unsigned exponential golomb
|
||
let leading_zeros = this._skipLeadingZero();
|
||
return this.readBits(leading_zeros + 1) - 1;
|
||
}
|
||
readSEG() {
|
||
// signed exponential golomb
|
||
let value = this.readUEG();
|
||
if (value & 0x01) {
|
||
return value + 1 >>> 1;
|
||
} else {
|
||
return -1 * (value >>> 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Copyright (C) 2016 Bilibili. All Rights Reserved.
|
||
*
|
||
* @author zheng qian <xqq@xqq.im>
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
class SPSParser {
|
||
static _ebsp2rbsp(uint8array) {
|
||
let src = uint8array;
|
||
let src_length = src.byteLength;
|
||
let dst = new Uint8Array(src_length);
|
||
let dst_idx = 0;
|
||
for (let i = 0; i < src_length; i++) {
|
||
if (i >= 2) {
|
||
// Unescape: Skip 0x03 after 00 00
|
||
if (src[i] === 0x03 && src[i - 1] === 0x00 && src[i - 2] === 0x00) {
|
||
continue;
|
||
}
|
||
}
|
||
dst[dst_idx] = src[i];
|
||
dst_idx++;
|
||
}
|
||
return new Uint8Array(dst.buffer, 0, dst_idx);
|
||
}
|
||
|
||
// 解析 SPS
|
||
// https://zhuanlan.zhihu.com/p/27896239
|
||
static parseSPS(uint8array) {
|
||
let rbsp = SPSParser._ebsp2rbsp(uint8array);
|
||
let gb = new ExpGolomb(rbsp);
|
||
gb.readByte();
|
||
// 标识当前H.264码流的profile。
|
||
// 我们知道，H.264中定义了三种常用的档次profile： 基准档次：baseline profile;主要档次：main profile; 扩展档次：extended profile;
|
||
|
||
let profile_idc = gb.readByte(); // profile_idc
|
||
gb.readByte(); // constraint_set_flags[5] + reserved_zero[3]
|
||
// 标识当前码流的Level。编码的Level定义了某种条件下的最大视频分辨率、最大视频帧率等参数，码流所遵从的level由level_idc指定。
|
||
let level_idc = gb.readByte(); // level_idc
|
||
// 表示当前的序列参数集的id。通过该id值，图像参数集pps可以引用其代表的sps中的参数。
|
||
gb.readUEG(); // seq_parameter_set_id
|
||
|
||
let profile_string = SPSParser.getProfileString(profile_idc);
|
||
let level_string = SPSParser.getLevelString(level_idc);
|
||
let chroma_format_idc = 1;
|
||
let chroma_format = 420;
|
||
let chroma_format_table = [0, 420, 422, 444];
|
||
let bit_depth = 8;
|
||
|
||
//
|
||
if (profile_idc === 100 || profile_idc === 110 || profile_idc === 122 || profile_idc === 244 || profile_idc === 44 || profile_idc === 83 || profile_idc === 86 || profile_idc === 118 || profile_idc === 128 || profile_idc === 138 || profile_idc === 144) {
|
||
//
|
||
chroma_format_idc = gb.readUEG();
|
||
if (chroma_format_idc === 3) {
|
||
gb.readBits(1); // separate_colour_plane_flag
|
||
}
|
||
|
||
if (chroma_format_idc <= 3) {
|
||
chroma_format = chroma_format_table[chroma_format_idc];
|
||
}
|
||
bit_depth = gb.readUEG() + 8; // bit_depth_luma_minus8
|
||
gb.readUEG(); // bit_depth_chroma_minus8
|
||
gb.readBits(1); // qpprime_y_zero_transform_bypass_flag
|
||
if (gb.readBool()) {
|
||
// seq_scaling_matrix_present_flag
|
||
let scaling_list_count = chroma_format_idc !== 3 ? 8 : 12;
|
||
for (let i = 0; i < scaling_list_count; i++) {
|
||
if (gb.readBool()) {
|
||
// seq_scaling_list_present_flag
|
||
if (i < 6) {
|
||
SPSParser._skipScalingList(gb, 16);
|
||
} else {
|
||
SPSParser._skipScalingList(gb, 64);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 用于计算MaxFrameNum的值。计算公式为MaxFrameNum = 2^(log2_max_frame_num_minus4 +
|
||
gb.readUEG(); // log2_max_frame_num_minus4
|
||
// 表示解码picture order count(POC)的方法。POC是另一种计量图像序号的方式，与frame_num有着不同的计算方法。该语法元素的取值为0、1或2。
|
||
let pic_order_cnt_type = gb.readUEG();
|
||
if (pic_order_cnt_type === 0) {
|
||
gb.readUEG(); // log2_max_pic_order_cnt_lsb_minus_4
|
||
} else if (pic_order_cnt_type === 1) {
|
||
gb.readBits(1); // delta_pic_order_always_zero_flag
|
||
gb.readSEG(); // offset_for_non_ref_pic
|
||
gb.readSEG(); // offset_for_top_to_bottom_field
|
||
let num_ref_frames_in_pic_order_cnt_cycle = gb.readUEG();
|
||
for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
|
||
gb.readSEG(); // offset_for_ref_frame
|
||
}
|
||
}
|
||
// 用于表示参考帧的最大数目。
|
||
let ref_frames = gb.readUEG(); // max_num_ref_frames
|
||
// 标识位，说明frame_num中是否允许不连续的值。
|
||
gb.readBits(1); // gaps_in_frame_num_value_allowed_flag
|
||
// 用于计算图像的宽度。单位为宏块个数，因此图像的实际宽度为:
|
||
let pic_width_in_mbs_minus1 = gb.readUEG();
|
||
// 使用PicHeightInMapUnits来度量视频中一帧图像的高度。
|
||
// PicHeightInMapUnits并非图像明确的以像素或宏块为单位的高度，而需要考虑该宏块是帧编码或场编码。PicHeightInMapUnits的计算方式为：
|
||
let pic_height_in_map_units_minus1 = gb.readUEG();
|
||
// 标识位，说明宏块的编码方式。当该标识位为0时，宏块可能为帧编码或场编码；
|
||
// 该标识位为1时，所有宏块都采用帧编码。根据该标识位取值不同，PicHeightInMapUnits的含义也不同，
|
||
// 为0时表示一场数据按宏块计算的高度，为1时表示一帧数据按宏块计算的高度。
|
||
let frame_mbs_only_flag = gb.readBits(1);
|
||
if (frame_mbs_only_flag === 0) {
|
||
// 标识位，说明是否采用了宏块级的帧场自适应编码。当该标识位为0时，不存在帧编码和场编码之间的切换；当标识位为1时，宏块可能在帧编码和场编码模式之间进行选择。
|
||
gb.readBits(1); // mb_adaptive_frame_field_flag
|
||
}
|
||
// 标识位，用于B_Skip、B_Direct模式运动矢量的推导计算。
|
||
gb.readBits(1); // direct_8x8_inference_flag
|
||
|
||
let frame_crop_left_offset = 0;
|
||
let frame_crop_right_offset = 0;
|
||
let frame_crop_top_offset = 0;
|
||
let frame_crop_bottom_offset = 0;
|
||
let frame_cropping_flag = gb.readBool();
|
||
if (frame_cropping_flag) {
|
||
frame_crop_left_offset = gb.readUEG();
|
||
frame_crop_right_offset = gb.readUEG();
|
||
frame_crop_top_offset = gb.readUEG();
|
||
frame_crop_bottom_offset = gb.readUEG();
|
||
}
|
||
let sar_width = 1,
|
||
sar_height = 1;
|
||
let fps = 0,
|
||
fps_fixed = true,
|
||
fps_num = 0,
|
||
fps_den = 0;
|
||
// 标识位，说明SPS中是否存在VUI信息。
|
||
let vui_parameters_present_flag = gb.readBool();
|
||
if (vui_parameters_present_flag) {
|
||
if (gb.readBool()) {
|
||
// aspect_ratio_info_present_flag
|
||
let aspect_ratio_idc = gb.readByte();
|
||
let sar_w_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
|
||
let sar_h_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
|
||
if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
|
||
sar_width = sar_w_table[aspect_ratio_idc - 1];
|
||
sar_height = sar_h_table[aspect_ratio_idc - 1];
|
||
} else if (aspect_ratio_idc === 255) {
|
||
sar_width = gb.readByte() << 8 | gb.readByte();
|
||
sar_height = gb.readByte() << 8 | gb.readByte();
|
||
}
|
||
}
|
||
if (gb.readBool()) {
|
||
// overscan_info_present_flag
|
||
gb.readBool(); // overscan_appropriate_flag
|
||
}
|
||
|
||
if (gb.readBool()) {
|
||
// video_signal_type_present_flag
|
||
gb.readBits(4); // video_format & video_full_range_flag
|
||
if (gb.readBool()) {
|
||
// colour_description_present_flag
|
||
gb.readBits(24); // colour_primaries & transfer_characteristics & matrix_coefficients
|
||
}
|
||
}
|
||
|
||
if (gb.readBool()) {
|
||
// chroma_loc_info_present_flag
|
||
gb.readUEG(); // chroma_sample_loc_type_top_field
|
||
gb.readUEG(); // chroma_sample_loc_type_bottom_field
|
||
}
|
||
|
||
if (gb.readBool()) {
|
||
// timing_info_present_flag
|
||
let num_units_in_tick = gb.readBits(32);
|
||
let time_scale = gb.readBits(32);
|
||
fps_fixed = gb.readBool(); // fixed_frame_rate_flag
|
||
|
||
fps_num = time_scale;
|
||
fps_den = num_units_in_tick * 2;
|
||
fps = fps_num / fps_den;
|
||
}
|
||
}
|
||
let sarScale = 1;
|
||
if (sar_width !== 1 || sar_height !== 1) {
|
||
sarScale = sar_width / sar_height;
|
||
}
|
||
let crop_unit_x = 0,
|
||
crop_unit_y = 0;
|
||
if (chroma_format_idc === 0) {
|
||
crop_unit_x = 1;
|
||
crop_unit_y = 2 - frame_mbs_only_flag;
|
||
} else {
|
||
let sub_wc = chroma_format_idc === 3 ? 1 : 2;
|
||
let sub_hc = chroma_format_idc === 1 ? 2 : 1;
|
||
crop_unit_x = sub_wc;
|
||
crop_unit_y = sub_hc * (2 - frame_mbs_only_flag);
|
||
}
|
||
let codec_width = (pic_width_in_mbs_minus1 + 1) * 16;
|
||
let codec_height = (2 - frame_mbs_only_flag) * ((pic_height_in_map_units_minus1 + 1) * 16);
|
||
codec_width -= (frame_crop_left_offset + frame_crop_right_offset) * crop_unit_x;
|
||
codec_height -= (frame_crop_top_offset + frame_crop_bottom_offset) * crop_unit_y;
|
||
let present_width = Math.ceil(codec_width * sarScale);
|
||
gb.destroy();
|
||
gb = null;
|
||
|
||
// 解析出来的SPS 内容。
|
||
return {
|
||
profile_string: profile_string,
|
||
// baseline, high, high10, ...
|
||
level_string: level_string,
|
||
// 3, 3.1, 4, 4.1, 5, 5.1, ...
|
||
bit_depth: bit_depth,
|
||
// 8bit, 10bit, ...
|
||
ref_frames: ref_frames,
|
||
chroma_format: chroma_format,
|
||
// 4:2:0, 4:2:2, ...
|
||
chroma_format_string: SPSParser.getChromaFormatString(chroma_format),
|
||
frame_rate: {
|
||
fixed: fps_fixed,
|
||
fps: fps,
|
||
fps_den: fps_den,
|
||
fps_num: fps_num
|
||
},
|
||
sar_ratio: {
|
||
width: sar_width,
|
||
height: sar_height
|
||
},
|
||
codec_size: {
|
||
width: codec_width,
|
||
height: codec_height
|
||
},
|
||
present_size: {
|
||
width: present_width,
|
||
height: codec_height
|
||
}
|
||
};
|
||
}
|
||
static parseSPS$2(uint8array) {
|
||
let codec_array = uint8array.subarray(1, 4);
|
||
let codec_mimetype = 'avc1.';
|
||
for (let j = 0; j < 3; j++) {
|
||
let h = codec_array[j].toString(16);
|
||
if (h.length < 2) {
|
||
h = '0' + h;
|
||
}
|
||
codec_mimetype += h;
|
||
}
|
||
let rbsp = SPSParser._ebsp2rbsp(uint8array);
|
||
let gb = new ExpGolomb(rbsp);
|
||
gb.readByte();
|
||
let profile_idc = gb.readByte(); // profile_idc
|
||
gb.readByte(); // constraint_set_flags[5] + reserved_zero[3]
|
||
let level_idc = gb.readByte(); // level_idc
|
||
gb.readUEG(); // seq_parameter_set_id
|
||
|
||
let profile_string = SPSParser.getProfileString(profile_idc);
|
||
let level_string = SPSParser.getLevelString(level_idc);
|
||
let chroma_format_idc = 1;
|
||
let chroma_format = 420;
|
||
let chroma_format_table = [0, 420, 422, 444];
|
||
let bit_depth_luma = 8;
|
||
let bit_depth_chroma = 8;
|
||
if (profile_idc === 100 || profile_idc === 110 || profile_idc === 122 || profile_idc === 244 || profile_idc === 44 || profile_idc === 83 || profile_idc === 86 || profile_idc === 118 || profile_idc === 128 || profile_idc === 138 || profile_idc === 144) {
|
||
chroma_format_idc = gb.readUEG();
|
||
if (chroma_format_idc === 3) {
|
||
gb.readBits(1); // separate_colour_plane_flag
|
||
}
|
||
|
||
if (chroma_format_idc <= 3) {
|
||
chroma_format = chroma_format_table[chroma_format_idc];
|
||
}
|
||
bit_depth_luma = gb.readUEG() + 8; // bit_depth_luma_minus8
|
||
bit_depth_chroma = gb.readUEG() + 8; // bit_depth_chroma_minus8
|
||
gb.readBits(1); // qpprime_y_zero_transform_bypass_flag
|
||
if (gb.readBool()) {
|
||
// seq_scaling_matrix_present_flag
|
||
let scaling_list_count = chroma_format_idc !== 3 ? 8 : 12;
|
||
for (let i = 0; i < scaling_list_count; i++) {
|
||
if (gb.readBool()) {
|
||
// seq_scaling_list_present_flag
|
||
if (i < 6) {
|
||
SPSParser._skipScalingList(gb, 16);
|
||
} else {
|
||
SPSParser._skipScalingList(gb, 64);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
gb.readUEG(); // log2_max_frame_num_minus4
|
||
let pic_order_cnt_type = gb.readUEG();
|
||
if (pic_order_cnt_type === 0) {
|
||
gb.readUEG(); // log2_max_pic_order_cnt_lsb_minus_4
|
||
} else if (pic_order_cnt_type === 1) {
|
||
gb.readBits(1); // delta_pic_order_always_zero_flag
|
||
gb.readSEG(); // offset_for_non_ref_pic
|
||
gb.readSEG(); // offset_for_top_to_bottom_field
|
||
let num_ref_frames_in_pic_order_cnt_cycle = gb.readUEG();
|
||
for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
|
||
gb.readSEG(); // offset_for_ref_frame
|
||
}
|
||
}
|
||
|
||
let ref_frames = gb.readUEG(); // max_num_ref_frames
|
||
gb.readBits(1); // gaps_in_frame_num_value_allowed_flag
|
||
|
||
let pic_width_in_mbs_minus1 = gb.readUEG();
|
||
let pic_height_in_map_units_minus1 = gb.readUEG();
|
||
let frame_mbs_only_flag = gb.readBits(1);
|
||
if (frame_mbs_only_flag === 0) {
|
||
gb.readBits(1); // mb_adaptive_frame_field_flag
|
||
}
|
||
|
||
gb.readBits(1); // direct_8x8_inference_flag
|
||
|
||
let frame_crop_left_offset = 0;
|
||
let frame_crop_right_offset = 0;
|
||
let frame_crop_top_offset = 0;
|
||
let frame_crop_bottom_offset = 0;
|
||
let frame_cropping_flag = gb.readBool();
|
||
if (frame_cropping_flag) {
|
||
frame_crop_left_offset = gb.readUEG();
|
||
frame_crop_right_offset = gb.readUEG();
|
||
frame_crop_top_offset = gb.readUEG();
|
||
frame_crop_bottom_offset = gb.readUEG();
|
||
}
|
||
let sar_width = 1,
|
||
sar_height = 1;
|
||
let fps = 0,
|
||
fps_fixed = true,
|
||
fps_num = 0,
|
||
fps_den = 0;
|
||
let vui_parameters_present_flag = gb.readBool();
|
||
if (vui_parameters_present_flag) {
|
||
if (gb.readBool()) {
|
||
// aspect_ratio_info_present_flag
|
||
let aspect_ratio_idc = gb.readByte();
|
||
let sar_w_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
|
||
let sar_h_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
|
||
if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
|
||
sar_width = sar_w_table[aspect_ratio_idc - 1];
|
||
sar_height = sar_h_table[aspect_ratio_idc - 1];
|
||
} else if (aspect_ratio_idc === 255) {
|
||
sar_width = gb.readByte() << 8 | gb.readByte();
|
||
sar_height = gb.readByte() << 8 | gb.readByte();
|
||
}
|
||
}
|
||
if (gb.readBool()) {
|
||
// overscan_info_present_flag
|
||
gb.readBool(); // overscan_appropriate_flag
|
||
}
|
||
|
||
if (gb.readBool()) {
|
||
// video_signal_type_present_flag
|
||
gb.readBits(4); // video_format & video_full_range_flag
|
||
if (gb.readBool()) {
|
||
// colour_description_present_flag
|
||
gb.readBits(24); // colour_primaries & transfer_characteristics & matrix_coefficients
|
||
}
|
||
}
|
||
|
||
if (gb.readBool()) {
|
||
// chroma_loc_info_present_flag
|
||
gb.readUEG(); // chroma_sample_loc_type_top_field
|
||
gb.readUEG(); // chroma_sample_loc_type_bottom_field
|
||
}
|
||
|
||
if (gb.readBool()) {
|
||
// timing_info_present_flag
|
||
let num_units_in_tick = gb.readBits(32);
|
||
let time_scale = gb.readBits(32);
|
||
fps_fixed = gb.readBool(); // fixed_frame_rate_flag
|
||
|
||
fps_num = time_scale;
|
||
fps_den = num_units_in_tick * 2;
|
||
fps = fps_num / fps_den;
|
||
}
|
||
}
|
||
let sarScale = 1;
|
||
if (sar_width !== 1 || sar_height !== 1) {
|
||
sarScale = sar_width / sar_height;
|
||
}
|
||
let crop_unit_x = 0,
|
||
crop_unit_y = 0;
|
||
if (chroma_format_idc === 0) {
|
||
crop_unit_x = 1;
|
||
crop_unit_y = 2 - frame_mbs_only_flag;
|
||
} else {
|
||
let sub_wc = chroma_format_idc === 3 ? 1 : 2;
|
||
let sub_hc = chroma_format_idc === 1 ? 2 : 1;
|
||
crop_unit_x = sub_wc;
|
||
crop_unit_y = sub_hc * (2 - frame_mbs_only_flag);
|
||
}
|
||
let codec_width = (pic_width_in_mbs_minus1 + 1) * 16;
|
||
let codec_height = (2 - frame_mbs_only_flag) * ((pic_height_in_map_units_minus1 + 1) * 16);
|
||
codec_width -= (frame_crop_left_offset + frame_crop_right_offset) * crop_unit_x;
|
||
codec_height -= (frame_crop_top_offset + frame_crop_bottom_offset) * crop_unit_y;
|
||
let present_width = Math.ceil(codec_width * sarScale);
|
||
gb.destroy();
|
||
gb = null;
|
||
return {
|
||
codec_mimetype,
|
||
profile_idc,
|
||
level_idc,
|
||
profile_string,
|
||
// baseline, high, high10, ...
|
||
level_string,
|
||
// 3, 3.1, 4, 4.1, 5, 5.1, ...
|
||
chroma_format_idc,
|
||
bit_depth: bit_depth_luma,
|
||
// 8bit, 10bit, ...
|
||
bit_depth_luma,
|
||
bit_depth_chroma,
|
||
ref_frames,
|
||
chroma_format,
|
||
// 4:2:0, 4:2:2, ...
|
||
chroma_format_string: SPSParser.getChromaFormatString(chroma_format),
|
||
frame_rate: {
|
||
fixed: fps_fixed,
|
||
fps: fps,
|
||
fps_den: fps_den,
|
||
fps_num: fps_num
|
||
},
|
||
sar_ratio: {
|
||
width: sar_width,
|
||
height: sar_height
|
||
},
|
||
codec_size: {
|
||
width: codec_width,
|
||
height: codec_height
|
||
},
|
||
present_size: {
|
||
width: present_width,
|
||
height: codec_height
|
||
}
|
||
};
|
||
}
|
||
static _skipScalingList(gb, count) {
|
||
let last_scale = 8,
|
||
next_scale = 8;
|
||
let delta_scale = 0;
|
||
for (let i = 0; i < count; i++) {
|
||
if (next_scale !== 0) {
|
||
delta_scale = gb.readSEG();
|
||
next_scale = (last_scale + delta_scale + 256) % 256;
|
||
}
|
||
last_scale = next_scale === 0 ? last_scale : next_scale;
|
||
}
|
||
}
|
||
|
||
// profile_idc = 66 → baseline profile;
|
||
// profile_idc = 77 → main profile;
|
||
// profile_idc = 88 → extended profile;
|
||
// 在新版的标准中，还包括了High、High 10、High 4:2:2、High 4:4:4、High 10 Intra、High
|
||
// 4:2:2 Intra、High 4:4:4 Intra、CAVLC 4:4:4 Intra
|
||
static getProfileString(profile_idc) {
|
||
switch (profile_idc) {
|
||
case 66:
|
||
return 'Baseline';
|
||
case 77:
|
||
return 'Main';
|
||
case 88:
|
||
return 'Extended';
|
||
case 100:
|
||
return 'High';
|
||
case 110:
|
||
return 'High10';
|
||
case 122:
|
||
return 'High422';
|
||
case 244:
|
||
return 'High444';
|
||
default:
|
||
return 'Unknown';
|
||
}
|
||
}
|
||
static getLevelString(level_idc) {
|
||
return (level_idc / 10).toFixed(1);
|
||
}
|
||
static getChromaFormatString(chroma) {
|
||
switch (chroma) {
|
||
case 420:
|
||
return '4:2:0';
|
||
case 422:
|
||
return '4:2:2';
|
||
case 444:
|
||
return '4:4:4';
|
||
default:
|
||
return 'Unknown';
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
function parseAVCDecoderConfigurationRecord(arrayBuffer) {
|
||
const meta = {};
|
||
const v = new DataView(arrayBuffer.buffer);
|
||
let version = v.getUint8(0); // configurationVersion
|
||
let avcProfile = v.getUint8(1); // avcProfileIndication
|
||
v.getUint8(2); // profile_compatibil
|
||
v.getUint8(3); // AVCLevelIndication
|
||
|
||
if (version !== 1 || avcProfile === 0) {
|
||
// this._onError(DemuxErrors.FORMAT_ERROR, 'Flv: Invalid AVCDecoderConfigurationRecord');
|
||
|
||
return {};
|
||
}
|
||
const _naluLengthSize = (v.getUint8(4) & 3) + 1; // lengthSizeMinusOne
|
||
|
||
if (_naluLengthSize !== 3 && _naluLengthSize !== 4) {
|
||
// holy shit!!!
|
||
// this._onError(DemuxErrors.FORMAT_ERROR, `Flv: Strange NaluLengthSizeMinusOne: ${_naluLengthSize - 1}`);
|
||
return {};
|
||
}
|
||
let spsCount = v.getUint8(5) & 31; // numOfSequenceParameterSets
|
||
|
||
if (spsCount === 0) {
|
||
// this._onError(DemuxErrors.FORMAT_ERROR, 'Flv: Invalid AVCDecoderConfigurationRecord: No SPS');
|
||
return {};
|
||
}
|
||
let offset = 6;
|
||
for (let i = 0; i < spsCount; i++) {
|
||
let len = v.getUint16(offset, false); // sequenceParameterSetLength
|
||
offset += 2;
|
||
if (len === 0) {
|
||
continue;
|
||
}
|
||
|
||
// Notice: Nalu without startcode header (00 00 00 01)
|
||
let sps = new Uint8Array(arrayBuffer.buffer, offset, len);
|
||
offset += len;
|
||
// flv.js作者选择了自己来解析这个数据结构，也是迫不得已，因为JS环境下没有ffmpeg，解析这个结构主要是为了提取 sps和pps。虽然理论上sps允许有多个，但其实一般就一个。
|
||
// packetTtype 为 1 表示 NALU，NALU= network abstract layer unit，这是H.264的概念，网络抽象层数据单元，其实简单理解就是一帧视频数据。
|
||
// pps的信息没什么用，所以作者只实现了sps的分析器，说明作者下了很大功夫去学习264的标准，其中的Golomb解码还是挺复杂的，能解对不容易，我在PC和手机平台都是用ffmpeg去解析的。
|
||
// SPS里面包括了视频分辨率，帧率，profile level等视频重要信息。
|
||
let config = SPSParser.parseSPS(sps);
|
||
// console.log('h264 sps config',config)
|
||
if (i !== 0) {
|
||
// ignore other sps's config
|
||
continue;
|
||
}
|
||
meta.sps = sps;
|
||
meta.timescale = 1000;
|
||
meta.codecWidth = config.codec_size.width;
|
||
meta.codecHeight = config.codec_size.height;
|
||
meta.presentWidth = config.present_size.width;
|
||
meta.presentHeight = config.present_size.height;
|
||
meta.profile = config.profile_string;
|
||
meta.level = config.level_string;
|
||
meta.bitDepth = config.bit_depth;
|
||
meta.chromaFormat = config.chroma_format;
|
||
meta.sarRatio = config.sar_ratio;
|
||
meta.frameRate = config.frame_rate;
|
||
if (config.frame_rate.fixed === false || config.frame_rate.fps_num === 0 || config.frame_rate.fps_den === 0) {
|
||
meta.frameRate = {
|
||
fixed: true,
|
||
fps: 23.976,
|
||
fps_num: 23976,
|
||
fps_den: 1000
|
||
};
|
||
}
|
||
let fps_den = meta.frameRate.fps_den;
|
||
let fps_num = meta.frameRate.fps_num;
|
||
meta.refSampleDuration = meta.timescale * (fps_den / fps_num);
|
||
let codecArray = sps.subarray(1, 4);
|
||
let codecString = 'avc1.';
|
||
for (let j = 0; j < 3; j++) {
|
||
let h = codecArray[j].toString(16);
|
||
if (h.length < 2) {
|
||
h = '0' + h;
|
||
}
|
||
codecString += h;
|
||
}
|
||
// codec
|
||
meta.codec = codecString;
|
||
}
|
||
let ppsCount = v.getUint8(offset); // numOfPictureParameterSets
|
||
if (ppsCount === 0) {
|
||
// this._onError(DemuxErrors.FORMAT_ERROR, 'Flv: Invalid AVCDecoderConfigurationRecord: No PPS');
|
||
return {};
|
||
}
|
||
offset++;
|
||
for (let i = 0; i < ppsCount; i++) {
|
||
let len = v.getUint16(offset, false); // pictureParameterSetLength
|
||
offset += 2;
|
||
if (len === 0) {
|
||
continue;
|
||
}
|
||
let pps = new Uint8Array(arrayBuffer.buffer, offset, len);
|
||
|
||
// pps is useless for extracting video information
|
||
offset += len;
|
||
meta.pps = pps;
|
||
}
|
||
meta.videoType = 'avc';
|
||
if (meta.sps) {
|
||
const spsLength = meta.sps.byteLength;
|
||
const spsFlag = new Uint8Array([spsLength >>> 24 & 0xFF, spsLength >>> 16 & 0xFF, spsLength >>> 8 & 0xFF, spsLength & 0xFF]);
|
||
const sps = new Uint8Array(spsLength + 4);
|
||
sps.set(spsFlag, 0);
|
||
sps.set(meta.sps, 4);
|
||
meta.sps = sps;
|
||
}
|
||
if (meta.pps) {
|
||
const ppsLength = meta.pps.byteLength;
|
||
const ppsFlag = new Uint8Array([ppsLength >>> 24 & 0xFF, ppsLength >>> 16 & 0xFF, ppsLength >>> 8 & 0xFF, ppsLength & 0xFF]);
|
||
const pps = new Uint8Array(ppsLength + 4);
|
||
pps.set(ppsFlag, 0);
|
||
pps.set(meta.pps, 4);
|
||
meta.pps = pps;
|
||
}
|
||
|
||
// meta.avcc = arrayBuffer;
|
||
return meta;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param sps
|
||
* @param pps
|
||
* @returns {Uint8Array}
|
||
*/
|
||
function avcEncoderConfigurationRecord(_ref) {
|
||
let {
|
||
sps,
|
||
pps
|
||
} = _ref;
|
||
// todo: 1 是 序列帧 2-4cts帧
|
||
// 从 0x01 开始 表示version。
|
||
// RTMP_AVC_HEAD
|
||
// 0x17 keyframe 7:AVC
|
||
// 0x00 AVC sequence header
|
||
// 0x00 0x00 0x00
|
||
// 0x01 configurationVersion
|
||
// 0x42 AVCProfileIndication
|
||
// 0x00 profile_compatibility
|
||
// 0x1E AVCLevelIndication
|
||
// 0xFF lengthSizeMinusOne
|
||
const tmp = [0x17, 0x00, 0x00, 0x00, 0x00, 0x01, 0x42, 0x00, 0x1E, 0xFF];
|
||
// 是个是私有协议标识，h264的。
|
||
// 0x17 :23
|
||
tmp[0] = 0x17;
|
||
|
||
// 标准的 nale 格式。。。
|
||
tmp[6] = sps[1]; // 0x42 avc profile ( sps[0][1] )
|
||
tmp[7] = sps[2]; // 0x00 avc compatibility ( sps[0][2] )
|
||
tmp[8] = sps[3]; // 0x1E avc level ( sps[0][3] )
|
||
//tmp[9] 0xFF 6 reserved ( all bits on )
|
||
// temp 的length 是10 最后的下标就是 9
|
||
|
||
// 0xE1 : 225
|
||
tmp[10] = 0xE1; //
|
||
// number of SPS NALUs (usually 1) repeated once per SPS:
|
||
//
|
||
tmp[11] = sps.byteLength >> 8 & 0xff; //
|
||
// SPS size
|
||
tmp[12] = sps.byteLength & 0xff; //
|
||
// variable SPS NALU data
|
||
// number of PPS NALUs (usually 1) repeated once per PPS
|
||
// PPS size
|
||
// variable PPS NALU data
|
||
tmp.push(...sps, 0x01, pps.byteLength >> 8 & 0xff, pps.byteLength & 0xff, ...pps);
|
||
//
|
||
|
||
const arrayBuffer = new Uint8Array(tmp);
|
||
return arrayBuffer;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param oneNALBuffer
|
||
* @param isIframe
|
||
* @returns {Uint8Array}
|
||
*/
|
||
function avcEncoderNalePacket(oneNALBuffer, isIframe) {
|
||
// 正常发送nal
|
||
const idrBit = 0x10 | 7;
|
||
const nIdrBit = 0x20 | 7;
|
||
let tmp = [];
|
||
if (isIframe) {
|
||
tmp[0] = idrBit;
|
||
} else {
|
||
tmp[0] = nIdrBit;
|
||
}
|
||
// compositionTime
|
||
tmp[1] = 1;
|
||
tmp[2] = 0;
|
||
tmp[3] = 0;
|
||
tmp[4] = 0;
|
||
|
||
//
|
||
tmp[5] = oneNALBuffer.byteLength >> 24 & 0xff;
|
||
tmp[6] = oneNALBuffer.byteLength >> 16 & 0xff;
|
||
tmp[7] = oneNALBuffer.byteLength >> 8 & 0xff;
|
||
tmp[8] = oneNALBuffer.byteLength & 0xff;
|
||
const arrayBuffer = new Uint8Array(tmp.length + oneNALBuffer.byteLength);
|
||
arrayBuffer.set(tmp, 0);
|
||
arrayBuffer.set(oneNALBuffer, tmp.length);
|
||
return arrayBuffer;
|
||
}
|
||
function avcEncoderNalePacketNotLength(oneNALBuffer, isIframe) {
|
||
// 正常发送nal
|
||
const idrBit = 0x10 | 7;
|
||
const nIdrBit = 0x20 | 7;
|
||
let tmp = [];
|
||
if (isIframe) {
|
||
tmp[0] = idrBit;
|
||
} else {
|
||
tmp[0] = nIdrBit;
|
||
}
|
||
// compositionTime
|
||
tmp[1] = 1;
|
||
tmp[2] = 0;
|
||
tmp[3] = 0;
|
||
tmp[4] = 0;
|
||
const arrayBuffer = new Uint8Array(tmp.length + oneNALBuffer.byteLength);
|
||
arrayBuffer.set(tmp, 0);
|
||
arrayBuffer.set(oneNALBuffer, tmp.length);
|
||
return arrayBuffer;
|
||
}
|
||
function addNaleHeaderLength(nalUnit) {
|
||
const nalUnitLength = nalUnit.byteLength;
|
||
const header = new Uint8Array(4);
|
||
header[0] = nalUnitLength >>> 24 & 0xff;
|
||
header[1] = nalUnitLength >>> 16 & 0xff;
|
||
header[2] = nalUnitLength >>> 8 & 0xff;
|
||
header[3] = nalUnitLength & 0xff;
|
||
const result = new Uint8Array(nalUnitLength + 4);
|
||
result.set(header, 0);
|
||
result.set(nalUnit, 4);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* (NALU类型 & 0001 1111)
|
||
* @param nalu
|
||
* @returns {number}
|
||
*/
|
||
function getAvcSeqHeadType(nalu) {
|
||
return nalu[0] & 0b0001_1111;
|
||
}
|
||
function isAvcSeqHead(type) {
|
||
return type === H264_NAL_TYPE.sps || type === H264_NAL_TYPE.pps;
|
||
}
|
||
function isHvcSEIType(type) {
|
||
return type === H264_NAL_TYPE.kSliceSEI;
|
||
}
|
||
function isNotAvcSeqHead(type) {
|
||
return !isAvcSeqHead(type) && !isHvcSEIType(type);
|
||
}
|
||
function isAvcNaluIFrame(type) {
|
||
return type === H264_NAL_TYPE.iFrame;
|
||
}
|
||
function isSameAvcNaluType(naluList) {
|
||
if (naluList.length === 0) {
|
||
return false;
|
||
}
|
||
const type = getAvcSeqHeadType(naluList[0]);
|
||
for (let i = 1; i < naluList.length; i++) {
|
||
if (type !== getAvcSeqHeadType(naluList[i])) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
const _ebsp2rbsp = uint8array => {
|
||
let src = uint8array;
|
||
let src_length = src.byteLength;
|
||
let dst = new Uint8Array(src_length);
|
||
let dst_idx = 0;
|
||
for (let i = 0; i < src_length; i++) {
|
||
if (i >= 2) {
|
||
// Unescape: Skip 0x03 after 00 00
|
||
if (src[i] === 0x03 && src[i - 1] === 0x00 && src[i - 2] === 0x00) {
|
||
continue;
|
||
}
|
||
}
|
||
dst[dst_idx] = src[i];
|
||
dst_idx++;
|
||
}
|
||
return new Uint8Array(dst.buffer, 0, dst_idx);
|
||
};
|
||
const getLevelString = level_idc => {
|
||
return (level_idc / 30).toFixed(1);
|
||
};
|
||
const getChromaFormatString = chroma_format_idc => {
|
||
switch (chroma_format_idc) {
|
||
case 0:
|
||
return '4:0:0';
|
||
case 1:
|
||
return '4:2:0';
|
||
case 2:
|
||
return '4:2:2';
|
||
case 3:
|
||
return '4:4:4';
|
||
default:
|
||
return 'Unknown';
|
||
}
|
||
};
|
||
const parseHevcSPS = uint8array => {
|
||
let rbsp = _ebsp2rbsp(uint8array);
|
||
let gb = new ExpGolomb(rbsp);
|
||
|
||
/* remove NALu Header */
|
||
gb.readByte();
|
||
gb.readByte();
|
||
let left_offset = 0,
|
||
right_offset = 0,
|
||
top_offset = 0,
|
||
bottom_offset = 0;
|
||
|
||
// SPS
|
||
gb.readBits(4);
|
||
let max_sub_layers_minus1 = gb.readBits(3);
|
||
gb.readBool();
|
||
|
||
// profile_tier_level begin
|
||
let general_profile_space = gb.readBits(2);
|
||
let general_tier_flag = gb.readBool();
|
||
let general_profile_idc = gb.readBits(5);
|
||
let general_profile_compatibility_flags_1 = gb.readByte();
|
||
let general_profile_compatibility_flags_2 = gb.readByte();
|
||
let general_profile_compatibility_flags_3 = gb.readByte();
|
||
let general_profile_compatibility_flags_4 = gb.readByte();
|
||
let general_constraint_indicator_flags_1 = gb.readByte();
|
||
let general_constraint_indicator_flags_2 = gb.readByte();
|
||
let general_constraint_indicator_flags_3 = gb.readByte();
|
||
let general_constraint_indicator_flags_4 = gb.readByte();
|
||
let general_constraint_indicator_flags_5 = gb.readByte();
|
||
let general_constraint_indicator_flags_6 = gb.readByte();
|
||
let general_level_idc = gb.readByte();
|
||
let sub_layer_profile_present_flag = [];
|
||
let sub_layer_level_present_flag = [];
|
||
for (let i = 0; i < max_sub_layers_minus1; i++) {
|
||
sub_layer_profile_present_flag.push(gb.readBool());
|
||
sub_layer_level_present_flag.push(gb.readBool());
|
||
}
|
||
if (max_sub_layers_minus1 > 0) {
|
||
for (let i = max_sub_layers_minus1; i < 8; i++) {
|
||
gb.readBits(2);
|
||
}
|
||
}
|
||
for (let i = 0; i < max_sub_layers_minus1; i++) {
|
||
if (sub_layer_profile_present_flag[i]) {
|
||
gb.readByte(); // sub_layer_profile_space, sub_layer_tier_flag, sub_layer_profile_idc
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte(); // sub_layer_profile_compatibility_flag
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte();
|
||
}
|
||
if (sub_layer_profile_present_flag[i]) {
|
||
gb.readByte();
|
||
}
|
||
}
|
||
// profile_tier_level end
|
||
|
||
gb.readUEG();
|
||
let chroma_format_idc = gb.readUEG();
|
||
if (chroma_format_idc == 3) {
|
||
gb.readBits(1); // separate_colour_plane_flag
|
||
}
|
||
|
||
let pic_width_in_luma_samples = gb.readUEG();
|
||
let pic_height_in_luma_samples = gb.readUEG();
|
||
let conformance_window_flag = gb.readBool();
|
||
if (conformance_window_flag) {
|
||
left_offset += gb.readUEG();
|
||
right_offset += gb.readUEG();
|
||
top_offset += gb.readUEG();
|
||
bottom_offset += gb.readUEG();
|
||
}
|
||
let bit_depth_luma_minus8 = gb.readUEG();
|
||
let bit_depth_chroma_minus8 = gb.readUEG();
|
||
let log2_max_pic_order_cnt_lsb_minus4 = gb.readUEG();
|
||
let sub_layer_ordering_info_present_flag = gb.readBool();
|
||
for (let i = sub_layer_ordering_info_present_flag ? 0 : max_sub_layers_minus1; i <= max_sub_layers_minus1; i++) {
|
||
gb.readUEG(); // max_dec_pic_buffering_minus1[i]
|
||
gb.readUEG(); // max_num_reorder_pics[i]
|
||
gb.readUEG(); // max_latency_increase_plus1[i]
|
||
}
|
||
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
let scaling_list_enabled_flag = gb.readBool();
|
||
if (scaling_list_enabled_flag) {
|
||
let sps_scaling_list_data_present_flag = gb.readBool();
|
||
if (sps_scaling_list_data_present_flag) {
|
||
for (let sizeId = 0; sizeId < 4; sizeId++) {
|
||
for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
|
||
let scaling_list_pred_mode_flag = gb.readBool();
|
||
if (!scaling_list_pred_mode_flag) {
|
||
gb.readUEG(); // scaling_list_pred_matrix_id_delta
|
||
} else {
|
||
let coefNum = Math.min(64, 1 << 4 + (sizeId << 1));
|
||
if (sizeId > 1) {
|
||
gb.readSEG();
|
||
}
|
||
for (let i = 0; i < coefNum; i++) {
|
||
gb.readSEG();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
gb.readBool();
|
||
gb.readBool();
|
||
let pcm_enabled_flag = gb.readBool();
|
||
if (pcm_enabled_flag) {
|
||
gb.readByte();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readBool();
|
||
}
|
||
let num_short_term_ref_pic_sets = gb.readUEG();
|
||
let num_delta_pocs = 0;
|
||
for (let i = 0; i < num_short_term_ref_pic_sets; i++) {
|
||
let inter_ref_pic_set_prediction_flag = false;
|
||
if (i !== 0) {
|
||
inter_ref_pic_set_prediction_flag = gb.readBool();
|
||
}
|
||
if (inter_ref_pic_set_prediction_flag) {
|
||
if (i === num_short_term_ref_pic_sets) {
|
||
gb.readUEG();
|
||
}
|
||
gb.readBool();
|
||
gb.readUEG();
|
||
let next_num_delta_pocs = 0;
|
||
for (let j = 0; j <= num_delta_pocs; j++) {
|
||
let used_by_curr_pic_flag = gb.readBool();
|
||
let use_delta_flag = false;
|
||
if (!used_by_curr_pic_flag) {
|
||
use_delta_flag = gb.readBool();
|
||
}
|
||
if (used_by_curr_pic_flag || use_delta_flag) {
|
||
next_num_delta_pocs++;
|
||
}
|
||
}
|
||
num_delta_pocs = next_num_delta_pocs;
|
||
} else {
|
||
let num_negative_pics = gb.readUEG();
|
||
let num_positive_pics = gb.readUEG();
|
||
num_delta_pocs = num_negative_pics + num_positive_pics;
|
||
for (let j = 0; j < num_negative_pics; j++) {
|
||
gb.readUEG();
|
||
gb.readBool();
|
||
}
|
||
for (let j = 0; j < num_positive_pics; j++) {
|
||
gb.readUEG();
|
||
gb.readBool();
|
||
}
|
||
}
|
||
}
|
||
let long_term_ref_pics_present_flag = gb.readBool();
|
||
if (long_term_ref_pics_present_flag) {
|
||
let num_long_term_ref_pics_sps = gb.readUEG();
|
||
for (let i = 0; i < num_long_term_ref_pics_sps; i++) {
|
||
for (let j = 0; j < log2_max_pic_order_cnt_lsb_minus4 + 4; j++) {
|
||
gb.readBits(1);
|
||
}
|
||
gb.readBits(1);
|
||
}
|
||
}
|
||
//*
|
||
let default_display_window_flag = false; // for calc offset
|
||
let min_spatial_segmentation_idc = 0; // for hvcC
|
||
let sar_width = 1,
|
||
sar_height = 1;
|
||
let fps_fixed = false,
|
||
fps_den = 1,
|
||
fps_num = 1;
|
||
//*/
|
||
gb.readBool();
|
||
gb.readBool();
|
||
let vui_parameters_present_flag = gb.readBool();
|
||
if (vui_parameters_present_flag) {
|
||
let aspect_ratio_info_present_flag = gb.readBool();
|
||
if (aspect_ratio_info_present_flag) {
|
||
let aspect_ratio_idc = gb.readByte();
|
||
let sar_w_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
|
||
let sar_h_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
|
||
if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
|
||
sar_width = sar_w_table[aspect_ratio_idc - 1];
|
||
sar_height = sar_h_table[aspect_ratio_idc - 1];
|
||
} else if (aspect_ratio_idc === 255) {
|
||
sar_width = gb.readBits(16);
|
||
sar_height = gb.readBits(16);
|
||
}
|
||
}
|
||
let overscan_info_present_flag = gb.readBool();
|
||
if (overscan_info_present_flag) {
|
||
gb.readBool();
|
||
}
|
||
let video_signal_type_present_flag = gb.readBool();
|
||
if (video_signal_type_present_flag) {
|
||
gb.readBits(3);
|
||
gb.readBool();
|
||
let colour_description_present_flag = gb.readBool();
|
||
if (colour_description_present_flag) {
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readByte();
|
||
}
|
||
}
|
||
let chroma_loc_info_present_flag = gb.readBool();
|
||
if (chroma_loc_info_present_flag) {
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
}
|
||
gb.readBool();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
default_display_window_flag = gb.readBool();
|
||
if (default_display_window_flag) {
|
||
left_offset += gb.readUEG();
|
||
right_offset += gb.readUEG();
|
||
top_offset += gb.readUEG();
|
||
bottom_offset += gb.readUEG();
|
||
}
|
||
let vui_timing_info_present_flag = gb.readBool();
|
||
if (vui_timing_info_present_flag) {
|
||
fps_den = gb.readBits(32);
|
||
fps_num = gb.readBits(32);
|
||
let vui_poc_proportional_to_timing_flag = gb.readBool();
|
||
if (vui_poc_proportional_to_timing_flag) {
|
||
gb.readUEG();
|
||
let vui_hrd_parameters_present_flag = gb.readBool();
|
||
if (vui_hrd_parameters_present_flag) {
|
||
let nal_hrd_parameters_present_flag = false;
|
||
let vcl_hrd_parameters_present_flag = false;
|
||
let sub_pic_hrd_params_present_flag = false;
|
||
{
|
||
nal_hrd_parameters_present_flag = gb.readBool();
|
||
vcl_hrd_parameters_present_flag = gb.readBool();
|
||
if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
|
||
sub_pic_hrd_params_present_flag = gb.readBool();
|
||
if (sub_pic_hrd_params_present_flag) {
|
||
gb.readByte();
|
||
gb.readBits(5);
|
||
gb.readBool();
|
||
gb.readBits(5);
|
||
}
|
||
gb.readBits(4);
|
||
gb.readBits(4);
|
||
if (sub_pic_hrd_params_present_flag) {
|
||
gb.readBits(4);
|
||
}
|
||
gb.readBits(5);
|
||
gb.readBits(5);
|
||
gb.readBits(5);
|
||
}
|
||
}
|
||
for (let i = 0; i <= max_sub_layers_minus1; i++) {
|
||
let fixed_pic_rate_general_flag = gb.readBool();
|
||
fps_fixed = fixed_pic_rate_general_flag;
|
||
let fixed_pic_rate_within_cvs_flag = false;
|
||
let cpbCnt = 1;
|
||
if (!fixed_pic_rate_general_flag) {
|
||
fixed_pic_rate_within_cvs_flag = gb.readBool();
|
||
}
|
||
let low_delay_hrd_flag = false;
|
||
if (fixed_pic_rate_within_cvs_flag) {
|
||
gb.readSEG();
|
||
} else {
|
||
low_delay_hrd_flag = gb.readBool();
|
||
}
|
||
if (!low_delay_hrd_flag) {
|
||
cpbcnt = gb.readUEG() + 1;
|
||
}
|
||
if (nal_hrd_parameters_present_flag) {
|
||
for (let j = 0; j < cpbCnt; j++) {
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
if (sub_pic_hrd_params_present_flag) {
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
}
|
||
}
|
||
}
|
||
if (vcl_hrd_parameters_present_flag) {
|
||
for (let j = 0; j < cpbCnt; j++) {
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
if (sub_pic_hrd_params_present_flag) {
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let bitstream_restriction_flag = gb.readBool();
|
||
if (bitstream_restriction_flag) {
|
||
gb.readBool();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
min_spatial_segmentation_idc = gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
}
|
||
}
|
||
gb.readBool(); // ignore...
|
||
|
||
// for meta data
|
||
let codec_mimetype = `hvc1.${general_profile_idc}.1.L${general_level_idc}.B0`;
|
||
let codec_width = pic_width_in_luma_samples;
|
||
let codec_height = pic_height_in_luma_samples;
|
||
let sar_scale = 1;
|
||
if (sar_width !== 1 && sar_height !== 1) {
|
||
sar_scale = sar_width / sar_height;
|
||
}
|
||
gb.destroy();
|
||
gb = null;
|
||
return {
|
||
codec_mimetype,
|
||
level_string: getLevelString(general_level_idc),
|
||
profile_idc: general_profile_idc,
|
||
bit_depth: bit_depth_luma_minus8 + 8,
|
||
ref_frames: 1,
|
||
// FIXME!!!
|
||
chroma_format: chroma_format_idc,
|
||
chroma_format_string: getChromaFormatString(chroma_format_idc),
|
||
general_level_idc,
|
||
general_profile_space,
|
||
general_tier_flag,
|
||
general_profile_idc,
|
||
general_profile_compatibility_flags_1,
|
||
general_profile_compatibility_flags_2,
|
||
general_profile_compatibility_flags_3,
|
||
general_profile_compatibility_flags_4,
|
||
general_constraint_indicator_flags_1,
|
||
general_constraint_indicator_flags_2,
|
||
general_constraint_indicator_flags_3,
|
||
general_constraint_indicator_flags_4,
|
||
general_constraint_indicator_flags_5,
|
||
general_constraint_indicator_flags_6,
|
||
min_spatial_segmentation_idc,
|
||
constant_frame_rate: 0 /* FIXME!! fps_fixed ? 1 : 0? */,
|
||
chroma_format_idc,
|
||
bit_depth_luma_minus8,
|
||
bit_depth_chroma_minus8,
|
||
frame_rate: {
|
||
fixed: fps_fixed,
|
||
fps: fps_num / fps_den,
|
||
fps_den: fps_den,
|
||
fps_num: fps_num
|
||
},
|
||
sar_ratio: {
|
||
width: sar_width,
|
||
height: sar_height
|
||
},
|
||
codec_size: {
|
||
width: codec_width,
|
||
height: codec_height
|
||
},
|
||
present_size: {
|
||
width: codec_width * sar_scale,
|
||
height: codec_height
|
||
}
|
||
};
|
||
};
|
||
const parseHevcVPS = uint8array => {
|
||
let rbsp = _ebsp2rbsp(uint8array);
|
||
let gb = new ExpGolomb(rbsp);
|
||
|
||
/* remove NALu Header */
|
||
gb.readByte();
|
||
gb.readByte();
|
||
|
||
// VPS
|
||
gb.readBits(4);
|
||
gb.readBits(2);
|
||
gb.readBits(6);
|
||
let max_sub_layers_minus1 = gb.readBits(3);
|
||
let temporal_id_nesting_flag = gb.readBool();
|
||
// and more ...
|
||
|
||
return {
|
||
num_temporal_layers: max_sub_layers_minus1 + 1,
|
||
temporal_id_nested: temporal_id_nesting_flag
|
||
};
|
||
};
|
||
const parseHevcPPS = uint8array => {
|
||
let rbsp = _ebsp2rbsp(uint8array);
|
||
let gb = new ExpGolomb(rbsp);
|
||
|
||
/* remove NALu Header */
|
||
gb.readByte();
|
||
gb.readByte();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
gb.readBits(3);
|
||
gb.readBool();
|
||
gb.readBool();
|
||
gb.readUEG();
|
||
gb.readUEG();
|
||
gb.readSEG();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
let cu_qp_delta_enabled_flag = gb.readBool();
|
||
if (cu_qp_delta_enabled_flag) {
|
||
gb.readUEG();
|
||
}
|
||
gb.readSEG();
|
||
gb.readSEG();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
gb.readBool();
|
||
let tiles_enabled_flag = gb.readBool();
|
||
let entropy_coding_sync_enabled_flag = gb.readBool();
|
||
// and more ...
|
||
|
||
// needs hvcC
|
||
let parallelismType = 1; // slice-based parallel decoding
|
||
if (entropy_coding_sync_enabled_flag && tiles_enabled_flag) {
|
||
parallelismType = 0; // mixed-type parallel decoding
|
||
} else if (entropy_coding_sync_enabled_flag) {
|
||
parallelismType = 3; // wavefront-based parallel decoding
|
||
} else if (tiles_enabled_flag) {
|
||
parallelismType = 2; // tile-based parallel decoding
|
||
}
|
||
|
||
return {
|
||
parallelismType
|
||
};
|
||
};
|
||
|
||
function hevcEncoderConfigurationRecord$2(_ref2) {
|
||
let {
|
||
vps,
|
||
pps,
|
||
sps
|
||
} = _ref2;
|
||
let detail = {
|
||
configurationVersion: 1
|
||
};
|
||
const vpsDetail = parseHevcVPS(vps);
|
||
const spsDetail = parseHevcSPS(sps);
|
||
const ppsDetail = parseHevcPPS(pps);
|
||
detail = Object.assign(detail, vpsDetail, spsDetail, ppsDetail);
|
||
let length = 23 + (3 + 2 + vps.byteLength) + (3 + 2 + sps.byteLength) + (3 + 2 + pps.byteLength);
|
||
let data = new Uint8Array(length);
|
||
data[0] = 0x01; // configurationVersion
|
||
data[1] = (detail.general_profile_space & 0x03) << 6 | (detail.general_tier_flag ? 1 : 0) << 5 | detail.general_profile_idc & 0x1F;
|
||
data[2] = detail.general_profile_compatibility_flags_1 || 0;
|
||
data[3] = detail.general_profile_compatibility_flags_2 || 0;
|
||
data[4] = detail.general_profile_compatibility_flags_3 || 0;
|
||
data[5] = detail.general_profile_compatibility_flags_4 || 0;
|
||
data[6] = detail.general_constraint_indicator_flags_1 || 0;
|
||
data[7] = detail.general_constraint_indicator_flags_2 || 0;
|
||
data[8] = detail.general_constraint_indicator_flags_3 || 0;
|
||
data[9] = detail.general_constraint_indicator_flags_4 || 0;
|
||
data[10] = detail.general_constraint_indicator_flags_5 || 0;
|
||
data[11] = detail.general_constraint_indicator_flags_6 || 0;
|
||
data[12] = 0x3C;
|
||
data[13] = 0xF0 | (detail.min_spatial_segmentation_idc & 0x0F00) >> 8;
|
||
data[14] = detail.min_spatial_segmentation_idc & 0xFF;
|
||
data[15] = 0xFC | detail.parallelismType & 0x03;
|
||
data[16] = 0xFC | detail.chroma_format_idc & 0x03;
|
||
data[17] = 0xF8 | detail.bit_depth_luma_minus8 & 0x07;
|
||
data[18] = 0xF8 | detail.bit_depth_chroma_minus8 & 0x07;
|
||
data[19] = 0;
|
||
data[20] = 0;
|
||
data[21] = (detail.constant_frame_rate & 0x03) << 6 | (detail.num_temporal_layers & 0x07) << 3 | (detail.temporal_id_nested ? 1 : 0) << 2 | 3;
|
||
data[22] = 3;
|
||
data[23 + 0 + 0] = 0x80 | H265_NAL_TYPE.vps;
|
||
data[23 + 0 + 1] = 0;
|
||
data[23 + 0 + 2] = 1;
|
||
data[23 + 0 + 3] = (vps.byteLength & 0xFF00) >> 8;
|
||
data[23 + 0 + 4] = (vps.byteLength & 0x00FF) >> 0;
|
||
data.set(vps, 23 + 0 + 5);
|
||
data[23 + (5 + vps.byteLength) + 0] = 0x80 | H265_NAL_TYPE.sps;
|
||
data[23 + (5 + vps.byteLength) + 1] = 0;
|
||
data[23 + (5 + vps.byteLength) + 2] = 1;
|
||
data[23 + (5 + vps.byteLength) + 3] = (sps.byteLength & 0xFF00) >> 8;
|
||
data[23 + (5 + vps.byteLength) + 4] = (sps.byteLength & 0x00FF) >> 0;
|
||
data.set(sps, 23 + (5 + vps.byteLength) + 5);
|
||
data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 0] = 0x80 | H265_NAL_TYPE.pps;
|
||
data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 1] = 0;
|
||
data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 2] = 1;
|
||
data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 3] = (pps.byteLength & 0xFF00) >> 8;
|
||
data[23 + (5 + vps.byteLength + 5 + sps.byteLength) + 4] = (pps.byteLength & 0x00FF) >> 0;
|
||
data.set(pps, 23 + (5 + vps.byteLength + 5 + sps.byteLength) + 5);
|
||
const prevData = [0x1c, 0, 0, 0, 0];
|
||
const newData = new Uint8Array(prevData.length + data.byteLength);
|
||
newData.set(prevData, 0);
|
||
newData.set(data, prevData.length);
|
||
return newData;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param oneNALBuffer
|
||
* @param isIframe
|
||
* @returns {Uint8Array}
|
||
*/
|
||
function hevcEncoderNalePacket(oneNALBuffer, isIframe) {
|
||
// 正常发送nal
|
||
// 这边增加 是否i帧， 然后前面封装了1 + 8 个字节的数据。
|
||
const idrBit = 0x10 | 12;
|
||
const nIdrBit = 0x20 | 12;
|
||
let tmp = [];
|
||
if (isIframe) {
|
||
tmp[0] = idrBit;
|
||
} else {
|
||
tmp[0] = nIdrBit;
|
||
}
|
||
tmp[1] = 1;
|
||
//
|
||
tmp[2] = 0;
|
||
tmp[3] = 0;
|
||
tmp[4] = 0;
|
||
// 真正开始的地方。。。
|
||
tmp[5] = oneNALBuffer.byteLength >> 24 & 0xff;
|
||
tmp[6] = oneNALBuffer.byteLength >> 16 & 0xff;
|
||
tmp[7] = oneNALBuffer.byteLength >> 8 & 0xff;
|
||
tmp[8] = oneNALBuffer.byteLength & 0xff;
|
||
const arrayBuffer = new Uint8Array(tmp.length + oneNALBuffer.byteLength);
|
||
arrayBuffer.set(tmp, 0);
|
||
arrayBuffer.set(oneNALBuffer, tmp.length);
|
||
return arrayBuffer;
|
||
}
|
||
function getHevcSeqHeadType(nalu) {
|
||
return (nalu[0] & 0x7E) >> 1;
|
||
}
|
||
function isHevcSEIType(type) {
|
||
return type === H265_NAL_TYPE.sei;
|
||
}
|
||
|
||
// 32-40是VPS SPS PPS SUFFIX_SEI_NUT等
|
||
function isHevcSeqHead(type) {
|
||
return type >= 32 && type <= 40;
|
||
}
|
||
function isNotHevcSeqHead(type) {
|
||
return !isHevcSeqHead(type);
|
||
}
|
||
|
||
// 16-21是关键(I)帧
|
||
function isHevcNalIFrame(type) {
|
||
return type >= 16 && type <= 21;
|
||
}
|
||
|
||
function checkInt(value) {
|
||
return parseInt(value) === value;
|
||
}
|
||
function checkInts(arrayish) {
|
||
if (!checkInt(arrayish.length)) {
|
||
return false;
|
||
}
|
||
for (var i = 0; i < arrayish.length; i++) {
|
||
if (!checkInt(arrayish[i]) || arrayish[i] < 0 || arrayish[i] > 255) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
function coerceArray(arg, copy) {
|
||
// ArrayBuffer view
|
||
if (arg.buffer && arg.name === 'Uint8Array') {
|
||
if (copy) {
|
||
if (arg.slice) {
|
||
arg = arg.slice();
|
||
} else {
|
||
arg = Array.prototype.slice.call(arg);
|
||
}
|
||
}
|
||
return arg;
|
||
}
|
||
|
||
// It's an array; check it is a valid representation of a byte
|
||
if (Array.isArray(arg)) {
|
||
if (!checkInts(arg)) {
|
||
throw new Error('Array contains invalid value: ' + arg);
|
||
}
|
||
return new Uint8Array(arg);
|
||
}
|
||
|
||
// Something else, but behaves like an array (maybe a Buffer? Arguments?)
|
||
if (checkInt(arg.length) && checkInts(arg)) {
|
||
return new Uint8Array(arg);
|
||
}
|
||
throw new Error('unsupported array-like object');
|
||
}
|
||
function createArray(length) {
|
||
return new Uint8Array(length);
|
||
}
|
||
function copyArray(sourceArray, targetArray, targetStart, sourceStart, sourceEnd) {
|
||
if (sourceStart != null || sourceEnd != null) {
|
||
if (sourceArray.slice) {
|
||
sourceArray = sourceArray.slice(sourceStart, sourceEnd);
|
||
} else {
|
||
sourceArray = Array.prototype.slice.call(sourceArray, sourceStart, sourceEnd);
|
||
}
|
||
}
|
||
targetArray.set(sourceArray, targetStart);
|
||
}
|
||
var convertUtf8 = function () {
|
||
function toBytes(text) {
|
||
var result = [],
|
||
i = 0;
|
||
text = encodeURI(text);
|
||
while (i < text.length) {
|
||
var c = text.charCodeAt(i++);
|
||
|
||
// if it is a % sign, encode the following 2 bytes as a hex value
|
||
if (c === 37) {
|
||
result.push(parseInt(text.substr(i, 2), 16));
|
||
i += 2;
|
||
|
||
// otherwise, just the actual byte
|
||
} else {
|
||
result.push(c);
|
||
}
|
||
}
|
||
return coerceArray(result);
|
||
}
|
||
function fromBytes(bytes) {
|
||
var result = [],
|
||
i = 0;
|
||
while (i < bytes.length) {
|
||
var c = bytes[i];
|
||
if (c < 128) {
|
||
result.push(String.fromCharCode(c));
|
||
i++;
|
||
} else if (c > 191 && c < 224) {
|
||
result.push(String.fromCharCode((c & 0x1f) << 6 | bytes[i + 1] & 0x3f));
|
||
i += 2;
|
||
} else {
|
||
result.push(String.fromCharCode((c & 0x0f) << 12 | (bytes[i + 1] & 0x3f) << 6 | bytes[i + 2] & 0x3f));
|
||
i += 3;
|
||
}
|
||
}
|
||
return result.join('');
|
||
}
|
||
return {
|
||
toBytes: toBytes,
|
||
fromBytes: fromBytes
|
||
};
|
||
}();
|
||
var convertHex = function () {
|
||
function toBytes(text) {
|
||
var result = [];
|
||
for (var i = 0; i < text.length; i += 2) {
|
||
result.push(parseInt(text.substr(i, 2), 16));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// http://ixti.net/development/javascript/2011/11/11/base64-encodedecode-of-utf8-in-browser-with-js.html
|
||
var Hex = '0123456789abcdef';
|
||
function fromBytes(bytes) {
|
||
var result = [];
|
||
for (var i = 0; i < bytes.length; i++) {
|
||
var v = bytes[i];
|
||
result.push(Hex[(v & 0xf0) >> 4] + Hex[v & 0x0f]);
|
||
}
|
||
return result.join('');
|
||
}
|
||
return {
|
||
toBytes: toBytes,
|
||
fromBytes: fromBytes
|
||
};
|
||
}();
|
||
|
||
// Number of rounds by keysize
|
||
var numberOfRounds = {
|
||
16: 10,
|
||
24: 12,
|
||
32: 14
|
||
};
|
||
|
||
// Round constant words
|
||
var rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91];
|
||
|
||
// S-box and Inverse S-box (S is for Substitution)
|
||
var S = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16];
|
||
var Si = [0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d];
|
||
|
||
// Transformations for encryption
|
||
var T1 = [0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a];
|
||
var T2 = [0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0xec41adad, 0x67b3d4d4, 0xfd5fa2a2, 0xea45afaf, 0xbf239c9c, 0xf753a4a4, 0x96e47272, 0x5b9bc0c0, 0xc275b7b7, 0x1ce1fdfd, 0xae3d9393, 0x6a4c2626, 0x5a6c3636, 0x417e3f3f, 0x02f5f7f7, 0x4f83cccc, 0x5c683434, 0xf451a5a5, 0x34d1e5e5, 0x08f9f1f1, 0x93e27171, 0x73abd8d8, 0x53623131, 0x3f2a1515, 0x0c080404, 0x5295c7c7, 0x65462323, 0x5e9dc3c3, 0x28301818, 0xa1379696, 0x0f0a0505, 0xb52f9a9a, 0x090e0707, 0x36241212, 0x9b1b8080, 0x3ddfe2e2, 0x26cdebeb, 0x694e2727, 0xcd7fb2b2, 0x9fea7575, 0x1b120909, 0x9e1d8383, 0x74582c2c, 0x2e341a1a, 0x2d361b1b, 0xb2dc6e6e, 0xeeb45a5a, 0xfb5ba0a0, 0xf6a45252, 0x4d763b3b, 0x61b7d6d6, 0xce7db3b3, 0x7b522929, 0x3edde3e3, 0x715e2f2f, 0x97138484, 0xf5a65353, 0x68b9d1d1, 0x00000000, 0x2cc1eded, 0x60402020, 0x1fe3fcfc, 0xc879b1b1, 0xedb65b5b, 0xbed46a6a, 0x468dcbcb, 0xd967bebe, 0x4b723939, 0xde944a4a, 0xd4984c4c, 0xe8b05858, 0x4a85cfcf, 0x6bbbd0d0, 0x2ac5efef, 0xe54faaaa, 0x16edfbfb, 0xc5864343, 0xd79a4d4d, 0x55663333, 0x94118585, 0xcf8a4545, 0x10e9f9f9, 0x06040202, 0x81fe7f7f, 0xf0a05050, 0x44783c3c, 0xba259f9f, 0xe34ba8a8, 0xf3a25151, 0xfe5da3a3, 0xc0804040, 0x8a058f8f, 0xad3f9292, 0xbc219d9d, 0x48703838, 0x04f1f5f5, 0xdf63bcbc, 0xc177b6b6, 0x75afdada, 0x63422121, 0x30201010, 0x1ae5ffff, 0x0efdf3f3, 0x6dbfd2d2, 0x4c81cdcd, 0x14180c0c, 0x35261313, 0x2fc3ecec, 0xe1be5f5f, 0xa2359797, 0xcc884444, 0x392e1717, 0x5793c4c4, 0xf255a7a7, 0x82fc7e7e, 0x477a3d3d, 0xacc86464, 0xe7ba5d5d, 0x2b321919, 0x95e67373, 0xa0c06060, 0x98198181, 0xd19e4f4f, 0x7fa3dcdc, 0x66442222, 0x7e542a2a, 0xab3b9090, 0x830b8888, 0xca8c4646, 0x29c7eeee, 0xd36bb8b8, 0x3c281414, 0x79a7dede, 0xe2bc5e5e, 0x1d160b0b, 0x76addbdb, 0x3bdbe0e0, 0x56643232, 0x4e743a3a, 0x1e140a0a, 0xdb924949, 0x0a0c0606, 0x6c482424, 0xe4b85c5c, 0x5d9fc2c2, 0x6ebdd3d3, 0xef43acac, 0xa6c46262, 0xa8399191, 0xa4319595, 0x37d3e4e4, 0x8bf27979, 0x32d5e7e7, 0x438bc8c8, 0x596e3737, 0xb7da6d6d, 0x8c018d8d, 0x64b1d5d5, 0xd29c4e4e, 0xe049a9a9, 0xb4d86c6c, 0xfaac5656, 0x07f3f4f4, 0x25cfeaea, 0xafca6565, 0x8ef47a7a, 0xe947aeae, 0x18100808, 0xd56fbaba, 0x88f07878, 0x6f4a2525, 0x725c2e2e, 0x24381c1c, 0xf157a6a6, 0xc773b4b4, 0x5197c6c6, 0x23cbe8e8, 0x7ca1dddd, 0x9ce87474, 0x213e1f1f, 0xdd964b4b, 0xdc61bdbd, 0x860d8b8b, 0x850f8a8a, 0x90e07070, 0x427c3e3e, 0xc471b5b5, 0xaacc6666, 0xd8904848, 0x05060303, 0x01f7f6f6, 0x121c0e0e, 0xa3c26161, 0x5f6a3535, 0xf9ae5757, 0xd069b9b9, 0x91178686, 0x5899c1c1, 0x273a1d1d, 0xb9279e9e, 0x38d9e1e1, 0x13ebf8f8, 0xb32b9898, 0x33221111, 0xbbd26969, 0x70a9d9d9, 0x89078e8e, 0xa7339494, 0xb62d9b9b, 0x223c1e1e, 0x92158787, 0x20c9e9e9, 0x4987cece, 0xffaa5555, 0x78502828, 0x7aa5dfdf, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616];
|
||
var T3 = [0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xadec41ad, 0xd467b3d4, 0xa2fd5fa2, 0xafea45af, 0x9cbf239c, 0xa4f753a4, 0x7296e472, 0xc05b9bc0, 0xb7c275b7, 0xfd1ce1fd, 0x93ae3d93, 0x266a4c26, 0x365a6c36, 0x3f417e3f, 0xf702f5f7, 0xcc4f83cc, 0x345c6834, 0xa5f451a5, 0xe534d1e5, 0xf108f9f1, 0x7193e271, 0xd873abd8, 0x31536231, 0x153f2a15, 0x040c0804, 0xc75295c7, 0x23654623, 0xc35e9dc3, 0x18283018, 0x96a13796, 0x050f0a05, 0x9ab52f9a, 0x07090e07, 0x12362412, 0x809b1b80, 0xe23ddfe2, 0xeb26cdeb, 0x27694e27, 0xb2cd7fb2, 0x759fea75, 0x091b1209, 0x839e1d83, 0x2c74582c, 0x1a2e341a, 0x1b2d361b, 0x6eb2dc6e, 0x5aeeb45a, 0xa0fb5ba0, 0x52f6a452, 0x3b4d763b, 0xd661b7d6, 0xb3ce7db3, 0x297b5229, 0xe33edde3, 0x2f715e2f, 0x84971384, 0x53f5a653, 0xd168b9d1, 0x00000000, 0xed2cc1ed, 0x20604020, 0xfc1fe3fc, 0xb1c879b1, 0x5bedb65b, 0x6abed46a, 0xcb468dcb, 0xbed967be, 0x394b7239, 0x4ade944a, 0x4cd4984c, 0x58e8b058, 0xcf4a85cf, 0xd06bbbd0, 0xef2ac5ef, 0xaae54faa, 0xfb16edfb, 0x43c58643, 0x4dd79a4d, 0x33556633, 0x85941185, 0x45cf8a45, 0xf910e9f9, 0x02060402, 0x7f81fe7f, 0x50f0a050, 0x3c44783c, 0x9fba259f, 0xa8e34ba8, 0x51f3a251, 0xa3fe5da3, 0x40c08040, 0x8f8a058f, 0x92ad3f92, 0x9dbc219d, 0x38487038, 0xf504f1f5, 0xbcdf63bc, 0xb6c177b6, 0xda75afda, 0x21634221, 0x10302010, 0xff1ae5ff, 0xf30efdf3, 0xd26dbfd2, 0xcd4c81cd, 0x0c14180c, 0x13352613, 0xec2fc3ec, 0x5fe1be5f, 0x97a23597, 0x44cc8844, 0x17392e17, 0xc45793c4, 0xa7f255a7, 0x7e82fc7e, 0x3d477a3d, 0x64acc864, 0x5de7ba5d, 0x192b3219, 0x7395e673, 0x60a0c060, 0x81981981, 0x4fd19e4f, 0xdc7fa3dc, 0x22664422, 0x2a7e542a, 0x90ab3b90, 0x88830b88, 0x46ca8c46, 0xee29c7ee, 0xb8d36bb8, 0x143c2814, 0xde79a7de, 0x5ee2bc5e, 0x0b1d160b, 0xdb76addb, 0xe03bdbe0, 0x32566432, 0x3a4e743a, 0x0a1e140a, 0x49db9249, 0x060a0c06, 0x246c4824, 0x5ce4b85c, 0xc25d9fc2, 0xd36ebdd3, 0xacef43ac, 0x62a6c462, 0x91a83991, 0x95a43195, 0xe437d3e4, 0x798bf279, 0xe732d5e7, 0xc8438bc8, 0x37596e37, 0x6db7da6d, 0x8d8c018d, 0xd564b1d5, 0x4ed29c4e, 0xa9e049a9, 0x6cb4d86c, 0x56faac56, 0xf407f3f4, 0xea25cfea, 0x65afca65, 0x7a8ef47a, 0xaee947ae, 0x08181008, 0xbad56fba, 0x7888f078, 0x256f4a25, 0x2e725c2e, 0x1c24381c, 0xa6f157a6, 0xb4c773b4, 0xc65197c6, 0xe823cbe8, 0xdd7ca1dd, 0x749ce874, 0x1f213e1f, 0x4bdd964b, 0xbddc61bd, 0x8b860d8b, 0x8a850f8a, 0x7090e070, 0x3e427c3e, 0xb5c471b5, 0x66aacc66, 0x48d89048, 0x03050603, 0xf601f7f6, 0x0e121c0e, 0x61a3c261, 0x355f6a35, 0x57f9ae57, 0xb9d069b9, 0x86911786, 0xc15899c1, 0x1d273a1d, 0x9eb9279e, 0xe138d9e1, 0xf813ebf8, 0x98b32b98, 0x11332211, 0x69bbd269, 0xd970a9d9, 0x8e89078e, 0x94a73394, 0x9bb62d9b, 0x1e223c1e, 0x87921587, 0xe920c9e9, 0xce4987ce, 0x55ffaa55, 0x28785028, 0xdf7aa5df, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16];
|
||
var T4 = [0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xadadec41, 0xd4d467b3, 0xa2a2fd5f, 0xafafea45, 0x9c9cbf23, 0xa4a4f753, 0x727296e4, 0xc0c05b9b, 0xb7b7c275, 0xfdfd1ce1, 0x9393ae3d, 0x26266a4c, 0x36365a6c, 0x3f3f417e, 0xf7f702f5, 0xcccc4f83, 0x34345c68, 0xa5a5f451, 0xe5e534d1, 0xf1f108f9, 0x717193e2, 0xd8d873ab, 0x31315362, 0x15153f2a, 0x04040c08, 0xc7c75295, 0x23236546, 0xc3c35e9d, 0x18182830, 0x9696a137, 0x05050f0a, 0x9a9ab52f, 0x0707090e, 0x12123624, 0x80809b1b, 0xe2e23ddf, 0xebeb26cd, 0x2727694e, 0xb2b2cd7f, 0x75759fea, 0x09091b12, 0x83839e1d, 0x2c2c7458, 0x1a1a2e34, 0x1b1b2d36, 0x6e6eb2dc, 0x5a5aeeb4, 0xa0a0fb5b, 0x5252f6a4, 0x3b3b4d76, 0xd6d661b7, 0xb3b3ce7d, 0x29297b52, 0xe3e33edd, 0x2f2f715e, 0x84849713, 0x5353f5a6, 0xd1d168b9, 0x00000000, 0xeded2cc1, 0x20206040, 0xfcfc1fe3, 0xb1b1c879, 0x5b5bedb6, 0x6a6abed4, 0xcbcb468d, 0xbebed967, 0x39394b72, 0x4a4ade94, 0x4c4cd498, 0x5858e8b0, 0xcfcf4a85, 0xd0d06bbb, 0xefef2ac5, 0xaaaae54f, 0xfbfb16ed, 0x4343c586, 0x4d4dd79a, 0x33335566, 0x85859411, 0x4545cf8a, 0xf9f910e9, 0x02020604, 0x7f7f81fe, 0x5050f0a0, 0x3c3c4478, 0x9f9fba25, 0xa8a8e34b, 0x5151f3a2, 0xa3a3fe5d, 0x4040c080, 0x8f8f8a05, 0x9292ad3f, 0x9d9dbc21, 0x38384870, 0xf5f504f1, 0xbcbcdf63, 0xb6b6c177, 0xdada75af, 0x21216342, 0x10103020, 0xffff1ae5, 0xf3f30efd, 0xd2d26dbf, 0xcdcd4c81, 0x0c0c1418, 0x13133526, 0xecec2fc3, 0x5f5fe1be, 0x9797a235, 0x4444cc88, 0x1717392e, 0xc4c45793, 0xa7a7f255, 0x7e7e82fc, 0x3d3d477a, 0x6464acc8, 0x5d5de7ba, 0x19192b32, 0x737395e6, 0x6060a0c0, 0x81819819, 0x4f4fd19e, 0xdcdc7fa3, 0x22226644, 0x2a2a7e54, 0x9090ab3b, 0x8888830b, 0x4646ca8c, 0xeeee29c7, 0xb8b8d36b, 0x14143c28, 0xdede79a7, 0x5e5ee2bc, 0x0b0b1d16, 0xdbdb76ad, 0xe0e03bdb, 0x32325664, 0x3a3a4e74, 0x0a0a1e14, 0x4949db92, 0x06060a0c, 0x24246c48, 0x5c5ce4b8, 0xc2c25d9f, 0xd3d36ebd, 0xacacef43, 0x6262a6c4, 0x9191a839, 0x9595a431, 0xe4e437d3, 0x79798bf2, 0xe7e732d5, 0xc8c8438b, 0x3737596e, 0x6d6db7da, 0x8d8d8c01, 0xd5d564b1, 0x4e4ed29c, 0xa9a9e049, 0x6c6cb4d8, 0x5656faac, 0xf4f407f3, 0xeaea25cf, 0x6565afca, 0x7a7a8ef4, 0xaeaee947, 0x08081810, 0xbabad56f, 0x787888f0, 0x25256f4a, 0x2e2e725c, 0x1c1c2438, 0xa6a6f157, 0xb4b4c773, 0xc6c65197, 0xe8e823cb, 0xdddd7ca1, 0x74749ce8, 0x1f1f213e, 0x4b4bdd96, 0xbdbddc61, 0x8b8b860d, 0x8a8a850f, 0x707090e0, 0x3e3e427c, 0xb5b5c471, 0x6666aacc, 0x4848d890, 0x03030506, 0xf6f601f7, 0x0e0e121c, 0x6161a3c2, 0x35355f6a, 0x5757f9ae, 0xb9b9d069, 0x86869117, 0xc1c15899, 0x1d1d273a, 0x9e9eb927, 0xe1e138d9, 0xf8f813eb, 0x9898b32b, 0x11113322, 0x6969bbd2, 0xd9d970a9, 0x8e8e8907, 0x9494a733, 0x9b9bb62d, 0x1e1e223c, 0x87879215, 0xe9e920c9, 0xcece4987, 0x5555ffaa, 0x28287850, 0xdfdf7aa5, 0x8c8c8f03, 0xa1a1f859, 0x89898009, 0x0d0d171a, 0xbfbfda65, 0xe6e631d7, 0x4242c684, 0x6868b8d0, 0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e, 0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c];
|
||
|
||
// Transformations for decryption
|
||
var T5 = [0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742];
|
||
var T6 = [0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0xe7038f5f, 0x9515929c, 0xebbf6d7a, 0xda955259, 0x2dd4be83, 0xd3587421, 0x2949e069, 0x448ec9c8, 0x6a75c289, 0x78f48e79, 0x6b99583e, 0xdd27b971, 0xb6bee14f, 0x17f088ad, 0x66c920ac, 0xb47dce3a, 0x1863df4a, 0x82e51a31, 0x60975133, 0x4562537f, 0xe0b16477, 0x84bb6bae, 0x1cfe81a0, 0x94f9082b, 0x58704868, 0x198f45fd, 0x8794de6c, 0xb7527bf8, 0x23ab73d3, 0xe2724b02, 0x57e31f8f, 0x2a6655ab, 0x07b2eb28, 0x032fb5c2, 0x9a86c57b, 0xa5d33708, 0xf2302887, 0xb223bfa5, 0xba02036a, 0x5ced1682, 0x2b8acf1c, 0x92a779b4, 0xf0f307f2, 0xa14e69e2, 0xcd65daf4, 0xd50605be, 0x1fd13462, 0x8ac4a6fe, 0x9d342e53, 0xa0a2f355, 0x32058ae1, 0x75a4f6eb, 0x390b83ec, 0xaa4060ef, 0x065e719f, 0x51bd6e10, 0xf93e218a, 0x3d96dd06, 0xaedd3e05, 0x464de6bd, 0xb591548d, 0x0571c45d, 0x6f0406d4, 0xff605015, 0x241998fb, 0x97d6bde9, 0xcc894043, 0x7767d99e, 0xbdb0e842, 0x8807898b, 0x38e7195b, 0xdb79c8ee, 0x47a17c0a, 0xe97c420f, 0xc9f8841e, 0x00000000, 0x83098086, 0x48322bed, 0xac1e1170, 0x4e6c5a72, 0xfbfd0eff, 0x560f8538, 0x1e3daed5, 0x27362d39, 0x640a0fd9, 0x21685ca6, 0xd19b5b54, 0x3a24362e, 0xb10c0a67, 0x0f9357e7, 0xd2b4ee96, 0x9e1b9b91, 0x4f80c0c5, 0xa261dc20, 0x695a774b, 0x161c121a, 0x0ae293ba, 0xe5c0a02a, 0x433c22e0, 0x1d121b17, 0x0b0e090d, 0xadf28bc7, 0xb92db6a8, 0xc8141ea9, 0x8557f119, 0x4caf7507, 0xbbee99dd, 0xfda37f60, 0x9ff70126, 0xbc5c72f5, 0xc544663b, 0x345bfb7e, 0x768b4329, 0xdccb23c6, 0x68b6edfc, 0x63b8e4f1, 0xcad731dc, 0x10426385, 0x40139722, 0x2084c611, 0x7d854a24, 0xf8d2bb3d, 0x11aef932, 0x6dc729a1, 0x4b1d9e2f, 0xf3dcb230, 0xec0d8652, 0xd077c1e3, 0x6c2bb316, 0x99a970b9, 0xfa119448, 0x2247e964, 0xc4a8fc8c, 0x1aa0f03f, 0xd8567d2c, 0xef223390, 0xc787494e, 0xc1d938d1, 0xfe8ccaa2, 0x3698d40b, 0xcfa6f581, 0x28a57ade, 0x26dab78e, 0xa43fadbf, 0xe42c3a9d, 0x0d507892, 0x9b6a5fcc, 0x62547e46, 0xc2f68d13, 0xe890d8b8, 0x5e2e39f7, 0xf582c3af, 0xbe9f5d80, 0x7c69d093, 0xa96fd52d, 0xb3cf2512, 0x3bc8ac99, 0xa710187d, 0x6ee89c63, 0x7bdb3bbb, 0x09cd2678, 0xf46e5918, 0x01ec9ab7, 0xa8834f9a, 0x65e6956e, 0x7eaaffe6, 0x0821bccf, 0xe6ef15e8, 0xd9bae79b, 0xce4a6f36, 0xd4ea9f09, 0xd629b07c, 0xaf31a4b2, 0x312a3f23, 0x30c6a594, 0xc035a266, 0x37744ebc, 0xa6fc82ca, 0xb0e090d0, 0x1533a7d8, 0x4af10498, 0xf741ecda, 0x0e7fcd50, 0x2f1791f6, 0x8d764dd6, 0x4d43efb0, 0x54ccaa4d, 0xdfe49604, 0xe39ed1b5, 0x1b4c6a88, 0xb8c12c1f, 0x7f466551, 0x049d5eea, 0x5d018c35, 0x73fa8774, 0x2efb0b41, 0x5ab3671d, 0x5292dbd2, 0x33e91056, 0x136dd647, 0x8c9ad761, 0x7a37a10c, 0x8e59f814, 0x89eb133c, 0xeecea927, 0x35b761c9, 0xede11ce5, 0x3c7a47b1, 0x599cd2df, 0x3f55f273, 0x791814ce, 0xbf73c737, 0xea53f7cd, 0x5b5ffdaa, 0x14df3d6f, 0x867844db, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857];
|
||
var T7 = [0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5fe7038f, 0x9c951592, 0x7aebbf6d, 0x59da9552, 0x832dd4be, 0x21d35874, 0x692949e0, 0xc8448ec9, 0x896a75c2, 0x7978f48e, 0x3e6b9958, 0x71dd27b9, 0x4fb6bee1, 0xad17f088, 0xac66c920, 0x3ab47dce, 0x4a1863df, 0x3182e51a, 0x33609751, 0x7f456253, 0x77e0b164, 0xae84bb6b, 0xa01cfe81, 0x2b94f908, 0x68587048, 0xfd198f45, 0x6c8794de, 0xf8b7527b, 0xd323ab73, 0x02e2724b, 0x8f57e31f, 0xab2a6655, 0x2807b2eb, 0xc2032fb5, 0x7b9a86c5, 0x08a5d337, 0x87f23028, 0xa5b223bf, 0x6aba0203, 0x825ced16, 0x1c2b8acf, 0xb492a779, 0xf2f0f307, 0xe2a14e69, 0xf4cd65da, 0xbed50605, 0x621fd134, 0xfe8ac4a6, 0x539d342e, 0x55a0a2f3, 0xe132058a, 0xeb75a4f6, 0xec390b83, 0xefaa4060, 0x9f065e71, 0x1051bd6e, 0x8af93e21, 0x063d96dd, 0x05aedd3e, 0xbd464de6, 0x8db59154, 0x5d0571c4, 0xd46f0406, 0x15ff6050, 0xfb241998, 0xe997d6bd, 0x43cc8940, 0x9e7767d9, 0x42bdb0e8, 0x8b880789, 0x5b38e719, 0xeedb79c8, 0x0a47a17c, 0x0fe97c42, 0x1ec9f884, 0x00000000, 0x86830980, 0xed48322b, 0x70ac1e11, 0x724e6c5a, 0xfffbfd0e, 0x38560f85, 0xd51e3dae, 0x3927362d, 0xd9640a0f, 0xa621685c, 0x54d19b5b, 0x2e3a2436, 0x67b10c0a, 0xe70f9357, 0x96d2b4ee, 0x919e1b9b, 0xc54f80c0, 0x20a261dc, 0x4b695a77, 0x1a161c12, 0xba0ae293, 0x2ae5c0a0, 0xe0433c22, 0x171d121b, 0x0d0b0e09, 0xc7adf28b, 0xa8b92db6, 0xa9c8141e, 0x198557f1, 0x074caf75, 0xddbbee99, 0x60fda37f, 0x269ff701, 0xf5bc5c72, 0x3bc54466, 0x7e345bfb, 0x29768b43, 0xc6dccb23, 0xfc68b6ed, 0xf163b8e4, 0xdccad731, 0x85104263, 0x22401397, 0x112084c6, 0x247d854a, 0x3df8d2bb, 0x3211aef9, 0xa16dc729, 0x2f4b1d9e, 0x30f3dcb2, 0x52ec0d86, 0xe3d077c1, 0x166c2bb3, 0xb999a970, 0x48fa1194, 0x642247e9, 0x8cc4a8fc, 0x3f1aa0f0, 0x2cd8567d, 0x90ef2233, 0x4ec78749, 0xd1c1d938, 0xa2fe8cca, 0x0b3698d4, 0x81cfa6f5, 0xde28a57a, 0x8e26dab7, 0xbfa43fad, 0x9de42c3a, 0x920d5078, 0xcc9b6a5f, 0x4662547e, 0x13c2f68d, 0xb8e890d8, 0xf75e2e39, 0xaff582c3, 0x80be9f5d, 0x937c69d0, 0x2da96fd5, 0x12b3cf25, 0x993bc8ac, 0x7da71018, 0x636ee89c, 0xbb7bdb3b, 0x7809cd26, 0x18f46e59, 0xb701ec9a, 0x9aa8834f, 0x6e65e695, 0xe67eaaff, 0xcf0821bc, 0xe8e6ef15, 0x9bd9bae7, 0x36ce4a6f, 0x09d4ea9f, 0x7cd629b0, 0xb2af31a4, 0x23312a3f, 0x9430c6a5, 0x66c035a2, 0xbc37744e, 0xcaa6fc82, 0xd0b0e090, 0xd81533a7, 0x984af104, 0xdaf741ec, 0x500e7fcd, 0xf62f1791, 0xd68d764d, 0xb04d43ef, 0x4d54ccaa, 0x04dfe496, 0xb5e39ed1, 0x881b4c6a, 0x1fb8c12c, 0x517f4665, 0xea049d5e, 0x355d018c, 0x7473fa87, 0x412efb0b, 0x1d5ab367, 0xd25292db, 0x5633e910, 0x47136dd6, 0x618c9ad7, 0x0c7a37a1, 0x148e59f8, 0x3c89eb13, 0x27eecea9, 0xc935b761, 0xe5ede11c, 0xb13c7a47, 0xdf599cd2, 0x733f55f2, 0xce791814, 0x37bf73c7, 0xcdea53f7, 0xaa5b5ffd, 0x6f14df3d, 0xdb867844, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8];
|
||
var T8 = [0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0x8f5fe703, 0x929c9515, 0x6d7aebbf, 0x5259da95, 0xbe832dd4, 0x7421d358, 0xe0692949, 0xc9c8448e, 0xc2896a75, 0x8e7978f4, 0x583e6b99, 0xb971dd27, 0xe14fb6be, 0x88ad17f0, 0x20ac66c9, 0xce3ab47d, 0xdf4a1863, 0x1a3182e5, 0x51336097, 0x537f4562, 0x6477e0b1, 0x6bae84bb, 0x81a01cfe, 0x082b94f9, 0x48685870, 0x45fd198f, 0xde6c8794, 0x7bf8b752, 0x73d323ab, 0x4b02e272, 0x1f8f57e3, 0x55ab2a66, 0xeb2807b2, 0xb5c2032f, 0xc57b9a86, 0x3708a5d3, 0x2887f230, 0xbfa5b223, 0x036aba02, 0x16825ced, 0xcf1c2b8a, 0x79b492a7, 0x07f2f0f3, 0x69e2a14e, 0xdaf4cd65, 0x05bed506, 0x34621fd1, 0xa6fe8ac4, 0x2e539d34, 0xf355a0a2, 0x8ae13205, 0xf6eb75a4, 0x83ec390b, 0x60efaa40, 0x719f065e, 0x6e1051bd, 0x218af93e, 0xdd063d96, 0x3e05aedd, 0xe6bd464d, 0x548db591, 0xc45d0571, 0x06d46f04, 0x5015ff60, 0x98fb2419, 0xbde997d6, 0x4043cc89, 0xd99e7767, 0xe842bdb0, 0x898b8807, 0x195b38e7, 0xc8eedb79, 0x7c0a47a1, 0x420fe97c, 0x841ec9f8, 0x00000000, 0x80868309, 0x2bed4832, 0x1170ac1e, 0x5a724e6c, 0x0efffbfd, 0x8538560f, 0xaed51e3d, 0x2d392736, 0x0fd9640a, 0x5ca62168, 0x5b54d19b, 0x362e3a24, 0x0a67b10c, 0x57e70f93, 0xee96d2b4, 0x9b919e1b, 0xc0c54f80, 0xdc20a261, 0x774b695a, 0x121a161c, 0x93ba0ae2, 0xa02ae5c0, 0x22e0433c, 0x1b171d12, 0x090d0b0e, 0x8bc7adf2, 0xb6a8b92d, 0x1ea9c814, 0xf1198557, 0x75074caf, 0x99ddbbee, 0x7f60fda3, 0x01269ff7, 0x72f5bc5c, 0x663bc544, 0xfb7e345b, 0x4329768b, 0x23c6dccb, 0xedfc68b6, 0xe4f163b8, 0x31dccad7, 0x63851042, 0x97224013, 0xc6112084, 0x4a247d85, 0xbb3df8d2, 0xf93211ae, 0x29a16dc7, 0x9e2f4b1d, 0xb230f3dc, 0x8652ec0d, 0xc1e3d077, 0xb3166c2b, 0x70b999a9, 0x9448fa11, 0xe9642247, 0xfc8cc4a8, 0xf03f1aa0, 0x7d2cd856, 0x3390ef22, 0x494ec787, 0x38d1c1d9, 0xcaa2fe8c, 0xd40b3698, 0xf581cfa6, 0x7ade28a5, 0xb78e26da, 0xadbfa43f, 0x3a9de42c, 0x78920d50, 0x5fcc9b6a, 0x7e466254, 0x8d13c2f6, 0xd8b8e890, 0x39f75e2e, 0xc3aff582, 0x5d80be9f, 0xd0937c69, 0xd52da96f, 0x2512b3cf, 0xac993bc8, 0x187da710, 0x9c636ee8, 0x3bbb7bdb, 0x267809cd, 0x5918f46e, 0x9ab701ec, 0x4f9aa883, 0x956e65e6, 0xffe67eaa, 0xbccf0821, 0x15e8e6ef, 0xe79bd9ba, 0x6f36ce4a, 0x9f09d4ea, 0xb07cd629, 0xa4b2af31, 0x3f23312a, 0xa59430c6, 0xa266c035, 0x4ebc3774, 0x82caa6fc, 0x90d0b0e0, 0xa7d81533, 0x04984af1, 0xecdaf741, 0xcd500e7f, 0x91f62f17, 0x4dd68d76, 0xefb04d43, 0xaa4d54cc, 0x9604dfe4, 0xd1b5e39e, 0x6a881b4c, 0x2c1fb8c1, 0x65517f46, 0x5eea049d, 0x8c355d01, 0x877473fa, 0x0b412efb, 0x671d5ab3, 0xdbd25292, 0x105633e9, 0xd647136d, 0xd7618c9a, 0xa10c7a37, 0xf8148e59, 0x133c89eb, 0xa927eece, 0x61c935b7, 0x1ce5ede1, 0x47b13c7a, 0xd2df599c, 0xf2733f55, 0x14ce7918, 0xc737bf73, 0xf7cdea53, 0xfdaa5b5f, 0x3d6f14df, 0x44db8678, 0xaff381ca, 0x68c43eb9, 0x24342c38, 0xa3405fc2, 0x1dc37216, 0xe2250cbc, 0x3c498b28, 0x0d9541ff, 0xa8017139, 0x0cb3de08, 0xb4e49cd8, 0x56c19064, 0xcb84617b, 0x32b670d5, 0x6c5c7448, 0xb85742d0];
|
||
|
||
// Transformations for decryption key expansion
|
||
var U1 = [0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3];
|
||
var U2 = [0x00000000, 0x0b0e090d, 0x161c121a, 0x1d121b17, 0x2c382434, 0x27362d39, 0x3a24362e, 0x312a3f23, 0x58704868, 0x537e4165, 0x4e6c5a72, 0x4562537f, 0x74486c5c, 0x7f466551, 0x62547e46, 0x695a774b, 0xb0e090d0, 0xbbee99dd, 0xa6fc82ca, 0xadf28bc7, 0x9cd8b4e4, 0x97d6bde9, 0x8ac4a6fe, 0x81caaff3, 0xe890d8b8, 0xe39ed1b5, 0xfe8ccaa2, 0xf582c3af, 0xc4a8fc8c, 0xcfa6f581, 0xd2b4ee96, 0xd9bae79b, 0x7bdb3bbb, 0x70d532b6, 0x6dc729a1, 0x66c920ac, 0x57e31f8f, 0x5ced1682, 0x41ff0d95, 0x4af10498, 0x23ab73d3, 0x28a57ade, 0x35b761c9, 0x3eb968c4, 0x0f9357e7, 0x049d5eea, 0x198f45fd, 0x12814cf0, 0xcb3bab6b, 0xc035a266, 0xdd27b971, 0xd629b07c, 0xe7038f5f, 0xec0d8652, 0xf11f9d45, 0xfa119448, 0x934be303, 0x9845ea0e, 0x8557f119, 0x8e59f814, 0xbf73c737, 0xb47dce3a, 0xa96fd52d, 0xa261dc20, 0xf6ad766d, 0xfda37f60, 0xe0b16477, 0xebbf6d7a, 0xda955259, 0xd19b5b54, 0xcc894043, 0xc787494e, 0xaedd3e05, 0xa5d33708, 0xb8c12c1f, 0xb3cf2512, 0x82e51a31, 0x89eb133c, 0x94f9082b, 0x9ff70126, 0x464de6bd, 0x4d43efb0, 0x5051f4a7, 0x5b5ffdaa, 0x6a75c289, 0x617bcb84, 0x7c69d093, 0x7767d99e, 0x1e3daed5, 0x1533a7d8, 0x0821bccf, 0x032fb5c2, 0x32058ae1, 0x390b83ec, 0x241998fb, 0x2f1791f6, 0x8d764dd6, 0x867844db, 0x9b6a5fcc, 0x906456c1, 0xa14e69e2, 0xaa4060ef, 0xb7527bf8, 0xbc5c72f5, 0xd50605be, 0xde080cb3, 0xc31a17a4, 0xc8141ea9, 0xf93e218a, 0xf2302887, 0xef223390, 0xe42c3a9d, 0x3d96dd06, 0x3698d40b, 0x2b8acf1c, 0x2084c611, 0x11aef932, 0x1aa0f03f, 0x07b2eb28, 0x0cbce225, 0x65e6956e, 0x6ee89c63, 0x73fa8774, 0x78f48e79, 0x49deb15a, 0x42d0b857, 0x5fc2a340, 0x54ccaa4d, 0xf741ecda, 0xfc4fe5d7, 0xe15dfec0, 0xea53f7cd, 0xdb79c8ee, 0xd077c1e3, 0xcd65daf4, 0xc66bd3f9, 0xaf31a4b2, 0xa43fadbf, 0xb92db6a8, 0xb223bfa5, 0x83098086, 0x8807898b, 0x9515929c, 0x9e1b9b91, 0x47a17c0a, 0x4caf7507, 0x51bd6e10, 0x5ab3671d, 0x6b99583e, 0x60975133, 0x7d854a24, 0x768b4329, 0x1fd13462, 0x14df3d6f, 0x09cd2678, 0x02c32f75, 0x33e91056, 0x38e7195b, 0x25f5024c, 0x2efb0b41, 0x8c9ad761, 0x8794de6c, 0x9a86c57b, 0x9188cc76, 0xa0a2f355, 0xabacfa58, 0xb6bee14f, 0xbdb0e842, 0xd4ea9f09, 0xdfe49604, 0xc2f68d13, 0xc9f8841e, 0xf8d2bb3d, 0xf3dcb230, 0xeecea927, 0xe5c0a02a, 0x3c7a47b1, 0x37744ebc, 0x2a6655ab, 0x21685ca6, 0x10426385, 0x1b4c6a88, 0x065e719f, 0x0d507892, 0x640a0fd9, 0x6f0406d4, 0x72161dc3, 0x791814ce, 0x48322bed, 0x433c22e0, 0x5e2e39f7, 0x552030fa, 0x01ec9ab7, 0x0ae293ba, 0x17f088ad, 0x1cfe81a0, 0x2dd4be83, 0x26dab78e, 0x3bc8ac99, 0x30c6a594, 0x599cd2df, 0x5292dbd2, 0x4f80c0c5, 0x448ec9c8, 0x75a4f6eb, 0x7eaaffe6, 0x63b8e4f1, 0x68b6edfc, 0xb10c0a67, 0xba02036a, 0xa710187d, 0xac1e1170, 0x9d342e53, 0x963a275e, 0x8b283c49, 0x80263544, 0xe97c420f, 0xe2724b02, 0xff605015, 0xf46e5918, 0xc544663b, 0xce4a6f36, 0xd3587421, 0xd8567d2c, 0x7a37a10c, 0x7139a801, 0x6c2bb316, 0x6725ba1b, 0x560f8538, 0x5d018c35, 0x40139722, 0x4b1d9e2f, 0x2247e964, 0x2949e069, 0x345bfb7e, 0x3f55f273, 0x0e7fcd50, 0x0571c45d, 0x1863df4a, 0x136dd647, 0xcad731dc, 0xc1d938d1, 0xdccb23c6, 0xd7c52acb, 0xe6ef15e8, 0xede11ce5, 0xf0f307f2, 0xfbfd0eff, 0x92a779b4, 0x99a970b9, 0x84bb6bae, 0x8fb562a3, 0xbe9f5d80, 0xb591548d, 0xa8834f9a, 0xa38d4697];
|
||
var U3 = [0x00000000, 0x0d0b0e09, 0x1a161c12, 0x171d121b, 0x342c3824, 0x3927362d, 0x2e3a2436, 0x23312a3f, 0x68587048, 0x65537e41, 0x724e6c5a, 0x7f456253, 0x5c74486c, 0x517f4665, 0x4662547e, 0x4b695a77, 0xd0b0e090, 0xddbbee99, 0xcaa6fc82, 0xc7adf28b, 0xe49cd8b4, 0xe997d6bd, 0xfe8ac4a6, 0xf381caaf, 0xb8e890d8, 0xb5e39ed1, 0xa2fe8cca, 0xaff582c3, 0x8cc4a8fc, 0x81cfa6f5, 0x96d2b4ee, 0x9bd9bae7, 0xbb7bdb3b, 0xb670d532, 0xa16dc729, 0xac66c920, 0x8f57e31f, 0x825ced16, 0x9541ff0d, 0x984af104, 0xd323ab73, 0xde28a57a, 0xc935b761, 0xc43eb968, 0xe70f9357, 0xea049d5e, 0xfd198f45, 0xf012814c, 0x6bcb3bab, 0x66c035a2, 0x71dd27b9, 0x7cd629b0, 0x5fe7038f, 0x52ec0d86, 0x45f11f9d, 0x48fa1194, 0x03934be3, 0x0e9845ea, 0x198557f1, 0x148e59f8, 0x37bf73c7, 0x3ab47dce, 0x2da96fd5, 0x20a261dc, 0x6df6ad76, 0x60fda37f, 0x77e0b164, 0x7aebbf6d, 0x59da9552, 0x54d19b5b, 0x43cc8940, 0x4ec78749, 0x05aedd3e, 0x08a5d337, 0x1fb8c12c, 0x12b3cf25, 0x3182e51a, 0x3c89eb13, 0x2b94f908, 0x269ff701, 0xbd464de6, 0xb04d43ef, 0xa75051f4, 0xaa5b5ffd, 0x896a75c2, 0x84617bcb, 0x937c69d0, 0x9e7767d9, 0xd51e3dae, 0xd81533a7, 0xcf0821bc, 0xc2032fb5, 0xe132058a, 0xec390b83, 0xfb241998, 0xf62f1791, 0xd68d764d, 0xdb867844, 0xcc9b6a5f, 0xc1906456, 0xe2a14e69, 0xefaa4060, 0xf8b7527b, 0xf5bc5c72, 0xbed50605, 0xb3de080c, 0xa4c31a17, 0xa9c8141e, 0x8af93e21, 0x87f23028, 0x90ef2233, 0x9de42c3a, 0x063d96dd, 0x0b3698d4, 0x1c2b8acf, 0x112084c6, 0x3211aef9, 0x3f1aa0f0, 0x2807b2eb, 0x250cbce2, 0x6e65e695, 0x636ee89c, 0x7473fa87, 0x7978f48e, 0x5a49deb1, 0x5742d0b8, 0x405fc2a3, 0x4d54ccaa, 0xdaf741ec, 0xd7fc4fe5, 0xc0e15dfe, 0xcdea53f7, 0xeedb79c8, 0xe3d077c1, 0xf4cd65da, 0xf9c66bd3, 0xb2af31a4, 0xbfa43fad, 0xa8b92db6, 0xa5b223bf, 0x86830980, 0x8b880789, 0x9c951592, 0x919e1b9b, 0x0a47a17c, 0x074caf75, 0x1051bd6e, 0x1d5ab367, 0x3e6b9958, 0x33609751, 0x247d854a, 0x29768b43, 0x621fd134, 0x6f14df3d, 0x7809cd26, 0x7502c32f, 0x5633e910, 0x5b38e719, 0x4c25f502, 0x412efb0b, 0x618c9ad7, 0x6c8794de, 0x7b9a86c5, 0x769188cc, 0x55a0a2f3, 0x58abacfa, 0x4fb6bee1, 0x42bdb0e8, 0x09d4ea9f, 0x04dfe496, 0x13c2f68d, 0x1ec9f884, 0x3df8d2bb, 0x30f3dcb2, 0x27eecea9, 0x2ae5c0a0, 0xb13c7a47, 0xbc37744e, 0xab2a6655, 0xa621685c, 0x85104263, 0x881b4c6a, 0x9f065e71, 0x920d5078, 0xd9640a0f, 0xd46f0406, 0xc372161d, 0xce791814, 0xed48322b, 0xe0433c22, 0xf75e2e39, 0xfa552030, 0xb701ec9a, 0xba0ae293, 0xad17f088, 0xa01cfe81, 0x832dd4be, 0x8e26dab7, 0x993bc8ac, 0x9430c6a5, 0xdf599cd2, 0xd25292db, 0xc54f80c0, 0xc8448ec9, 0xeb75a4f6, 0xe67eaaff, 0xf163b8e4, 0xfc68b6ed, 0x67b10c0a, 0x6aba0203, 0x7da71018, 0x70ac1e11, 0x539d342e, 0x5e963a27, 0x498b283c, 0x44802635, 0x0fe97c42, 0x02e2724b, 0x15ff6050, 0x18f46e59, 0x3bc54466, 0x36ce4a6f, 0x21d35874, 0x2cd8567d, 0x0c7a37a1, 0x017139a8, 0x166c2bb3, 0x1b6725ba, 0x38560f85, 0x355d018c, 0x22401397, 0x2f4b1d9e, 0x642247e9, 0x692949e0, 0x7e345bfb, 0x733f55f2, 0x500e7fcd, 0x5d0571c4, 0x4a1863df, 0x47136dd6, 0xdccad731, 0xd1c1d938, 0xc6dccb23, 0xcbd7c52a, 0xe8e6ef15, 0xe5ede11c, 0xf2f0f307, 0xfffbfd0e, 0xb492a779, 0xb999a970, 0xae84bb6b, 0xa38fb562, 0x80be9f5d, 0x8db59154, 0x9aa8834f, 0x97a38d46];
|
||
var U4 = [0x00000000, 0x090d0b0e, 0x121a161c, 0x1b171d12, 0x24342c38, 0x2d392736, 0x362e3a24, 0x3f23312a, 0x48685870, 0x4165537e, 0x5a724e6c, 0x537f4562, 0x6c5c7448, 0x65517f46, 0x7e466254, 0x774b695a, 0x90d0b0e0, 0x99ddbbee, 0x82caa6fc, 0x8bc7adf2, 0xb4e49cd8, 0xbde997d6, 0xa6fe8ac4, 0xaff381ca, 0xd8b8e890, 0xd1b5e39e, 0xcaa2fe8c, 0xc3aff582, 0xfc8cc4a8, 0xf581cfa6, 0xee96d2b4, 0xe79bd9ba, 0x3bbb7bdb, 0x32b670d5, 0x29a16dc7, 0x20ac66c9, 0x1f8f57e3, 0x16825ced, 0x0d9541ff, 0x04984af1, 0x73d323ab, 0x7ade28a5, 0x61c935b7, 0x68c43eb9, 0x57e70f93, 0x5eea049d, 0x45fd198f, 0x4cf01281, 0xab6bcb3b, 0xa266c035, 0xb971dd27, 0xb07cd629, 0x8f5fe703, 0x8652ec0d, 0x9d45f11f, 0x9448fa11, 0xe303934b, 0xea0e9845, 0xf1198557, 0xf8148e59, 0xc737bf73, 0xce3ab47d, 0xd52da96f, 0xdc20a261, 0x766df6ad, 0x7f60fda3, 0x6477e0b1, 0x6d7aebbf, 0x5259da95, 0x5b54d19b, 0x4043cc89, 0x494ec787, 0x3e05aedd, 0x3708a5d3, 0x2c1fb8c1, 0x2512b3cf, 0x1a3182e5, 0x133c89eb, 0x082b94f9, 0x01269ff7, 0xe6bd464d, 0xefb04d43, 0xf4a75051, 0xfdaa5b5f, 0xc2896a75, 0xcb84617b, 0xd0937c69, 0xd99e7767, 0xaed51e3d, 0xa7d81533, 0xbccf0821, 0xb5c2032f, 0x8ae13205, 0x83ec390b, 0x98fb2419, 0x91f62f17, 0x4dd68d76, 0x44db8678, 0x5fcc9b6a, 0x56c19064, 0x69e2a14e, 0x60efaa40, 0x7bf8b752, 0x72f5bc5c, 0x05bed506, 0x0cb3de08, 0x17a4c31a, 0x1ea9c814, 0x218af93e, 0x2887f230, 0x3390ef22, 0x3a9de42c, 0xdd063d96, 0xd40b3698, 0xcf1c2b8a, 0xc6112084, 0xf93211ae, 0xf03f1aa0, 0xeb2807b2, 0xe2250cbc, 0x956e65e6, 0x9c636ee8, 0x877473fa, 0x8e7978f4, 0xb15a49de, 0xb85742d0, 0xa3405fc2, 0xaa4d54cc, 0xecdaf741, 0xe5d7fc4f, 0xfec0e15d, 0xf7cdea53, 0xc8eedb79, 0xc1e3d077, 0xdaf4cd65, 0xd3f9c66b, 0xa4b2af31, 0xadbfa43f, 0xb6a8b92d, 0xbfa5b223, 0x80868309, 0x898b8807, 0x929c9515, 0x9b919e1b, 0x7c0a47a1, 0x75074caf, 0x6e1051bd, 0x671d5ab3, 0x583e6b99, 0x51336097, 0x4a247d85, 0x4329768b, 0x34621fd1, 0x3d6f14df, 0x267809cd, 0x2f7502c3, 0x105633e9, 0x195b38e7, 0x024c25f5, 0x0b412efb, 0xd7618c9a, 0xde6c8794, 0xc57b9a86, 0xcc769188, 0xf355a0a2, 0xfa58abac, 0xe14fb6be, 0xe842bdb0, 0x9f09d4ea, 0x9604dfe4, 0x8d13c2f6, 0x841ec9f8, 0xbb3df8d2, 0xb230f3dc, 0xa927eece, 0xa02ae5c0, 0x47b13c7a, 0x4ebc3774, 0x55ab2a66, 0x5ca62168, 0x63851042, 0x6a881b4c, 0x719f065e, 0x78920d50, 0x0fd9640a, 0x06d46f04, 0x1dc37216, 0x14ce7918, 0x2bed4832, 0x22e0433c, 0x39f75e2e, 0x30fa5520, 0x9ab701ec, 0x93ba0ae2, 0x88ad17f0, 0x81a01cfe, 0xbe832dd4, 0xb78e26da, 0xac993bc8, 0xa59430c6, 0xd2df599c, 0xdbd25292, 0xc0c54f80, 0xc9c8448e, 0xf6eb75a4, 0xffe67eaa, 0xe4f163b8, 0xedfc68b6, 0x0a67b10c, 0x036aba02, 0x187da710, 0x1170ac1e, 0x2e539d34, 0x275e963a, 0x3c498b28, 0x35448026, 0x420fe97c, 0x4b02e272, 0x5015ff60, 0x5918f46e, 0x663bc544, 0x6f36ce4a, 0x7421d358, 0x7d2cd856, 0xa10c7a37, 0xa8017139, 0xb3166c2b, 0xba1b6725, 0x8538560f, 0x8c355d01, 0x97224013, 0x9e2f4b1d, 0xe9642247, 0xe0692949, 0xfb7e345b, 0xf2733f55, 0xcd500e7f, 0xc45d0571, 0xdf4a1863, 0xd647136d, 0x31dccad7, 0x38d1c1d9, 0x23c6dccb, 0x2acbd7c5, 0x15e8e6ef, 0x1ce5ede1, 0x07f2f0f3, 0x0efffbfd, 0x79b492a7, 0x70b999a9, 0x6bae84bb, 0x62a38fb5, 0x5d80be9f, 0x548db591, 0x4f9aa883, 0x4697a38d];
|
||
function convertToInt32(bytes) {
|
||
var result = [];
|
||
for (var i = 0; i < bytes.length; i += 4) {
|
||
result.push(bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]);
|
||
}
|
||
return result;
|
||
}
|
||
var AesJs = function (key) {
|
||
if (!(this instanceof AesJs)) {
|
||
throw Error('AES must be instanitated with `new`');
|
||
}
|
||
Object.defineProperty(this, 'key', {
|
||
value: coerceArray(key, true)
|
||
});
|
||
this._prepare();
|
||
};
|
||
AesJs.prototype._prepare = function () {
|
||
var rounds = numberOfRounds[this.key.length];
|
||
if (rounds == null) {
|
||
throw new Error('invalid key size (must be 16, 24 or 32 bytes)');
|
||
}
|
||
|
||
// encryption round keys
|
||
this._Ke = [];
|
||
|
||
// decryption round keys
|
||
this._Kd = [];
|
||
for (var i = 0; i <= rounds; i++) {
|
||
this._Ke.push([0, 0, 0, 0]);
|
||
this._Kd.push([0, 0, 0, 0]);
|
||
}
|
||
var roundKeyCount = (rounds + 1) * 4;
|
||
var KC = this.key.length / 4;
|
||
|
||
// convert the key into ints
|
||
var tk = convertToInt32(this.key);
|
||
|
||
// copy values into round key arrays
|
||
var index;
|
||
for (var i = 0; i < KC; i++) {
|
||
index = i >> 2;
|
||
this._Ke[index][i % 4] = tk[i];
|
||
this._Kd[rounds - index][i % 4] = tk[i];
|
||
}
|
||
|
||
// key expansion (fips-197 section 5.2)
|
||
var rconpointer = 0;
|
||
var t = KC,
|
||
tt;
|
||
while (t < roundKeyCount) {
|
||
tt = tk[KC - 1];
|
||
tk[0] ^= S[tt >> 16 & 0xFF] << 24 ^ S[tt >> 8 & 0xFF] << 16 ^ S[tt & 0xFF] << 8 ^ S[tt >> 24 & 0xFF] ^ rcon[rconpointer] << 24;
|
||
rconpointer += 1;
|
||
|
||
// key expansion (for non-256 bit)
|
||
if (KC != 8) {
|
||
for (var i = 1; i < KC; i++) {
|
||
tk[i] ^= tk[i - 1];
|
||
}
|
||
|
||
// key expansion for 256-bit keys is "slightly different" (fips-197)
|
||
} else {
|
||
for (var i = 1; i < KC / 2; i++) {
|
||
tk[i] ^= tk[i - 1];
|
||
}
|
||
tt = tk[KC / 2 - 1];
|
||
tk[KC / 2] ^= S[tt & 0xFF] ^ S[tt >> 8 & 0xFF] << 8 ^ S[tt >> 16 & 0xFF] << 16 ^ S[tt >> 24 & 0xFF] << 24;
|
||
for (var i = KC / 2 + 1; i < KC; i++) {
|
||
tk[i] ^= tk[i - 1];
|
||
}
|
||
}
|
||
|
||
// copy values into round key arrays
|
||
var i = 0,
|
||
r,
|
||
c;
|
||
while (i < KC && t < roundKeyCount) {
|
||
r = t >> 2;
|
||
c = t % 4;
|
||
this._Ke[r][c] = tk[i];
|
||
this._Kd[rounds - r][c] = tk[i++];
|
||
t++;
|
||
}
|
||
}
|
||
|
||
// inverse-cipher-ify the decryption round key (fips-197 section 5.3)
|
||
for (var r = 1; r < rounds; r++) {
|
||
for (var c = 0; c < 4; c++) {
|
||
tt = this._Kd[r][c];
|
||
this._Kd[r][c] = U1[tt >> 24 & 0xFF] ^ U2[tt >> 16 & 0xFF] ^ U3[tt >> 8 & 0xFF] ^ U4[tt & 0xFF];
|
||
}
|
||
}
|
||
};
|
||
AesJs.prototype.encrypt = function (plaintext) {
|
||
if (plaintext.length != 16) {
|
||
throw new Error('invalid plaintext size (must be 16 bytes)');
|
||
}
|
||
var rounds = this._Ke.length - 1;
|
||
var a = [0, 0, 0, 0];
|
||
|
||
// convert plaintext to (ints ^ key)
|
||
var t = convertToInt32(plaintext);
|
||
for (var i = 0; i < 4; i++) {
|
||
t[i] ^= this._Ke[0][i];
|
||
}
|
||
|
||
// apply round transforms
|
||
for (var r = 1; r < rounds; r++) {
|
||
for (var i = 0; i < 4; i++) {
|
||
a[i] = T1[t[i] >> 24 & 0xff] ^ T2[t[(i + 1) % 4] >> 16 & 0xff] ^ T3[t[(i + 2) % 4] >> 8 & 0xff] ^ T4[t[(i + 3) % 4] & 0xff] ^ this._Ke[r][i];
|
||
}
|
||
t = a.slice();
|
||
}
|
||
|
||
// the last round is special
|
||
var result = createArray(16),
|
||
tt;
|
||
for (var i = 0; i < 4; i++) {
|
||
tt = this._Ke[rounds][i];
|
||
result[4 * i] = (S[t[i] >> 24 & 0xff] ^ tt >> 24) & 0xff;
|
||
result[4 * i + 1] = (S[t[(i + 1) % 4] >> 16 & 0xff] ^ tt >> 16) & 0xff;
|
||
result[4 * i + 2] = (S[t[(i + 2) % 4] >> 8 & 0xff] ^ tt >> 8) & 0xff;
|
||
result[4 * i + 3] = (S[t[(i + 3) % 4] & 0xff] ^ tt) & 0xff;
|
||
}
|
||
return result;
|
||
};
|
||
AesJs.prototype.decrypt = function (ciphertext) {
|
||
if (ciphertext.length != 16) {
|
||
throw new Error('invalid ciphertext size (must be 16 bytes)');
|
||
}
|
||
var rounds = this._Kd.length - 1;
|
||
var a = [0, 0, 0, 0];
|
||
|
||
// convert plaintext to (ints ^ key)
|
||
var t = convertToInt32(ciphertext);
|
||
for (var i = 0; i < 4; i++) {
|
||
t[i] ^= this._Kd[0][i];
|
||
}
|
||
|
||
// apply round transforms
|
||
for (var r = 1; r < rounds; r++) {
|
||
for (var i = 0; i < 4; i++) {
|
||
a[i] = T5[t[i] >> 24 & 0xff] ^ T6[t[(i + 3) % 4] >> 16 & 0xff] ^ T7[t[(i + 2) % 4] >> 8 & 0xff] ^ T8[t[(i + 1) % 4] & 0xff] ^ this._Kd[r][i];
|
||
}
|
||
t = a.slice();
|
||
}
|
||
|
||
// the last round is special
|
||
var result = createArray(16),
|
||
tt;
|
||
for (var i = 0; i < 4; i++) {
|
||
tt = this._Kd[rounds][i];
|
||
result[4 * i] = (Si[t[i] >> 24 & 0xff] ^ tt >> 24) & 0xff;
|
||
result[4 * i + 1] = (Si[t[(i + 3) % 4] >> 16 & 0xff] ^ tt >> 16) & 0xff;
|
||
result[4 * i + 2] = (Si[t[(i + 2) % 4] >> 8 & 0xff] ^ tt >> 8) & 0xff;
|
||
result[4 * i + 3] = (Si[t[(i + 1) % 4] & 0xff] ^ tt) & 0xff;
|
||
}
|
||
return result;
|
||
};
|
||
|
||
/**
|
||
* Mode Of Operation - Electonic Codebook (ECB)
|
||
*/
|
||
var ModeOfOperationECB = function (key) {
|
||
if (!(this instanceof ModeOfOperationECB)) {
|
||
throw Error('AES must be instanitated with `new`');
|
||
}
|
||
this.description = "Electronic Code Block";
|
||
this.name = "ecb";
|
||
this._aes = new AesJs(key);
|
||
};
|
||
ModeOfOperationECB.prototype.encrypt = function (plaintext) {
|
||
plaintext = coerceArray(plaintext);
|
||
if (plaintext.length % 16 !== 0) {
|
||
throw new Error('invalid plaintext size (must be multiple of 16 bytes)');
|
||
}
|
||
var ciphertext = createArray(plaintext.length);
|
||
var block = createArray(16);
|
||
for (var i = 0; i < plaintext.length; i += 16) {
|
||
copyArray(plaintext, block, 0, i, i + 16);
|
||
block = this._aes.encrypt(block);
|
||
copyArray(block, ciphertext, i);
|
||
}
|
||
return ciphertext;
|
||
};
|
||
ModeOfOperationECB.prototype.decrypt = function (ciphertext) {
|
||
ciphertext = coerceArray(ciphertext);
|
||
if (ciphertext.length % 16 !== 0) {
|
||
throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');
|
||
}
|
||
var plaintext = createArray(ciphertext.length);
|
||
var block = createArray(16);
|
||
for (var i = 0; i < ciphertext.length; i += 16) {
|
||
copyArray(ciphertext, block, 0, i, i + 16);
|
||
block = this._aes.decrypt(block);
|
||
copyArray(block, plaintext, i);
|
||
}
|
||
return plaintext;
|
||
};
|
||
|
||
/**
|
||
* Mode Of Operation - Cipher Block Chaining (CBC)
|
||
*/
|
||
var ModeOfOperationCBC = function (key, iv) {
|
||
if (!(this instanceof ModeOfOperationCBC)) {
|
||
throw Error('AES must be instanitated with `new`');
|
||
}
|
||
this.description = "Cipher Block Chaining";
|
||
this.name = "cbc";
|
||
if (!iv) {
|
||
iv = createArray(16);
|
||
} else if (iv.length != 16) {
|
||
throw new Error('invalid initialation vector size (must be 16 bytes)');
|
||
}
|
||
this._lastCipherblock = coerceArray(iv, true);
|
||
this._aes = new AesJs(key);
|
||
};
|
||
ModeOfOperationCBC.prototype.encrypt = function (plaintext) {
|
||
plaintext = coerceArray(plaintext);
|
||
if (plaintext.length % 16 !== 0) {
|
||
throw new Error('invalid plaintext size (must be multiple of 16 bytes)');
|
||
}
|
||
var ciphertext = createArray(plaintext.length);
|
||
var block = createArray(16);
|
||
for (var i = 0; i < plaintext.length; i += 16) {
|
||
copyArray(plaintext, block, 0, i, i + 16);
|
||
for (var j = 0; j < 16; j++) {
|
||
block[j] ^= this._lastCipherblock[j];
|
||
}
|
||
this._lastCipherblock = this._aes.encrypt(block);
|
||
copyArray(this._lastCipherblock, ciphertext, i);
|
||
}
|
||
return ciphertext;
|
||
};
|
||
ModeOfOperationCBC.prototype.decrypt = function (ciphertext) {
|
||
ciphertext = coerceArray(ciphertext);
|
||
if (ciphertext.length % 16 !== 0) {
|
||
throw new Error('invalid ciphertext size (must be multiple of 16 bytes)');
|
||
}
|
||
var plaintext = createArray(ciphertext.length);
|
||
var block = createArray(16);
|
||
for (var i = 0; i < ciphertext.length; i += 16) {
|
||
copyArray(ciphertext, block, 0, i, i + 16);
|
||
block = this._aes.decrypt(block);
|
||
for (var j = 0; j < 16; j++) {
|
||
plaintext[i + j] = block[j] ^ this._lastCipherblock[j];
|
||
}
|
||
copyArray(ciphertext, this._lastCipherblock, 0, i, i + 16);
|
||
}
|
||
return plaintext;
|
||
};
|
||
|
||
/**
|
||
* Mode Of Operation - Cipher Feedback (CFB)
|
||
*/
|
||
var ModeOfOperationCFB = function (key, iv, segmentSize) {
|
||
if (!(this instanceof ModeOfOperationCFB)) {
|
||
throw Error('AES must be instanitated with `new`');
|
||
}
|
||
this.description = "Cipher Feedback";
|
||
this.name = "cfb";
|
||
if (!iv) {
|
||
iv = createArray(16);
|
||
} else if (iv.length != 16) {
|
||
throw new Error('invalid initialation vector size (must be 16 size)');
|
||
}
|
||
if (!segmentSize) {
|
||
segmentSize = 1;
|
||
}
|
||
this.segmentSize = segmentSize;
|
||
this._shiftRegister = coerceArray(iv, true);
|
||
this._aes = new AesJs(key);
|
||
};
|
||
ModeOfOperationCFB.prototype.encrypt = function (plaintext) {
|
||
if (plaintext.length % this.segmentSize != 0) {
|
||
throw new Error('invalid plaintext size (must be segmentSize bytes)');
|
||
}
|
||
var encrypted = coerceArray(plaintext, true);
|
||
var xorSegment;
|
||
for (var i = 0; i < encrypted.length; i += this.segmentSize) {
|
||
xorSegment = this._aes.encrypt(this._shiftRegister);
|
||
for (var j = 0; j < this.segmentSize; j++) {
|
||
encrypted[i + j] ^= xorSegment[j];
|
||
}
|
||
|
||
// Shift the register
|
||
copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize);
|
||
copyArray(encrypted, this._shiftRegister, 16 - this.segmentSize, i, i + this.segmentSize);
|
||
}
|
||
return encrypted;
|
||
};
|
||
ModeOfOperationCFB.prototype.decrypt = function (ciphertext) {
|
||
if (ciphertext.length % this.segmentSize != 0) {
|
||
throw new Error('invalid ciphertext size (must be segmentSize bytes)');
|
||
}
|
||
var plaintext = coerceArray(ciphertext, true);
|
||
var xorSegment;
|
||
for (var i = 0; i < plaintext.length; i += this.segmentSize) {
|
||
xorSegment = this._aes.encrypt(this._shiftRegister);
|
||
for (var j = 0; j < this.segmentSize; j++) {
|
||
plaintext[i + j] ^= xorSegment[j];
|
||
}
|
||
|
||
// Shift the register
|
||
copyArray(this._shiftRegister, this._shiftRegister, 0, this.segmentSize);
|
||
copyArray(ciphertext, this._shiftRegister, 16 - this.segmentSize, i, i + this.segmentSize);
|
||
}
|
||
return plaintext;
|
||
};
|
||
|
||
/**
|
||
* Mode Of Operation - Output Feedback (OFB)
|
||
*/
|
||
var ModeOfOperationOFB = function (key, iv) {
|
||
if (!(this instanceof ModeOfOperationOFB)) {
|
||
throw Error('AES must be instanitated with `new`');
|
||
}
|
||
this.description = "Output Feedback";
|
||
this.name = "ofb";
|
||
if (!iv) {
|
||
iv = createArray(16);
|
||
} else if (iv.length != 16) {
|
||
throw new Error('invalid initialation vector size (must be 16 bytes)');
|
||
}
|
||
this._lastPrecipher = coerceArray(iv, true);
|
||
this._lastPrecipherIndex = 16;
|
||
this._aes = new AesJs(key);
|
||
};
|
||
ModeOfOperationOFB.prototype.encrypt = function (plaintext) {
|
||
var encrypted = coerceArray(plaintext, true);
|
||
for (var i = 0; i < encrypted.length; i++) {
|
||
if (this._lastPrecipherIndex === 16) {
|
||
this._lastPrecipher = this._aes.encrypt(this._lastPrecipher);
|
||
this._lastPrecipherIndex = 0;
|
||
}
|
||
encrypted[i] ^= this._lastPrecipher[this._lastPrecipherIndex++];
|
||
}
|
||
return encrypted;
|
||
};
|
||
|
||
// Decryption is symetric
|
||
ModeOfOperationOFB.prototype.decrypt = ModeOfOperationOFB.prototype.encrypt;
|
||
|
||
/**
|
||
* Counter object for CTR common mode of operation
|
||
*/
|
||
var Counter = function (initialValue) {
|
||
if (!(this instanceof Counter)) {
|
||
throw Error('Counter must be instanitated with `new`');
|
||
}
|
||
|
||
// We allow 0, but anything false-ish uses the default 1
|
||
if (initialValue !== 0 && !initialValue) {
|
||
initialValue = 1;
|
||
}
|
||
if (typeof initialValue === 'number') {
|
||
this._counter = createArray(16);
|
||
this.setValue(initialValue);
|
||
} else {
|
||
this.setBytes(initialValue);
|
||
}
|
||
};
|
||
Counter.prototype.setValue = function (value) {
|
||
if (typeof value !== 'number' || parseInt(value) != value) {
|
||
throw new Error('invalid counter value (must be an integer)');
|
||
}
|
||
|
||
// We cannot safely handle numbers beyond the safe range for integers
|
||
if (value > Number.MAX_SAFE_INTEGER) {
|
||
throw new Error('integer value out of safe range');
|
||
}
|
||
for (var index = 15; index >= 0; --index) {
|
||
this._counter[index] = value % 256;
|
||
value = parseInt(value / 256);
|
||
}
|
||
};
|
||
Counter.prototype.setBytes = function (bytes) {
|
||
bytes = coerceArray(bytes, true);
|
||
if (bytes.length != 16) {
|
||
throw new Error('invalid counter bytes size (must be 16 bytes)');
|
||
}
|
||
this._counter = bytes;
|
||
};
|
||
Counter.prototype.increment = function () {
|
||
for (var i = 15; i >= 0; i--) {
|
||
if (this._counter[i] === 255) {
|
||
this._counter[i] = 0;
|
||
} else {
|
||
this._counter[i]++;
|
||
break;
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Mode Of Operation - Counter (CTR)
|
||
*/
|
||
var ModeOfOperationCTR = function (key, counter) {
|
||
if (!(this instanceof ModeOfOperationCTR)) {
|
||
throw Error('AES must be instanitated with `new`');
|
||
}
|
||
this.description = "Counter";
|
||
this.name = "ctr";
|
||
if (!(counter instanceof Counter)) {
|
||
counter = new Counter(counter);
|
||
}
|
||
this._counter = counter;
|
||
this._remainingCounter = null;
|
||
this._remainingCounterIndex = 16;
|
||
this._aes = new AesJs(key);
|
||
};
|
||
ModeOfOperationCTR.prototype.encrypt = function (plaintext) {
|
||
var encrypted = coerceArray(plaintext, true);
|
||
for (var i = 0; i < encrypted.length; i++) {
|
||
if (this._remainingCounterIndex === 16) {
|
||
this._remainingCounter = this._aes.encrypt(this._counter._counter);
|
||
this._remainingCounterIndex = 0;
|
||
this._counter.increment();
|
||
}
|
||
encrypted[i] ^= this._remainingCounter[this._remainingCounterIndex++];
|
||
}
|
||
return encrypted;
|
||
};
|
||
|
||
// Decryption is symetric
|
||
ModeOfOperationCTR.prototype.decrypt = ModeOfOperationCTR.prototype.encrypt;
|
||
|
||
///////////////////////
|
||
// Padding
|
||
|
||
// See:https://tools.ietf.org/html/rfc2315
|
||
function pkcs7pad(data) {
|
||
data = coerceArray(data, true);
|
||
var padder = 16 - data.length % 16;
|
||
var result = createArray(data.length + padder);
|
||
copyArray(data, result);
|
||
for (var i = data.length; i < result.length; i++) {
|
||
result[i] = padder;
|
||
}
|
||
return result;
|
||
}
|
||
function pkcs7strip(data) {
|
||
data = coerceArray(data, true);
|
||
if (data.length < 16) {
|
||
throw new Error('PKCS#7 invalid length');
|
||
}
|
||
var padder = data[data.length - 1];
|
||
if (padder > 16) {
|
||
throw new Error('PKCS#7 padding byte out of range');
|
||
}
|
||
var length = data.length - padder;
|
||
for (var i = 0; i < padder; i++) {
|
||
if (data[length + i] !== padder) {
|
||
throw new Error('PKCS#7 invalid padding byte');
|
||
}
|
||
}
|
||
var result = createArray(length);
|
||
copyArray(data, result, 0, 0, length);
|
||
return result;
|
||
}
|
||
|
||
///////////////////////
|
||
// Exporting
|
||
|
||
// The block cipher
|
||
const aesjs = {
|
||
AES: AesJs,
|
||
Counter: Counter,
|
||
ModeOfOperation: {
|
||
ecb: ModeOfOperationECB,
|
||
cbc: ModeOfOperationCBC,
|
||
cfb: ModeOfOperationCFB,
|
||
ofb: ModeOfOperationOFB,
|
||
ctr: ModeOfOperationCTR
|
||
},
|
||
utils: {
|
||
hex: convertHex,
|
||
utf8: convertUtf8
|
||
},
|
||
padding: {
|
||
pkcs7: {
|
||
pad: pkcs7pad,
|
||
strip: pkcs7strip
|
||
}
|
||
},
|
||
_arrayTest: {
|
||
coerceArray: coerceArray,
|
||
createArray: createArray,
|
||
copyArray: copyArray
|
||
}
|
||
};
|
||
|
||
function getNaluLength(data) {
|
||
let length = data[3] | data[2] << 8 | data[1] << 16 | data[0] << 24;
|
||
return length;
|
||
}
|
||
|
||
// aes-256-ctr 解密
|
||
function aes256ctrDecrypt(arrayBuffer, key, iv) {
|
||
key = new Uint8Array(key);
|
||
iv = new Uint8Array(iv);
|
||
const totalLength = arrayBuffer.byteLength;
|
||
let startIndex = 5;
|
||
while (startIndex < totalLength) {
|
||
let tempNaluLength = getNaluLength(arrayBuffer.slice(startIndex, startIndex + 4));
|
||
if (tempNaluLength > totalLength) {
|
||
break;
|
||
}
|
||
let naluType = arrayBuffer[startIndex + 4];
|
||
naluType = naluType & 0x1f;
|
||
if (naluType === 1 || naluType === 5) {
|
||
const tempNalu = arrayBuffer.slice(startIndex + 4 + 2, startIndex + 4 + tempNaluLength);
|
||
let aesCtr = new aesjs.ModeOfOperation.ctr(key, new aesjs.Counter(iv));
|
||
const decryptMsg = aesCtr.decrypt(tempNalu);
|
||
// release memory
|
||
aesCtr = null;
|
||
arrayBuffer.set(decryptMsg, startIndex + 4 + 2);
|
||
}
|
||
startIndex = startIndex + 4 + tempNaluLength;
|
||
}
|
||
return arrayBuffer;
|
||
}
|
||
|
||
if (!Date.now) Date.now = function () {
|
||
return new Date().getTime();
|
||
};
|
||
function workerPostRun (Module) {
|
||
let bufferList = [];
|
||
let tempAudioBuffer = [];
|
||
let wcsVideoDecoder = {};
|
||
let abortController = new AbortController();
|
||
let socket = null;
|
||
let streamRate = null;
|
||
let streamRateAndStatsInterval = null;
|
||
let input = null;
|
||
let videoWidth = null;
|
||
let videoHeight = null;
|
||
let hasInitVideoCodec = false;
|
||
let hasInitAudioCodec = false;
|
||
let isVideoFirstIFrame = false;
|
||
// let lastDecodeVideoFrameTimestamp = 0;
|
||
// let lastDecodeVideoFrameLocalTimestamp = 0;
|
||
// let lastDecodeAudioFrameTimestamp = 0;
|
||
// let newDecodedVideoFrameTimestamp = 0;
|
||
// let newDecodedVideoFrameLocalTimestamp = 0;
|
||
// let newDecodedAudioFrameTimestamp = 0;
|
||
let isStreamTimeDiffMoreThanLocalTimeDiff = false;
|
||
let preLoopTimestamp = null;
|
||
let bufferStartDts = null;
|
||
let bufferStartLocalTs = null;
|
||
let audioOutputArray = [];
|
||
let audioRemain = 0;
|
||
let audioChannels = 0;
|
||
let preIframeTs = null;
|
||
let preTimestamp = null;
|
||
let getDefaultOpt = () => {
|
||
const defaultOptions = getDefaultPlayerOptions();
|
||
return {
|
||
debug: defaultOptions.debug,
|
||
debugLevel: defaultOptions.debugLevel,
|
||
debugUuid: defaultOptions.debugUuid,
|
||
useOffscreen: defaultOptions.useOffscreen,
|
||
useWCS: defaultOptions.useWCS,
|
||
videoBuffer: defaultOptions.videoBuffer,
|
||
videoBufferDelay: defaultOptions.videoBufferDelay,
|
||
openWebglAlignment: defaultOptions.openWebglAlignment,
|
||
playType: defaultOptions.playType,
|
||
hasAudio: defaultOptions.hasAudio,
|
||
hasVideo: defaultOptions.hasVideo,
|
||
playbackRate: 1,
|
||
playbackForwardMaxRateDecodeIFrame: defaultOptions.playbackForwardMaxRateDecodeIFrame,
|
||
playbackIsCacheBeforeDecodeForFpsRender: defaultOptions.playbackConfig.isCacheBeforeDecodeForFpsRender,
|
||
sampleRate: 0,
|
||
networkDelay: defaultOptions.networkDelay,
|
||
visibility: true,
|
||
useSIMD: defaultOptions.useSIMD,
|
||
isRecording: false,
|
||
recordType: defaultOptions.recordType,
|
||
isNakedFlow: defaultOptions.isNakedFlow,
|
||
checkFirstIFrame: defaultOptions.checkFirstIFrame,
|
||
audioBufferSize: 1024,
|
||
isCrypto: defaultOptions.isCrypto,
|
||
cryptoKey: defaultOptions.cryptoKey,
|
||
cryptoIV: defaultOptions.cryptoIV
|
||
};
|
||
};
|
||
if ("VideoEncoder" in self) {
|
||
wcsVideoDecoder = {
|
||
hasInit: false,
|
||
isEmitInfo: false,
|
||
offscreenCanvas: null,
|
||
offscreenCanvasCtx: null,
|
||
decoder: new VideoDecoder({
|
||
output: function (videoFrame) {
|
||
if (!wcsVideoDecoder.isEmitInfo) {
|
||
decoder.debug.log('worker', 'Webcodecs Video Decoder initSize');
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.initVideo,
|
||
w: videoFrame.codedWidth,
|
||
h: videoFrame.codedHeight
|
||
});
|
||
wcsVideoDecoder.isEmitInfo = true;
|
||
wcsVideoDecoder.offscreenCanvas = new OffscreenCanvas(videoFrame.codedWidth, videoFrame.codedHeight);
|
||
wcsVideoDecoder.offscreenCanvasCtx = wcsVideoDecoder.offscreenCanvas.getContext("2d");
|
||
}
|
||
if (isFunction(videoFrame.createImageBitmap)) {
|
||
videoFrame.createImageBitmap().then(image => {
|
||
wcsVideoDecoder.offscreenCanvasCtx.drawImage(image, 0, 0, videoFrame.codedWidth, videoFrame.codedHeight);
|
||
let image_bitmap = wcsVideoDecoder.offscreenCanvas.transferToImageBitmap();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.render,
|
||
buffer: image_bitmap,
|
||
delay: decoder.delay,
|
||
ts: 0
|
||
}, [image_bitmap]);
|
||
setTimeout(function () {
|
||
if (videoFrame.close) {
|
||
videoFrame.close();
|
||
} else {
|
||
videoFrame.destroy();
|
||
}
|
||
}, 100);
|
||
});
|
||
} else {
|
||
wcsVideoDecoder.offscreenCanvasCtx.drawImage(videoFrame, 0, 0, videoFrame.codedWidth, videoFrame.codedHeight);
|
||
let image_bitmap = wcsVideoDecoder.offscreenCanvas.transferToImageBitmap();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.render,
|
||
buffer: image_bitmap,
|
||
delay: decoder.delay,
|
||
ts: 0
|
||
}, [image_bitmap]);
|
||
setTimeout(function () {
|
||
if (videoFrame.close) {
|
||
videoFrame.close();
|
||
} else {
|
||
videoFrame.destroy();
|
||
}
|
||
}, 100);
|
||
}
|
||
},
|
||
error: function (error) {
|
||
decoder.debug.error('worker', 'VideoDecoder error', error);
|
||
}
|
||
}),
|
||
decode: function (payload, ts, cts) {
|
||
const isIFrame = payload[0] >> 4 === 1;
|
||
if (!wcsVideoDecoder.hasInit) {
|
||
if (isIFrame && payload[1] === 0) {
|
||
const videoCodec = payload[0] & 0x0F;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.videoCode,
|
||
code: videoCodec
|
||
});
|
||
const extraData = payload.slice(5);
|
||
const config = formatVideoDecoderConfigure(extraData);
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.videoCodec,
|
||
buffer: payload,
|
||
codecId: videoCodec
|
||
}, [payload.buffer]);
|
||
wcsVideoDecoder.decoder.configure(config);
|
||
wcsVideoDecoder.hasInit = true;
|
||
}
|
||
} else {
|
||
const chunk = new EncodedVideoChunk({
|
||
data: payload.slice(5),
|
||
timestamp: ts,
|
||
type: isIFrame ? ENCODED_VIDEO_TYPE.key : ENCODED_VIDEO_TYPE.delta
|
||
});
|
||
wcsVideoDecoder.decoder.decode(chunk);
|
||
}
|
||
},
|
||
reset() {
|
||
wcsVideoDecoder.hasInit = false;
|
||
wcsVideoDecoder.isEmitInfo = false;
|
||
wcsVideoDecoder.offscreenCanvas = null;
|
||
wcsVideoDecoder.offscreenCanvasCtx = null;
|
||
}
|
||
};
|
||
}
|
||
let abort = function () {
|
||
if (abortController) {
|
||
abortController.abort();
|
||
abortController = null;
|
||
}
|
||
};
|
||
let nakedFlowDemuxer = {
|
||
init() {
|
||
nakedFlowDemuxer.lastBuf = null;
|
||
nakedFlowDemuxer.vps = null;
|
||
nakedFlowDemuxer.sps = null;
|
||
nakedFlowDemuxer.pps = null;
|
||
nakedFlowDemuxer.streamType = null;
|
||
nakedFlowDemuxer.localDts = 0;
|
||
nakedFlowDemuxer.isSendSeqHeader = false;
|
||
},
|
||
destroy() {
|
||
nakedFlowDemuxer.lastBuf = null;
|
||
nakedFlowDemuxer.vps = null;
|
||
nakedFlowDemuxer.sps = null;
|
||
nakedFlowDemuxer.pps = null;
|
||
nakedFlowDemuxer.streamType = null;
|
||
nakedFlowDemuxer.localDts = 0;
|
||
nakedFlowDemuxer.isSendSeqHeader = false;
|
||
},
|
||
//
|
||
dispatch(data) {
|
||
const uint8Array = new Uint8Array(data);
|
||
// decoder.debug.log('worker', 'nakedFlowDemuxer dispatch', uint8Array.byteLength);
|
||
nakedFlowDemuxer.extractNALu$2(uint8Array);
|
||
// nakedFlowDemuxer.handleNALu(uint8Array);
|
||
},
|
||
|
||
getNaluDts() {
|
||
let resul = nakedFlowDemuxer.localDts;
|
||
nakedFlowDemuxer.localDts = nakedFlowDemuxer.localDts + 1000 / 25;
|
||
return resul;
|
||
},
|
||
getNaluAudioDts() {
|
||
const audioContextSampleRate = decoder._opt.sampleRate;
|
||
const audioBufferSize = decoder._opt.audioBufferSize;
|
||
return nakedFlowDemuxer.localDts + parseInt(audioBufferSize / audioContextSampleRate * 1000);
|
||
},
|
||
extractNALu(buffer) {
|
||
let i = 0,
|
||
length = buffer.byteLength,
|
||
value,
|
||
state = 0,
|
||
result = [],
|
||
lastIndex;
|
||
while (i < length) {
|
||
value = buffer[i++];
|
||
// Annex-B格式使用start code进行分割，start code为0x000001或0x00000001，SPS/PPS作为一般NALU单元以start code作为分隔符的方式放在文件或者直播流的头部。
|
||
// finding 3 or 4-byte start codes (00 00 01 OR 00 00 00 01)
|
||
switch (state) {
|
||
case 0:
|
||
if (value === 0) {
|
||
state = 1;
|
||
}
|
||
break;
|
||
case 1:
|
||
if (value === 0) {
|
||
state = 2;
|
||
} else {
|
||
state = 0;
|
||
}
|
||
break;
|
||
case 2:
|
||
case 3:
|
||
if (value === 0) {
|
||
state = 3;
|
||
} else if (value === 1 && i < length) {
|
||
if (lastIndex) {
|
||
result.push(buffer.subarray(lastIndex, i - state - 1));
|
||
}
|
||
lastIndex = i;
|
||
state = 0;
|
||
} else {
|
||
state = 0;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (lastIndex) {
|
||
result.push(buffer.subarray(lastIndex, length));
|
||
}
|
||
return result;
|
||
},
|
||
extractNALu$2(buffer) {
|
||
let typedArray = null;
|
||
if (!buffer || buffer.byteLength < 1) return;
|
||
if (nakedFlowDemuxer.lastBuf) {
|
||
typedArray = new Uint8Array(buffer.byteLength + nakedFlowDemuxer.lastBuf.length);
|
||
typedArray.set(nakedFlowDemuxer.lastBuf);
|
||
typedArray.set(new Uint8Array(buffer), nakedFlowDemuxer.lastBuf.length);
|
||
} else {
|
||
typedArray = new Uint8Array(buffer);
|
||
}
|
||
let lastNalEndPos = 0;
|
||
let b1 = -1; // byte before one
|
||
let b2 = -2; // byte before two
|
||
const nalStartPos = new Array();
|
||
for (let i = 0; i < typedArray.length; i += 2) {
|
||
const b_0 = typedArray[i];
|
||
const b_1 = typedArray[i + 1];
|
||
if (b1 == 0 && b_0 == 0 && b_1 == 0) {
|
||
nalStartPos.push(i - 1);
|
||
} else if (b_1 == 1 && b_0 == 0 && b1 == 0 && b2 == 0) {
|
||
nalStartPos.push(i - 2);
|
||
}
|
||
b2 = b_0;
|
||
b1 = b_1;
|
||
}
|
||
if (nalStartPos.length > 1) {
|
||
for (let i = 0; i < nalStartPos.length - 1; ++i) {
|
||
const naluItem = typedArray.subarray(nalStartPos[i], nalStartPos[i + 1] + 1);
|
||
nakedFlowDemuxer.handleNALu(naluItem);
|
||
//console.log('nakedFlowDemuxer.lastBuf nalType', nakedFlowDemuxer.lastBuf.byteLength);
|
||
lastNalEndPos = nalStartPos[i + 1];
|
||
}
|
||
} else {
|
||
lastNalEndPos = nalStartPos[0];
|
||
}
|
||
if (lastNalEndPos != 0 && lastNalEndPos < typedArray.length) {
|
||
nakedFlowDemuxer.lastBuf = typedArray.subarray(lastNalEndPos);
|
||
} else {
|
||
if (!!!nakedFlowDemuxer.lastBuf) {
|
||
nakedFlowDemuxer.lastBuf = typedArray;
|
||
}
|
||
const _newBuf = new Uint8Array(nakedFlowDemuxer.lastBuf.length + buffer.byteLength);
|
||
_newBuf.set(nakedFlowDemuxer.lastBuf);
|
||
_newBuf.set(new Uint8Array(buffer), nakedFlowDemuxer.lastBuf.length);
|
||
nakedFlowDemuxer.lastBuf = _newBuf;
|
||
}
|
||
},
|
||
handleNALu(nalu) {
|
||
if (nalu.length <= 4) {
|
||
decoder.debug.error('worker', 'handleNALu', 'nalu.length <= 4');
|
||
return;
|
||
}
|
||
// 0001 去掉前4个字节（start code）
|
||
nalu = nalu.slice(4);
|
||
nakedFlowDemuxer.handleVideoNalu(nalu);
|
||
},
|
||
handleVideoNalu(nalu) {
|
||
// decoder.debug.log('worker', 'handleVideoNalu', nalu);
|
||
if (!nakedFlowDemuxer.streamType) {
|
||
nakedFlowDemuxer.streamType = checkNaluType(nalu);
|
||
}
|
||
if (nakedFlowDemuxer.streamType === VIDEO_ENC_TYPE_SHOW.h264) {
|
||
// const nalType = getAvcSeqHeadType(nalu);
|
||
// if (nalType === H264_NAL_TYPE.pps) {
|
||
// nakedFlowDemuxer.extractH264PPS(nalu);
|
||
// } else {
|
||
// nakedFlowDemuxer.handleVideoH264Nalu(nalu);
|
||
// }
|
||
const tempNalu = nakedFlowDemuxer.handleAddNaluStartCode(nalu);
|
||
const naluList = nakedFlowDemuxer.extractNALu(tempNalu);
|
||
if (naluList.length === 0) {
|
||
decoder.debug.warn('worker', 'handleVideoNalu', 'naluList.length === 0');
|
||
return;
|
||
}
|
||
const newNaluList = [];
|
||
naluList.forEach(naluItem => {
|
||
const nalType = getAvcSeqHeadType(naluItem);
|
||
if (nalType === H264_NAL_TYPE.pps || nalType === H264_NAL_TYPE.sps) {
|
||
nakedFlowDemuxer.handleVideoH264Nalu(naluItem);
|
||
} else {
|
||
if (isNotAvcSeqHead(nalType)) {
|
||
newNaluList.push(naluItem);
|
||
}
|
||
}
|
||
});
|
||
if (newNaluList.length === 1) {
|
||
nakedFlowDemuxer.handleVideoH264Nalu(newNaluList[0]);
|
||
} else {
|
||
const isSameNaluType = isSameAvcNaluType(newNaluList);
|
||
if (isSameNaluType) {
|
||
const naluType = getAvcSeqHeadType(newNaluList[0]);
|
||
const isIFrame = isAvcNaluIFrame(naluType);
|
||
nakedFlowDemuxer.handleVideoH264NaluList(newNaluList, isIFrame, naluType);
|
||
} else {
|
||
newNaluList.forEach(naluItem => {
|
||
nakedFlowDemuxer.handleVideoH264Nalu(naluItem);
|
||
});
|
||
}
|
||
}
|
||
} else if (nakedFlowDemuxer.streamType === VIDEO_ENC_TYPE_SHOW.h265) {
|
||
const naluType = getHevcSeqHeadType(nalu);
|
||
if (naluType === H265_NAL_TYPE.pps) {
|
||
nakedFlowDemuxer.extractH265PPS(nalu);
|
||
} else {
|
||
nakedFlowDemuxer.handleVideoH265Nalu(nalu);
|
||
}
|
||
}
|
||
},
|
||
extractH264PPS(nalu) {
|
||
const tempNalu = nakedFlowDemuxer.handleAddNaluStartCode(nalu);
|
||
const naluList = nakedFlowDemuxer.extractNALu(tempNalu);
|
||
naluList.forEach(naluItem => {
|
||
const nalType = getAvcSeqHeadType(naluItem);
|
||
if (isHvcSEIType(nalType)) {
|
||
nakedFlowDemuxer.extractH264SEI(naluItem);
|
||
} else {
|
||
nakedFlowDemuxer.handleVideoH264Nalu(naluItem);
|
||
}
|
||
});
|
||
},
|
||
extractH265PPS(nalu) {
|
||
const tempNalu = nakedFlowDemuxer.handleAddNaluStartCode(nalu);
|
||
const naluList = nakedFlowDemuxer.extractNALu(tempNalu);
|
||
naluList.forEach(naluItem => {
|
||
const nalType = getHevcSeqHeadType(naluItem);
|
||
if (isHevcSEIType(nalType)) {
|
||
nakedFlowDemuxer.extractH265SEI(naluItem);
|
||
} else {
|
||
nakedFlowDemuxer.handleVideoH265Nalu(naluItem);
|
||
}
|
||
});
|
||
},
|
||
extractH264SEI(nalu) {
|
||
const tempNalu = nakedFlowDemuxer.handleAddNaluStartCode(nalu);
|
||
const naluList = nakedFlowDemuxer.extractNALu(tempNalu);
|
||
naluList.forEach(naluItem => {
|
||
nakedFlowDemuxer.handleVideoH264Nalu(naluItem);
|
||
});
|
||
},
|
||
extractH265SEI(nalu) {
|
||
const tempNalu = nakedFlowDemuxer.handleAddNaluStartCode(nalu);
|
||
const naluList = nakedFlowDemuxer.extractNALu(tempNalu);
|
||
//console.log('extractH265SEI', naluList);
|
||
naluList.forEach(naluItem => {
|
||
nakedFlowDemuxer.handleVideoH265Nalu(naluItem);
|
||
});
|
||
},
|
||
handleAddNaluStartCode(nalu) {
|
||
const prefix = [0, 0, 0, 1];
|
||
const newNalu = new Uint8Array(nalu.length + prefix.length);
|
||
newNalu.set(prefix);
|
||
newNalu.set(nalu, prefix.length);
|
||
return newNalu;
|
||
},
|
||
handleVideoH264Nalu(nalu) {
|
||
const nalType = getAvcSeqHeadType(nalu);
|
||
// decoder.debug.log('worker', `handleVideoH264Nalu nalType is ${nalu[0]} , nalu[0] is ${nalType}`);
|
||
switch (nalType) {
|
||
case H264_NAL_TYPE.sps:
|
||
nakedFlowDemuxer.sps = nalu;
|
||
// console.log('handleVideoH264Nalu sps', nalu);
|
||
break;
|
||
case H264_NAL_TYPE.pps:
|
||
nakedFlowDemuxer.pps = nalu;
|
||
// console.log('handleVideoH264Nalu pps', nalu);
|
||
break;
|
||
}
|
||
if (!nakedFlowDemuxer.isSendSeqHeader) {
|
||
if (nakedFlowDemuxer.sps && nakedFlowDemuxer.pps) {
|
||
nakedFlowDemuxer.isSendSeqHeader = true;
|
||
const seqHeader = avcEncoderConfigurationRecord({
|
||
sps: nakedFlowDemuxer.sps,
|
||
pps: nakedFlowDemuxer.pps
|
||
});
|
||
// console.log('handleVideoH264Nalu seqHeader', seqHeader);
|
||
// decoder.decodeVideo(seqHeader, 0, true, 0);
|
||
decoder.decode(seqHeader, {
|
||
type: MEDIA_TYPE.video,
|
||
ts: 0,
|
||
isIFrame: true,
|
||
cts: 0
|
||
});
|
||
}
|
||
} else {
|
||
if (isNotAvcSeqHead(nalType)) {
|
||
const isIFrame = isAvcNaluIFrame(nalType);
|
||
const dts = nakedFlowDemuxer.getNaluDts();
|
||
if (isIFrame) {
|
||
decoder.calcIframeIntervalTimestamp(dts);
|
||
}
|
||
decoder.calcNetworkDelay(dts);
|
||
const packet = avcEncoderNalePacket(nalu, isIFrame);
|
||
decoder.decode(packet, {
|
||
type: MEDIA_TYPE.video,
|
||
ts: dts,
|
||
isIFrame: isIFrame,
|
||
cts: 0
|
||
});
|
||
// decoder.decodeVideo(packet, dts, isIFrame, 0);
|
||
} else {
|
||
decoder.debug.warn('work', `handleVideoH264Nalu Avc Seq Head is ${nalType}`);
|
||
}
|
||
// console.log('handleVideoH264Nalu packet', packet);
|
||
}
|
||
},
|
||
|
||
handleVideoH264NaluList(naluList, isIFrame, naluType) {
|
||
if (nakedFlowDemuxer.isSendSeqHeader) {
|
||
const dts = nakedFlowDemuxer.getNaluDts();
|
||
decoder.calcNetworkDelay(dts);
|
||
const newNalu = naluList.reduce((pre, cur) => {
|
||
const nalu2 = addNaleHeaderLength(pre);
|
||
const nalu3 = addNaleHeaderLength(cur);
|
||
const nalu4 = new Uint8Array(nalu2.byteLength + nalu3.byteLength);
|
||
nalu4.set(nalu2, 0);
|
||
nalu4.set(nalu3, nalu2.byteLength);
|
||
return nalu4;
|
||
});
|
||
const packet = avcEncoderNalePacketNotLength(newNalu, isIFrame);
|
||
decoder.decode(packet, {
|
||
type: MEDIA_TYPE.video,
|
||
ts: dts,
|
||
isIFrame: isIFrame,
|
||
cts: 0
|
||
});
|
||
decoder.debug.log('worker', `handleVideoH264NaluList list size is ${naluList.length} package length is ${packet.byteLength} isIFrame is ${isIFrame},nalu type is ${naluType}, dts is ${dts}`);
|
||
} else {
|
||
decoder.debug.warn('worker', 'handleVideoH264NaluList isSendSeqHeader is false');
|
||
}
|
||
},
|
||
handleVideoH265Nalu(nalu) {
|
||
const nalType = getHevcSeqHeadType(nalu);
|
||
// decoder.debug.log('worker', `handleVideoH265Nalu nalType is ${nalType} , isHevcNalIFrame ${isHevcNalIFrame(nalType)} ,nalu[0] is ${nalu[0]} ,nalu.bytelength is ${nalu.byteLength}`);
|
||
switch (nalType) {
|
||
case H265_NAL_TYPE.vps:
|
||
nakedFlowDemuxer.vps = nalu;
|
||
// console.log('handleVideoH265Nalu vps', nalu);
|
||
break;
|
||
case H265_NAL_TYPE.sps:
|
||
nakedFlowDemuxer.sps = nalu;
|
||
// console.log('handleVideoH265Nalu sps', nalu);
|
||
break;
|
||
case H265_NAL_TYPE.pps:
|
||
nakedFlowDemuxer.pps = nalu;
|
||
// console.log('handleVideoH265Nalu pps', nalu);
|
||
break;
|
||
}
|
||
if (!nakedFlowDemuxer.isSendSeqHeader) {
|
||
if (nakedFlowDemuxer.vps && nakedFlowDemuxer.sps && nakedFlowDemuxer.pps) {
|
||
nakedFlowDemuxer.isSendSeqHeader = true;
|
||
const seqHeader = hevcEncoderConfigurationRecord$2({
|
||
vps: nakedFlowDemuxer.vps,
|
||
sps: nakedFlowDemuxer.sps,
|
||
pps: nakedFlowDemuxer.pps
|
||
});
|
||
// console.log('handleVideoH265Nalu seqHeader', seqHeader, seqHeader.byteLength);
|
||
// decoder.decodeVideo(seqHeader, 0, true, 0);
|
||
decoder.decode(seqHeader, {
|
||
type: MEDIA_TYPE.video,
|
||
ts: 0,
|
||
isIFrame: true,
|
||
cts: 0
|
||
});
|
||
}
|
||
} else {
|
||
if (isNotHevcSeqHead(nalType)) {
|
||
const isIFrame = isHevcNalIFrame(nalType);
|
||
const dts = nakedFlowDemuxer.getNaluDts();
|
||
decoder.calcNetworkDelay(dts);
|
||
const packet = hevcEncoderNalePacket(nalu, isIFrame);
|
||
if (isIFrame) {
|
||
decoder.calcIframeIntervalTimestamp(dts);
|
||
}
|
||
// console.log('handleVideoH265Nalu packet', nalu, packet.byteLength, dts, isIFrame);
|
||
// decoder.decodeVideo(packet, dts, isIFrame, 0);
|
||
decoder.decode(packet, {
|
||
type: MEDIA_TYPE.video,
|
||
ts: dts,
|
||
isIFrame: isIFrame,
|
||
cts: 0
|
||
});
|
||
} else {
|
||
decoder.debug.warn('work', `handleVideoH265Nalu HevcSeqHead is ${nalType}`);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let decoder = {
|
||
isPlayer: true,
|
||
_opt: getDefaultOpt(),
|
||
startStreamRateAndStatsInterval: function () {
|
||
// decoder.debug.log('worker', 'startStreamRateAndStatsInterval');
|
||
decoder.stopStreamRateAndStatsInterval();
|
||
streamRateAndStatsInterval = setInterval(() => {
|
||
streamRate && streamRate(0);
|
||
const streamStats = JSON.stringify({
|
||
demuxBufferDelay: decoder.getVideoBufferLength(),
|
||
audioDemuxBufferDelay: decoder.getAudioBufferLength(),
|
||
flvBufferByteLength: decoder.getFlvBufferLength(),
|
||
netBuf: decoder.networkDelay || 0,
|
||
pushLatestDelay: decoder.pushLatestDelay || 0,
|
||
isDropping: decoder.dropping === true || decoder.isPushDropping === true,
|
||
isStreamTsMoreThanLocal: isStreamTimeDiffMoreThanLocalTimeDiff
|
||
});
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamStats,
|
||
value: streamStats
|
||
});
|
||
}, 1000);
|
||
},
|
||
stopStreamRateAndStatsInterval: function () {
|
||
// decoder.debug.log('worker', `stopStreamRateAndStatsInterval`);
|
||
if (streamRateAndStatsInterval) {
|
||
clearInterval(streamRateAndStatsInterval);
|
||
streamRateAndStatsInterval = null;
|
||
}
|
||
},
|
||
useOffscreen: function () {
|
||
return decoder._opt.useOffscreen && typeof OffscreenCanvas != 'undefined';
|
||
},
|
||
getDelay: function (timestamp) {
|
||
if (!timestamp || decoder._opt.hasVideo && !isVideoFirstIFrame) {
|
||
return -1;
|
||
}
|
||
if (decoder.preDelayTimestamp && decoder.preDelayTimestamp > timestamp) {
|
||
if (decoder.preDelayTimestamp - timestamp > 1000) {
|
||
decoder.debug.warn('worker', `getDelay() and preDelayTimestamp is ${decoder.preDelayTimestamp} > timestamp is ${timestamp} more than ${decoder.preDelayTimestamp - timestamp}ms`);
|
||
}
|
||
decoder.preDelayTimestamp = timestamp;
|
||
return decoder.delay;
|
||
}
|
||
if (!decoder.firstTimestamp) {
|
||
decoder.firstTimestamp = timestamp;
|
||
decoder.startTimestamp = Date.now();
|
||
decoder.delay = -1;
|
||
} else {
|
||
if (timestamp) {
|
||
const localTimestamp = Date.now() - decoder.startTimestamp;
|
||
const timeTimestamp = timestamp - decoder.firstTimestamp;
|
||
if (localTimestamp >= timeTimestamp) {
|
||
isStreamTimeDiffMoreThanLocalTimeDiff = false;
|
||
decoder.delay = localTimestamp - timeTimestamp;
|
||
} else {
|
||
// if stream ts more than local ts, support stream rate is more than 1 rate
|
||
isStreamTimeDiffMoreThanLocalTimeDiff = true;
|
||
decoder.delay = timeTimestamp - localTimestamp;
|
||
}
|
||
}
|
||
}
|
||
decoder.preDelayTimestamp = timestamp;
|
||
return decoder.delay;
|
||
},
|
||
getDelayNotUpdateDelay: function (timestamp) {
|
||
if (!timestamp || decoder._opt.hasVideo && !isVideoFirstIFrame) {
|
||
return -1;
|
||
}
|
||
if (decoder.preDelayTimestamp && decoder.preDelayTimestamp - timestamp > 1000) {
|
||
decoder.debug.warn('worker', `getDelayNotUpdateDelay and preDelayTimestamp is ${decoder.preDelayTimestamp} > timestamp is ${timestamp} more than ${decoder.preDelayTimestamp - timestamp}ms`);
|
||
return -1;
|
||
}
|
||
if (!decoder.firstTimestamp) {
|
||
return -1;
|
||
} else {
|
||
let delay = -1;
|
||
if (timestamp) {
|
||
const localTimestamp = Date.now() - decoder.startTimestamp;
|
||
const timeTimestamp = timestamp - decoder.firstTimestamp;
|
||
if (localTimestamp >= timeTimestamp) {
|
||
isStreamTimeDiffMoreThanLocalTimeDiff = false;
|
||
delay = localTimestamp - timeTimestamp;
|
||
} else {
|
||
isStreamTimeDiffMoreThanLocalTimeDiff = true;
|
||
delay = timeTimestamp - localTimestamp;
|
||
}
|
||
}
|
||
return delay;
|
||
}
|
||
},
|
||
resetDelay: function () {
|
||
decoder.firstTimestamp = null;
|
||
decoder.startTimestamp = null;
|
||
decoder.delay = -1;
|
||
},
|
||
resetAllDelay: function () {
|
||
decoder.resetDelay();
|
||
decoder.preDelayTimestamp = null;
|
||
},
|
||
doDecode: function (data) {
|
||
if (decoder._opt.useWCS && decoder.useOffscreen() && data.type === MEDIA_TYPE.video && wcsVideoDecoder.decode) {
|
||
wcsVideoDecoder.decode(data.payload, data.ts, data.cts);
|
||
} else {
|
||
data.decoder.decode(data.payload, data.ts, data.isIFrame, data.cts);
|
||
}
|
||
},
|
||
init: function () {
|
||
decoder.debug.log('worker', 'init and opt is', decoder._opt);
|
||
const isPlayer = decoder._opt.playType === PLAY_TYPE.player;
|
||
nakedFlowDemuxer.init();
|
||
decoder.isPlayer = isPlayer;
|
||
// player || (playback && not cache before decode for fps render)
|
||
if (!decoder.isPlaybackCacheBeforeDecodeForFpsRender()) {
|
||
// default loop
|
||
const loop = () => {
|
||
let data = null;
|
||
if (bufferList.length) {
|
||
if (decoder.isPushDropping) {
|
||
decoder.debug.warn('worker', `loop() isPushDropping is true and bufferList length is ${this.bufferList.length}`);
|
||
return;
|
||
}
|
||
if (decoder.dropping) {
|
||
// // dropping
|
||
data = bufferList.shift();
|
||
decoder.debug.warn('worker', `loop() dropBuffer is dropping and isIFrame ${data.isIFrame} and delay is ${decoder.delay} and bufferlist is ${bufferList.length}`);
|
||
//
|
||
while (!data.isIFrame && bufferList.length) {
|
||
// decoder.debug.log('worker', 'loop is dropping = true, isIFrame is', data.isIFrame);
|
||
// dropping
|
||
data = bufferList.shift();
|
||
}
|
||
const tempDelay = decoder.getDelayNotUpdateDelay(data.ts);
|
||
if (data.isIFrame && tempDelay <= decoder.getNotDroppingDelayTs()) {
|
||
decoder.debug.log('worker', 'loop() is dropping = false, is iFrame');
|
||
decoder.dropping = false;
|
||
decoder.doDecode(data);
|
||
}
|
||
} else {
|
||
data = bufferList[0];
|
||
if (decoder.getDelay(data.ts) === -1) {
|
||
decoder.debug.log('worker', 'loop() common dumex delay is -1 ,data.ts is', data.ts);
|
||
bufferList.shift();
|
||
decoder.doDecode(data);
|
||
} else if (decoder.delay > decoder._opt.videoBuffer + decoder._opt.videoBufferDelay && isPlayer) {
|
||
if (decoder.hasIframeInBufferList()) {
|
||
decoder.debug.log('worker', `delay is ${decoder.delay}, set dropping is true`);
|
||
decoder.resetAllDelay();
|
||
decoder.dropping = true;
|
||
} else {
|
||
bufferList.shift();
|
||
decoder.doDecode(data);
|
||
}
|
||
} else {
|
||
// 持续解码
|
||
while (bufferList.length) {
|
||
data = bufferList[0];
|
||
if (decoder.getDelay(data.ts) > decoder._opt.videoBuffer) {
|
||
bufferList.shift();
|
||
decoder.doDecode(data);
|
||
} else {
|
||
if (decoder.delay < 0) {
|
||
decoder.debug.warn('worker', `loop() do not decode and delay is ${decoder.delay}, bufferList is ${bufferList.length}`);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if (decoder.delay !== -1) {
|
||
decoder.debug.log('worker', 'loop() bufferList is empty and reset delay');
|
||
}
|
||
decoder.resetAllDelay();
|
||
}
|
||
};
|
||
decoder.stopId = setInterval(() => {
|
||
let nowTime = new Date().getTime();
|
||
if (!preLoopTimestamp) {
|
||
preLoopTimestamp = nowTime;
|
||
}
|
||
const diffTime = nowTime - preLoopTimestamp;
|
||
if (diffTime > 100) {
|
||
decoder.debug.warn('worker', `loop demux diff time is ${diffTime}`);
|
||
}
|
||
loop();
|
||
preLoopTimestamp = new Date().getTime();
|
||
}, 10);
|
||
} else {
|
||
decoder.debug.log('worker', 'playback and playbackIsCacheBeforeDecodeForFpsRender is true');
|
||
}
|
||
// if not check first frame is iframe, will set isVideoFirstIFrame = true
|
||
if (!decoder._opt.checkFirstIFrame) {
|
||
isVideoFirstIFrame = true;
|
||
}
|
||
},
|
||
playbackCacheLoop: function () {
|
||
if (decoder.stopId) {
|
||
clearInterval(decoder.stopId);
|
||
decoder.stopId = null;
|
||
}
|
||
const loop = () => {
|
||
let data = null;
|
||
if (bufferList.length) {
|
||
data = bufferList.shift();
|
||
decoder.doDecode(data);
|
||
}
|
||
};
|
||
loop();
|
||
const fragDuration = Math.ceil(1000 / (decoder.streamFps * decoder._opt.playbackRate));
|
||
decoder.debug.log('worker', `playbackCacheLoop fragDuration is ${fragDuration}, streamFps is ${decoder.streamFps}, playbackRate is ${decoder._opt.playbackRate}`);
|
||
decoder.stopId = setInterval(loop, fragDuration);
|
||
},
|
||
close: function () {
|
||
decoder.debug.log('worker', 'close');
|
||
decoder.stopStreamRateAndStatsInterval();
|
||
clearInterval(decoder.stopId);
|
||
decoder.stopId = null;
|
||
audioDecoder.clear && audioDecoder.clear();
|
||
videoDecoder.clear && videoDecoder.clear();
|
||
audioDecoder = null;
|
||
videoDecoder = null;
|
||
streamRate = null;
|
||
preLoopTimestamp = null;
|
||
isStreamTimeDiffMoreThanLocalTimeDiff = false;
|
||
// lastDecodeVideoFrameTimestamp = 0;
|
||
// lastDecodeVideoFrameLocalTimestamp = 0;
|
||
// lastDecodeAudioFrameTimestamp = 0;
|
||
// newDecodedVideoFrameTimestamp = 0;
|
||
// newDecodedVideoFrameLocalTimestamp = 0;
|
||
// newDecodedAudioFrameTimestamp = 0;
|
||
wcsVideoDecoder.reset && wcsVideoDecoder.reset();
|
||
decoder.firstTimestamp = null;
|
||
decoder.startTimestamp = null;
|
||
decoder.networkDelay = 0;
|
||
decoder.streamFps = null; // audio + video all fps
|
||
decoder.streamAudioFps = null; //
|
||
decoder.streamVideoFps = null;
|
||
decoder.delay = -1;
|
||
decoder.pushLatestDelay = -1;
|
||
decoder.preDelayTimestamp = null;
|
||
decoder.dropping = false;
|
||
decoder.isPushDropping = false;
|
||
decoder.isPlayer = true;
|
||
decoder._opt = getDefaultOpt();
|
||
if (decoder.webglObj) {
|
||
decoder.webglObj.destroy();
|
||
decoder.offscreenCanvas = null;
|
||
decoder.offscreenCanvasGL = null;
|
||
decoder.offscreenCanvasCtx = null;
|
||
}
|
||
bufferList = [];
|
||
tempAudioBuffer = [];
|
||
abort();
|
||
input = null;
|
||
if (socket) {
|
||
socket.close();
|
||
socket = null;
|
||
}
|
||
videoWidth = null;
|
||
videoHeight = null;
|
||
hasInitVideoCodec = false;
|
||
hasInitAudioCodec = false;
|
||
isVideoFirstIFrame = false;
|
||
audioOutputArray = [];
|
||
audioRemain = 0;
|
||
audioChannels = 0;
|
||
bufferStartDts = null;
|
||
bufferStartLocalTs = null;
|
||
preIframeTs = null;
|
||
preTimestamp = null;
|
||
nakedFlowDemuxer.destroy();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.closeEnd
|
||
});
|
||
},
|
||
pushBuffer: function (bufferData, options) {
|
||
if (options.type === MEDIA_TYPE.audio && isAacCodecPacket(bufferData)) {
|
||
decoder.decodeAudio(bufferData, options.ts);
|
||
return;
|
||
}
|
||
if (decoder.isPlayer && preTimestamp > 0 && options.type === MEDIA_TYPE.video && options.ts < preTimestamp && preTimestamp - options.ts > FRAME_TS_MAX_DIFF) {
|
||
decoder.debug.warn('worker', `pushBuffer, preTimestamp is ${preTimestamp}, options.ts is ${options.ts}, diff is ${preTimestamp - options.ts} more than ${FRAME_TS_MAX_DIFF}, resetAllDelay`);
|
||
decoder.resetAllDelay();
|
||
}
|
||
if (decoder.isPlayer && options.ts <= preTimestamp && preTimestamp > 0 && options.type === MEDIA_TYPE.video) {
|
||
decoder.debug.warn('worker', `pushBuffer, options.ts is ${options.ts} less than (or equal) preTimestamp is ${preTimestamp} and type is ${options.type}`);
|
||
}
|
||
|
||
// decoder.debug.error('worker', `pushBuffer and type is ${options.type}, isIframe is ${options.isIFrame}, ts is ${options.ts}`);
|
||
|
||
if (decoder.isPlayer && isVideoFirstIFrame) {
|
||
const maxDelay = decoder._opt.videoBuffer + decoder._opt.videoBufferDelay;
|
||
const pushLatestDelay = decoder.getDelayNotUpdateDelay(options.ts);
|
||
// update push latest delay
|
||
decoder.pushLatestDelay = pushLatestDelay;
|
||
if (pushLatestDelay > maxDelay && decoder.delay < maxDelay && decoder.delay > 0) {
|
||
if (decoder.hasIframeInBufferList() && decoder.isPushDropping === false) {
|
||
decoder.debug.log('worker', `pushBuffer, pushLatestDelay is ${pushLatestDelay} more than ${maxDelay} and decoder.delay is ${decoder.delay} and has iIframe and next decoder.dropBuffer$2()`);
|
||
decoder.dropBuffer$2();
|
||
}
|
||
}
|
||
}
|
||
if (options.type === MEDIA_TYPE.video) {
|
||
preTimestamp = options.ts;
|
||
}
|
||
// 音频
|
||
if (options.type === MEDIA_TYPE.audio) {
|
||
bufferList.push({
|
||
ts: options.ts,
|
||
payload: bufferData,
|
||
decoder: {
|
||
decode: decoder.decodeAudio
|
||
},
|
||
type: MEDIA_TYPE.audio,
|
||
isIFrame: false
|
||
});
|
||
} else if (options.type === MEDIA_TYPE.video) {
|
||
bufferList.push({
|
||
ts: options.ts,
|
||
cts: options.cts,
|
||
payload: bufferData,
|
||
decoder: {
|
||
decode: decoder.decodeVideo
|
||
},
|
||
type: MEDIA_TYPE.video,
|
||
isIFrame: options.isIFrame
|
||
});
|
||
}
|
||
if (decoder.isPlaybackCacheBeforeDecodeForFpsRender()) {
|
||
if (isEmpty(decoder.streamVideoFps) || isEmpty(decoder.streamAudioFps)) {
|
||
let streamVideoFps = decoder.streamVideoFps;
|
||
let streamAudioFps = decoder.streamAudioFps;
|
||
if (isEmpty(decoder.streamVideoFps)) {
|
||
streamVideoFps = calcStreamFpsByBufferList(bufferList, MEDIA_TYPE.video);
|
||
if (streamVideoFps) {
|
||
decoder.streamVideoFps = streamVideoFps;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.playbackStreamVideoFps,
|
||
value: decoder.streamVideoFps
|
||
});
|
||
if (streamAudioFps) {
|
||
decoder.streamFps = streamVideoFps + streamAudioFps;
|
||
} else {
|
||
decoder.streamFps = streamVideoFps;
|
||
}
|
||
decoder.playbackCacheLoop();
|
||
}
|
||
}
|
||
if (isEmpty(decoder.streamAudioFps)) {
|
||
streamAudioFps = calcStreamFpsByBufferList(bufferList, MEDIA_TYPE.audio);
|
||
if (streamAudioFps) {
|
||
decoder.streamAudioFps = streamAudioFps;
|
||
if (streamVideoFps) {
|
||
decoder.streamFps = streamVideoFps + streamAudioFps;
|
||
} else {
|
||
decoder.streamFps = streamAudioFps;
|
||
}
|
||
decoder.playbackCacheLoop();
|
||
}
|
||
}
|
||
if (isEmpty(decoder.streamVideoFps) && isEmpty(decoder.streamAudioFps)) {
|
||
decoder.debug.log('worker', `playbackCacheBeforeDecodeForFpsRender, calc streamAudioFps is ${streamAudioFps}, streamVideoFps is ${streamVideoFps}, bufferListLength is ${bufferList.length}`);
|
||
}
|
||
}
|
||
}
|
||
},
|
||
// video buffer length
|
||
getVideoBufferLength() {
|
||
let result = 0;
|
||
bufferList.forEach(item => {
|
||
if (item.type === MEDIA_TYPE.video) {
|
||
result += 1;
|
||
}
|
||
});
|
||
return result;
|
||
},
|
||
hasIframeInBufferList() {
|
||
return bufferList.some(item => {
|
||
return item.type === MEDIA_TYPE.video && item.isIFrame;
|
||
});
|
||
},
|
||
getNotDroppingDelayTs() {
|
||
return decoder._opt.videoBuffer + decoder._opt.videoBufferDelay / 2;
|
||
},
|
||
getAudioBufferLength() {
|
||
let result = 0;
|
||
bufferList.forEach(item => {
|
||
if (item.type === MEDIA_TYPE.audio) {
|
||
result += 1;
|
||
}
|
||
});
|
||
return result;
|
||
},
|
||
getFlvBufferLength() {
|
||
let result = 0;
|
||
if (input && input.buffer) {
|
||
result = input.buffer.byteLength;
|
||
}
|
||
if (decoder._opt.isNakedFlow) {
|
||
if (nakedFlowDemuxer.lastBuf) {
|
||
result = nakedFlowDemuxer.lastBuf.byteLength;
|
||
}
|
||
}
|
||
return result;
|
||
},
|
||
fetchStream: function (url, options) {
|
||
decoder.debug.log('worker', 'fetchStream, url is ' + url, 'options:', JSON.stringify(options));
|
||
streamRate = calculationRate(rate => {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamRate,
|
||
value: rate
|
||
});
|
||
});
|
||
decoder.startStreamRateAndStatsInterval();
|
||
if (options.protocol === PLAYER_PLAY_PROTOCOL.fetch) {
|
||
input = new OPut(decoder.demuxFlv());
|
||
fetch(url, {
|
||
signal: abortController.signal
|
||
}).then(res => {
|
||
if (!isFetchSuccess(res)) {
|
||
decoder.debug.error('worker', `fetch response status is ${res.status} and ok is ${res.ok} and emit error and next abort()`);
|
||
abort();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS_ERROR.fetchError,
|
||
value: `fetch response status is ${res.status} and ok is ${res.ok}`
|
||
});
|
||
return;
|
||
}
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamSuccess
|
||
});
|
||
if (supportWritableStream()) {
|
||
res.body.pipeTo(new WritableStream({
|
||
write: value => {
|
||
streamRate(value.byteLength);
|
||
input.write(value);
|
||
},
|
||
close: () => {
|
||
input = null;
|
||
},
|
||
abort: e => {
|
||
input = null;
|
||
if (e.name === FETCH_ERROR.abort) {
|
||
return;
|
||
}
|
||
abort();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS_ERROR.fetchError,
|
||
value: e.toString()
|
||
});
|
||
}
|
||
}));
|
||
} else {
|
||
const reader = res.body.getReader();
|
||
const fetchNext = () => {
|
||
reader.read().then(_ref => {
|
||
let {
|
||
done,
|
||
value
|
||
} = _ref;
|
||
if (done) {
|
||
input = null;
|
||
return;
|
||
}
|
||
streamRate(value.byteLength);
|
||
input.write(value);
|
||
fetchNext();
|
||
}).catch(e => {
|
||
input = null;
|
||
if (e.name === FETCH_ERROR.abort) {
|
||
return;
|
||
}
|
||
abort();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS_ERROR.fetchError,
|
||
value: e.toString()
|
||
});
|
||
});
|
||
};
|
||
fetchNext();
|
||
}
|
||
}).catch(e => {
|
||
if (e.name === FETCH_ERROR.abort) {
|
||
return;
|
||
}
|
||
abort();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS_ERROR.fetchError,
|
||
value: e.toString()
|
||
});
|
||
input = null;
|
||
});
|
||
} else if (options.protocol === PLAYER_PLAY_PROTOCOL.websocket) {
|
||
if (options.isFlv) {
|
||
input = new OPut(decoder.demuxFlv());
|
||
}
|
||
socket = new WebSocket(url);
|
||
socket.binaryType = 'arraybuffer';
|
||
socket.onopen = () => {
|
||
decoder.debug.log('worker', 'fetchStream, WebsocketStream socket open');
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamSuccess
|
||
});
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.websocketOpen
|
||
});
|
||
};
|
||
socket.onclose = () => {
|
||
decoder.debug.log('worker', 'fetchStream, WebsocketStream socket close');
|
||
input = null;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamEnd
|
||
});
|
||
};
|
||
socket.onerror = error => {
|
||
decoder.debug.error('worker', 'fetchStream, WebsocketStream socket error', error.toString());
|
||
input = null;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS_ERROR.websocketError,
|
||
value: error.toString()
|
||
});
|
||
};
|
||
socket.onmessage = event => {
|
||
streamRate(event.data.byteLength);
|
||
// decoder.debug.log('worker',` socket on message isFlv is ${options.isFlv}`);
|
||
|
||
if (options.isFlv) {
|
||
input.write(event.data);
|
||
// decoder.debug.log('worker',` input.bufferList.length is ${input.buffer.length},byteLength is ${input.buffer.byteLength}`);
|
||
} else if (decoder._opt.isNakedFlow) {
|
||
decoder.demuxNakedFlow(event.data);
|
||
} else {
|
||
decoder.demuxM7s(event.data);
|
||
}
|
||
};
|
||
}
|
||
},
|
||
demuxFlv: function* () {
|
||
yield 9;
|
||
const tmp = new ArrayBuffer(4);
|
||
const tmp8 = new Uint8Array(tmp);
|
||
const tmp32 = new Uint32Array(tmp);
|
||
while (true) {
|
||
tmp8[3] = 0;
|
||
const t = yield 15;
|
||
const type = t[4];
|
||
tmp8[0] = t[7];
|
||
tmp8[1] = t[6];
|
||
tmp8[2] = t[5];
|
||
const length = tmp32[0];
|
||
tmp8[0] = t[10];
|
||
tmp8[1] = t[9];
|
||
tmp8[2] = t[8];
|
||
let ts = tmp32[0];
|
||
if (ts === 0xFFFFFF) {
|
||
tmp8[3] = t[11];
|
||
ts = tmp32[0];
|
||
}
|
||
const payload = (yield length).slice();
|
||
// console.log('demuxFlv type is', type);
|
||
switch (type) {
|
||
case FLV_MEDIA_TYPE.audio:
|
||
decoder.decode(payload, {
|
||
type: MEDIA_TYPE.audio,
|
||
ts
|
||
});
|
||
break;
|
||
case FLV_MEDIA_TYPE.video:
|
||
if (payload.byteLength > 0) {
|
||
const isIFrame = payload[0] >> 4 === 1;
|
||
// just for player
|
||
if (decoder.isPlayer) {
|
||
decoder.calcNetworkDelay(ts);
|
||
if (isIFrame) {
|
||
decoder.calcIframeIntervalTimestamp(ts);
|
||
}
|
||
}
|
||
tmp32[0] = payload[4];
|
||
tmp32[1] = payload[3];
|
||
tmp32[2] = payload[2];
|
||
tmp32[3] = 0;
|
||
let cts = tmp32[0];
|
||
let payloadBuffer = payload;
|
||
if (decoder._opt.isCrypto) {
|
||
if (decoder._opt.cryptoIV && decoder._opt.cryptoIV.byteLength > 0 && decoder._opt.cryptoKey && decoder._opt.cryptoKey.byteLength > 0) {
|
||
payloadBuffer = aes256ctrDecrypt(payload, decoder._opt.cryptoKey, decoder._opt.cryptoIV);
|
||
} else {
|
||
decoder.debug.error('worker', `cryptoKey.length is ${decoder._opt.cryptoKey && decoder._opt.cryptoKey.byteLength} or cryptoIV.length is ${decoder._opt.cryptoIV && decoder._opt.cryptoIV.byteLength} null`);
|
||
}
|
||
}
|
||
|
||
// decoder.debug.log('worker',`demuxFlv dts:${ts},isIFrame:${isIFrame}`);
|
||
decoder.decode(payloadBuffer, {
|
||
type: MEDIA_TYPE.video,
|
||
ts,
|
||
isIFrame,
|
||
cts
|
||
});
|
||
}
|
||
break;
|
||
default:
|
||
decoder.debug.log('worker', `demuxFlv() type is ${type}`);
|
||
break;
|
||
}
|
||
}
|
||
},
|
||
decode: function (payload, options) {
|
||
let playType = decoder._opt.playType;
|
||
if (options.type === MEDIA_TYPE.audio) {
|
||
if (decoder._opt.hasAudio) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamAbps,
|
||
value: payload.byteLength
|
||
});
|
||
if (playType === PLAY_TYPE.player) {
|
||
decoder.pushBuffer(payload, {
|
||
type: options.type,
|
||
ts: options.ts,
|
||
cts: options.cts
|
||
});
|
||
} else if (playType === PLAY_TYPE.playbackTF) {
|
||
if (decoder.isPlaybackCacheBeforeDecodeForFpsRender()) {
|
||
decoder.pushBuffer(payload, {
|
||
type: options.type,
|
||
ts: options.ts,
|
||
cts: options.cts
|
||
});
|
||
} else {
|
||
if (decoder._opt.playbackRate === 1) {
|
||
decoder.pushBuffer(payload, {
|
||
type: options.type,
|
||
ts: options.ts,
|
||
cts: options.cts
|
||
});
|
||
} else {
|
||
decoder.decodeAudio(payload, options.ts);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else if (options.type === MEDIA_TYPE.video) {
|
||
if (decoder._opt.hasVideo) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamVbps,
|
||
value: payload.byteLength
|
||
});
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.streamDts,
|
||
value: options.ts
|
||
});
|
||
if (playType === PLAY_TYPE.player) {
|
||
// decoder.debug.log('worker','fetchStream, decode video isIFrame is', options.isIFrame);
|
||
decoder.pushBuffer(payload, {
|
||
type: options.type,
|
||
ts: options.ts,
|
||
isIFrame: options.isIFrame,
|
||
cts: options.cts
|
||
});
|
||
} else if (playType === PLAY_TYPE.playbackTF) {
|
||
if (decoder._opt.playbackRate >= decoder._opt.playbackForwardMaxRateDecodeIFrame) {
|
||
if (options.isIFrame) {
|
||
decoder.decodeVideo(payload, options.ts, options.isIFrame, options.cts);
|
||
}
|
||
} else {
|
||
if (decoder.isPlaybackCacheBeforeDecodeForFpsRender()) {
|
||
decoder.pushBuffer(payload, {
|
||
type: options.type,
|
||
ts: options.ts,
|
||
cts: options.cts,
|
||
isIFrame: options.isIFrame
|
||
});
|
||
} else {
|
||
if (decoder._opt.playbackRate === 1) {
|
||
decoder.pushBuffer(payload, {
|
||
type: options.type,
|
||
ts: options.ts,
|
||
cts: options.cts,
|
||
isIFrame: options.isIFrame
|
||
});
|
||
} else {
|
||
decoder.decodeVideo(payload, options.ts, options.isIFrame, options.cts);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
setCodecAudio: function (payload) {
|
||
const codecId = payload[0] >> 4;
|
||
if (isAacCodecPacket(payload) || codecId === AUDIO_ENC_CODE.ALAW || codecId === AUDIO_ENC_CODE.MULAW) {
|
||
decoder.debug.log('worker', `setCodecAudio: init audio codec, codeId is ${codecId}`);
|
||
const extraData = codecId === AUDIO_ENC_CODE.AAC ? payload.slice(2) : payload.slice(1);
|
||
audioDecoder.setCodec(codecId, decoder._opt.sampleRate, extraData);
|
||
hasInitAudioCodec = true;
|
||
} else {
|
||
decoder.debug.warn('worker', 'setCodecAudio: hasInitAudioCodec is false, codecId is ', codecId);
|
||
}
|
||
},
|
||
decodeAudio: function (payload, ts) {
|
||
const codecId = payload[0] >> 4;
|
||
if (!hasInitAudioCodec) {
|
||
decoder.setCodecAudio(payload);
|
||
} else {
|
||
// lastDecodeAudioFrameTimestamp = ts;
|
||
audioDecoder.decode(codecId === AUDIO_ENC_CODE.AAC ? payload.slice(2) : payload.slice(1), ts);
|
||
}
|
||
},
|
||
setCodecVideo: function (payload) {
|
||
const codecId = payload[0] & 0x0F;
|
||
if (payload[0] >> 4 === FRAME_TYPE.keyFrame && payload[1] === AVC_PACKET_TYPE.sequenceHeader) {
|
||
if (codecId === VIDEO_ENC_CODE.h264 || codecId === VIDEO_ENC_CODE.h265) {
|
||
decoder.debug.log('worker', `setCodecVideo: init video codec , codecId is ${codecId}`);
|
||
const extraData = payload.slice(5);
|
||
if (codecId === VIDEO_ENC_CODE.h264 && decoder._opt.useSIMD) {
|
||
// need check width and height is more than 4080。
|
||
const avcConfig = parseAVCDecoderConfigurationRecord(extraData);
|
||
if (avcConfig.codecWidth > SIMD_H264_DECODE_MAX_WIDTH || avcConfig.codecHeight > SIMD_H264_DECODE_MAX_WIDTH) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.simdH264DecodeVideoWidthIsTooLarge
|
||
});
|
||
decoder.debug.warn('worker', `setCodecVideo: SIMD H264 decode video width is too large, width is ${avcConfig.codecWidth}, height is ${avcConfig.codecHeight}`);
|
||
return;
|
||
}
|
||
}
|
||
hasInitVideoCodec = true;
|
||
videoDecoder.setCodec(codecId, extraData);
|
||
if (decoder._opt.recordType === FILE_SUFFIX.mp4) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.videoCodec,
|
||
buffer: payload,
|
||
codecId
|
||
}, [payload.buffer]);
|
||
}
|
||
} else {
|
||
decoder.debug.warn('worker', `setCodecVideo: hasInitVideoCodec is false, codecId is ${codecId} is not H264 or H265`);
|
||
}
|
||
} else {
|
||
decoder.debug.warn('worker', `decodeVideo: hasInitVideoCodec is false, codecId is ${codecId} and frameType is ${payload[0] >> 4} and packetType is ${payload[1]}`);
|
||
}
|
||
},
|
||
decodeVideo: function (payload, ts, isIFrame, cts) {
|
||
if (!hasInitVideoCodec) {
|
||
decoder.setCodecVideo(payload);
|
||
} else {
|
||
if (!isVideoFirstIFrame && isIFrame) {
|
||
isVideoFirstIFrame = true;
|
||
}
|
||
if (isVideoFirstIFrame) {
|
||
const buffer = payload.slice(5);
|
||
// lastDecodeVideoFrameTimestamp = ts;
|
||
// lastDecodeVideoFrameLocalTimestamp = now();
|
||
videoDecoder.decode(buffer, isIFrame ? 1 : 0, ts);
|
||
if (decoder._opt.isRecording && decoder._opt.recordType === FILE_SUFFIX.mp4) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.videoNalu,
|
||
buffer: buffer,
|
||
isIFrame,
|
||
ts,
|
||
cts
|
||
}, [payload.buffer]);
|
||
}
|
||
} else {
|
||
decoder.debug.warn('worker', 'decodeVideo: first frame is not iframe');
|
||
}
|
||
}
|
||
},
|
||
clearBuffer: function () {
|
||
let needClear = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
||
decoder.debug.log('worker', `clearBuffer,bufferList length is ${bufferList.length}, need clear is ${needClear}`);
|
||
if (needClear) {
|
||
bufferList = [];
|
||
}
|
||
decoder.resetAllDelay();
|
||
decoder.dropping = true;
|
||
},
|
||
dropBuffer$2: function () {
|
||
if (bufferList.length > 0) {
|
||
decoder.isPushDropping = true;
|
||
const iFrameIndex = bufferList.findIndex(bufferItem => {
|
||
return bufferItem.isIFrame === true && bufferItem.type === MEDIA_TYPE.video;
|
||
});
|
||
if (iFrameIndex >= 0) {
|
||
//
|
||
bufferList = bufferList.slice(iFrameIndex);
|
||
const iFrameItem = bufferList.shift();
|
||
const tempDelay = decoder.getDelayNotUpdateDelay(iFrameItem.ts);
|
||
decoder.doDecode(iFrameItem);
|
||
decoder.isPushDropping = false;
|
||
decoder.debug.log('worker', `dropBuffer$2() iFrameIndex is ${iFrameIndex},and bufferList length is ${bufferList.length} and tempDelay is ${tempDelay} ,delay is ${decoder.delay} `);
|
||
} else {
|
||
decoder.isPushDropping = false;
|
||
}
|
||
}
|
||
if (bufferList.length === 0) {
|
||
decoder.isPushDropping = false;
|
||
}
|
||
},
|
||
demuxM7s: function (arrayBuffer) {
|
||
const dv = new DataView(arrayBuffer);
|
||
const ts = dv.getUint32(1, false);
|
||
const type = dv.getUint8(0);
|
||
// decoder.debug.log('worker', `demuxM7s , type is ${type}`);
|
||
switch (type) {
|
||
case MEDIA_TYPE.audio:
|
||
decoder.decode(new Uint8Array(arrayBuffer, 5), {
|
||
type: MEDIA_TYPE.audio,
|
||
ts
|
||
});
|
||
break;
|
||
case MEDIA_TYPE.video:
|
||
if (dv.byteLength > 5) {
|
||
const isIFrame = dv.getUint8(5) >> 4 === 1;
|
||
if (decoder.isPlayer) {
|
||
decoder.calcNetworkDelay(ts);
|
||
if (isIFrame) {
|
||
decoder.calcIframeIntervalTimestamp(ts);
|
||
}
|
||
}
|
||
decoder.decode(new Uint8Array(arrayBuffer, 5), {
|
||
type: MEDIA_TYPE.video,
|
||
ts,
|
||
isIFrame
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
},
|
||
demuxNakedFlow: function (arrayBuffer) {
|
||
// decoder.debug.log('worker', `demuxNakedFlow, arrayBuffer length is ${arrayBuffer.byteLength}`);
|
||
// console.log('demuxNakedFlow', arrayBuffer);
|
||
nakedFlowDemuxer.dispatch(arrayBuffer);
|
||
},
|
||
calcNetworkDelay: function (dts) {
|
||
if (!(isVideoFirstIFrame && dts > 0)) {
|
||
return;
|
||
}
|
||
if (bufferStartDts === null) {
|
||
bufferStartDts = dts;
|
||
bufferStartLocalTs = now();
|
||
} else {
|
||
if (dts < bufferStartDts) {
|
||
decoder.debug.warn('worker', `calcNetworkDelay, dts is ${dts} less than bufferStartDts is ${bufferStartDts}`);
|
||
bufferStartDts = dts;
|
||
bufferStartLocalTs = now();
|
||
}
|
||
}
|
||
const diff1 = dts - bufferStartDts;
|
||
const localDiff = now() - bufferStartLocalTs;
|
||
const delay = localDiff > diff1 ? localDiff - diff1 : 0;
|
||
decoder.networkDelay = delay;
|
||
if (delay > decoder._opt.networkDelay && decoder._opt.playType === PLAY_TYPE.player) {
|
||
decoder.debug.warn('worker', `calcNetworkDelay now dts:${dts}, start dts is ${bufferStartDts} vs start is ${diff1},local diff is ${localDiff} ,delay is ${delay}`);
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerFetch,
|
||
type: EVENTS.networkDelayTimeout,
|
||
value: delay
|
||
});
|
||
}
|
||
},
|
||
calcIframeIntervalTimestamp: function (ts) {
|
||
if (preIframeTs === null) {
|
||
preIframeTs = ts;
|
||
} else {
|
||
if (preIframeTs < ts) {
|
||
const intervalTimestamp = ts - preIframeTs;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.iframeIntervalTs,
|
||
value: intervalTimestamp
|
||
});
|
||
// post 到主线程里面去。
|
||
preIframeTs = ts;
|
||
}
|
||
}
|
||
},
|
||
canVisibilityDecodeNotDrop: function () {
|
||
return decoder._opt.visibility && videoWidth * videoHeight <= 1920 * 1080;
|
||
},
|
||
isPlaybackCacheBeforeDecodeForFpsRender: function () {
|
||
return !decoder.isPlayer && decoder._opt.playbackIsCacheBeforeDecodeForFpsRender;
|
||
},
|
||
videoInfo: function (videoCode, width, height) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.videoCode,
|
||
code: videoCode
|
||
});
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.initVideo,
|
||
w: width,
|
||
h: height
|
||
});
|
||
videoWidth = width;
|
||
videoHeight = height;
|
||
if (decoder.useOffscreen()) {
|
||
decoder.offscreenCanvas = new OffscreenCanvas(width, height);
|
||
decoder.offscreenCanvasGL = decoder.offscreenCanvas.getContext("webgl");
|
||
decoder.webglObj = createWebGL(decoder.offscreenCanvasGL, decoder._opt.openWebglAlignment);
|
||
}
|
||
},
|
||
audioInfo: function (audioCode, sampleRate, channels) {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.audioCode,
|
||
code: audioCode
|
||
});
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.initAudio,
|
||
sampleRate: sampleRate,
|
||
channels: channels
|
||
});
|
||
audioChannels = channels;
|
||
},
|
||
yuvData: function (yuv, ts) {
|
||
const size = videoWidth * videoHeight * 3 / 2;
|
||
let out = Module.HEAPU8.subarray(yuv, yuv + size);
|
||
let data = new Uint8Array(out);
|
||
// newDecodedVideoFrameTimestamp = ts;
|
||
// newDecodedVideoFrameLocalTimestamp = now();
|
||
if (decoder.useOffscreen()) {
|
||
decoder.webglObj.renderYUV(videoWidth, videoHeight, data);
|
||
let image_bitmap = decoder.offscreenCanvas.transferToImageBitmap();
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.render,
|
||
buffer: image_bitmap,
|
||
delay: decoder.delay,
|
||
ts
|
||
}, [image_bitmap]);
|
||
} else {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.render,
|
||
output: data,
|
||
delay: decoder.delay,
|
||
ts
|
||
}, [data.buffer]);
|
||
}
|
||
},
|
||
pcmData: function (data, len, ts) {
|
||
let frameCount = len;
|
||
let origin = [];
|
||
let start = 0;
|
||
let audioBufferSize = decoder._opt.audioBufferSize;
|
||
for (let channel = 0; channel < 2; channel++) {
|
||
let fp = Module.HEAPU32[(data >> 2) + channel] >> 2;
|
||
origin[channel] = Module.HEAPF32.subarray(fp, fp + frameCount);
|
||
}
|
||
if (audioRemain) {
|
||
len = audioBufferSize - audioRemain;
|
||
if (frameCount >= len) {
|
||
audioOutputArray[0] = Float32Array.of(...tempAudioBuffer[0], ...origin[0].subarray(0, len));
|
||
if (audioChannels == 2) {
|
||
audioOutputArray[1] = Float32Array.of(...tempAudioBuffer[1], ...origin[1].subarray(0, len));
|
||
}
|
||
// newDecodedAudioFrameTimestamp = ts;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.playAudio,
|
||
buffer: audioOutputArray,
|
||
ts
|
||
}, audioOutputArray.map(x => x.buffer));
|
||
start = len;
|
||
frameCount -= len;
|
||
} else {
|
||
audioRemain += frameCount;
|
||
tempAudioBuffer[0] = Float32Array.of(...tempAudioBuffer[0], ...origin[0]);
|
||
if (audioChannels == 2) {
|
||
tempAudioBuffer[1] = Float32Array.of(...tempAudioBuffer[1], ...origin[1]);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
for (audioRemain = frameCount; audioRemain >= audioBufferSize; audioRemain -= audioBufferSize) {
|
||
audioOutputArray[0] = origin[0].slice(start, start += audioBufferSize);
|
||
if (audioChannels == 2) {
|
||
audioOutputArray[1] = origin[1].slice(start - audioBufferSize, start);
|
||
}
|
||
// newDecodedAudioFrameTimestamp = ts;
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.playAudio,
|
||
buffer: audioOutputArray,
|
||
ts
|
||
}, audioOutputArray.map(x => x.buffer));
|
||
}
|
||
if (audioRemain) {
|
||
tempAudioBuffer[0] = origin[0].slice(start);
|
||
if (audioChannels == 2) {
|
||
tempAudioBuffer[1] = origin[1].slice(start);
|
||
}
|
||
}
|
||
},
|
||
sendWebsocketMessage: function (message) {
|
||
if (socket) {
|
||
if (socket.readyState === WEBSOCKET_STATUS_CODE.open) {
|
||
socket.send(message);
|
||
} else {
|
||
decoder.debug.error('worker', 'socket is not open');
|
||
}
|
||
} else {
|
||
decoder.debug.error('worker', 'socket is null');
|
||
}
|
||
},
|
||
timeEnd: function () {
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.workerEnd
|
||
});
|
||
}
|
||
};
|
||
decoder.debug = new Debug(decoder);
|
||
let audioDecoder = new Module.AudioDecoder(decoder);
|
||
let videoDecoder = new Module.VideoDecoder(decoder);
|
||
postMessage({
|
||
cmd: WORKER_CMD_TYPE.init
|
||
});
|
||
self.onmessage = function (event) {
|
||
let msg = event.data;
|
||
switch (msg.cmd) {
|
||
case WORKER_SEND_TYPE.init:
|
||
try {
|
||
decoder._opt = Object.assign(decoder._opt, JSON.parse(msg.opt));
|
||
} catch (e) {}
|
||
decoder.init();
|
||
break;
|
||
case WORKER_SEND_TYPE.decode:
|
||
decoder.pushBuffer(msg.buffer, msg.options);
|
||
break;
|
||
case WORKER_SEND_TYPE.audioDecode:
|
||
decoder.decodeAudio(msg.buffer, msg.ts);
|
||
break;
|
||
case WORKER_SEND_TYPE.videoDecode:
|
||
decoder.decodeVideo(msg.buffer, msg.ts, msg.isIFrame);
|
||
break;
|
||
case WORKER_SEND_TYPE.clearBuffer:
|
||
decoder.clearBuffer(msg.needClear);
|
||
break;
|
||
case WORKER_SEND_TYPE.fetchStream:
|
||
decoder.fetchStream(msg.url, JSON.parse(msg.opt));
|
||
break;
|
||
case WORKER_SEND_TYPE.close:
|
||
decoder.close();
|
||
break;
|
||
case WORKER_SEND_TYPE.updateConfig:
|
||
decoder._opt[msg.key] = msg.value;
|
||
if (msg.key === 'playbackRate') {
|
||
if (decoder.isPlaybackCacheBeforeDecodeForFpsRender()) {
|
||
decoder.playbackCacheLoop();
|
||
}
|
||
}
|
||
break;
|
||
case WORKER_SEND_TYPE.sendWsMessage:
|
||
decoder.sendWebsocketMessage(msg.message);
|
||
break;
|
||
}
|
||
};
|
||
}
|
||
|
||
decoderProSimd.postRun = function () {
|
||
workerPostRun(decoderProSimd);
|
||
};
|
||
|
||
}));
|
||
|