|
var JSPlayerModule = (function() {
|
var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
|
|
return (
|
function(JSPlayerModule) {
|
JSPlayerModule = JSPlayerModule || {};
|
|
|
|
// Support for growable heap + pthreads, where the buffer may change, so JS views
|
// must be updated.
|
function GROWABLE_HEAP_I8() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAP8;
|
}
|
function GROWABLE_HEAP_U8() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAPU8;
|
}
|
function GROWABLE_HEAP_I16() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAP16;
|
}
|
function GROWABLE_HEAP_U16() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAPU16;
|
}
|
function GROWABLE_HEAP_I32() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAP32;
|
}
|
function GROWABLE_HEAP_U32() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAPU32;
|
}
|
function GROWABLE_HEAP_F32() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAPF32;
|
}
|
function GROWABLE_HEAP_F64() {
|
if (wasmMemory.buffer != buffer) {
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
}
|
return HEAPF64;
|
}
|
|
var Module = typeof JSPlayerModule !== "undefined" ? JSPlayerModule : {};
|
|
var readyPromiseResolve, readyPromiseReject;
|
|
Module["ready"] = new Promise(function(resolve, reject) {
|
readyPromiseResolve = resolve;
|
readyPromiseReject = reject;
|
});
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetPort")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetPort", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetPort on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetPort", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetPort on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetStreamOpenMode")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetStreamOpenMode", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetStreamOpenMode on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetStreamOpenMode", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetStreamOpenMode on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_OpenStream")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_OpenStream", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_OpenStream on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_OpenStream", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_OpenStream on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDecCallBack")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecCallBack", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDecCallBack on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecCallBack", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDecCallBack on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDisplayCallBack")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDisplayCallBack", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDisplayCallBack on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDisplayCallBack", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDisplayCallBack on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetFrameInfoCallBack")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetFrameInfoCallBack", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetFrameInfoCallBack on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetFrameInfoCallBack", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetFrameInfoCallBack on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDecCBStream")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecCBStream", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDecCBStream on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecCBStream", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDecCBStream on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_Play")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Play", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_Play on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Play", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_Play on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_InputData")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_InputData", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_InputData on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_InputData", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_InputData on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_Stop")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Stop", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_Stop on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Stop", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_Stop on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_CloseStream")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_CloseStream", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_CloseStream on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_CloseStream", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_CloseStream on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_FreePort")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_FreePort", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_FreePort on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_FreePort", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_FreePort on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDecodeFrameType")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecodeFrameType", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDecodeFrameType on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecodeFrameType", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDecodeFrameType on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_PlaySound")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_PlaySound", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_PlaySound on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_PlaySound", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_PlaySound on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetSecretKey")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetSecretKey", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetSecretKey on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetSecretKey", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetSecretKey on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetJPEG")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetJPEG", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetJPEG on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetJPEG", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetJPEG on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetBMP")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetBMP", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetBMP on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetBMP", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetBMP on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_StopSound")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_StopSound", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_StopSound on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_StopSound", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_StopSound on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetSDKVersion")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetSDKVersion", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetSDKVersion on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetSDKVersion", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetSDKVersion on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetBuildDate")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetBuildDate", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetBuildDate on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetBuildDate", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetBuildDate on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetLastError")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetLastError", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetLastError on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetLastError", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetLastError on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_Fast")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Fast", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_Fast on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Fast", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_Fast on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_Slow")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Slow", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_Slow on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Slow", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_Slow on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetIFrameDecInterval")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetIFrameDecInterval", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetIFrameDecInterval on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetIFrameDecInterval", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetIFrameDecInterval on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDecodeThread")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecodeThread", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDecodeThread on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecodeThread", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDecodeThread on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_Pause")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Pause", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_Pause on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_Pause", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_Pause on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_OneByOne")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_OneByOne", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_OneByOne on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_OneByOne", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_OneByOne on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetVolume")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetVolume", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetVolume on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetVolume", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetVolume on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetVolume")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetVolume", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetVolume on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetVolume", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetVolume on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDisplayRegion")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDisplayRegion", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDisplayRegion on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDisplayRegion", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDisplayRegion on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetPrintLogFlag")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetPrintLogFlag", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetPrintLogFlag on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetPrintLogFlag", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetPrintLogFlag on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_RenderPrivateData")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_RenderPrivateData", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_RenderPrivateData on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_RenderPrivateData", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_RenderPrivateData on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_RenderPrivateDataEx")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_RenderPrivateDataEx", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_RenderPrivateDataEx on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_RenderPrivateDataEx", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_RenderPrivateDataEx on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetCanvasSize")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetCanvasSize", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetCanvasSize on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetCanvasSize", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetCanvasSize on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDisplayBuf")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDisplayBuf", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDisplayBuf on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDisplayBuf", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDisplayBuf on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetSourceBufferRemain")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetSourceBufferRemain", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetSourceBufferRemain on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetSourceBufferRemain", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetSourceBufferRemain on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetBufferValue")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetBufferValue", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetBufferValue on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetBufferValue", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetBufferValue on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_ReversePlay")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_ReversePlay", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_ReversePlay on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_ReversePlay", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_ReversePlay on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetDecodeThreadNum")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecodeThreadNum", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetDecodeThreadNum on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetDecodeThreadNum", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetDecodeThreadNum on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_GetCanvasSize")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetCanvasSize", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_GetCanvasSize on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_GetCanvasSize", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_GetCanvasSize on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_DisplayLostFrames")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_DisplayLostFrames", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_DisplayLostFrames on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_DisplayLostFrames", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_DisplayLostFrames on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetANRParam")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetANRParam", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetANRParam on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetANRParam", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetANRParam on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetAntialias")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetAntialias", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetAntialias on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetAntialias", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetAntialias on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SyncToAudio")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SyncToAudio", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SyncToAudio on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SyncToAudio", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SyncToAudio on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetResampleValue")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetResampleValue", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetResampleValue on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetResampleValue", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetResampleValue on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_JSPlayM4_SetAudioThreadModel")) {
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetAudioThreadModel", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _JSPlayM4_SetAudioThreadModel on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_JSPlayM4_SetAudioThreadModel", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _JSPlayM4_SetAudioThreadModel on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_stack_get_end")) {
|
Object.defineProperty(Module["ready"], "_emscripten_stack_get_end", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_stack_get_end on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_stack_get_end", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_stack_get_end on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_stack_get_free")) {
|
Object.defineProperty(Module["ready"], "_emscripten_stack_get_free", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_stack_get_free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_stack_get_free", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_stack_get_free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_stack_init")) {
|
Object.defineProperty(Module["ready"], "_emscripten_stack_init", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_stack_init on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_stack_init", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_stack_init on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackSave")) {
|
Object.defineProperty(Module["ready"], "_stackSave", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _stackSave on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_stackSave", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _stackSave on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackRestore")) {
|
Object.defineProperty(Module["ready"], "_stackRestore", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _stackRestore on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_stackRestore", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _stackRestore on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_stackAlloc")) {
|
Object.defineProperty(Module["ready"], "_stackAlloc", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _stackAlloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_stackAlloc", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _stackAlloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "___wasm_call_ctors")) {
|
Object.defineProperty(Module["ready"], "___wasm_call_ctors", {
|
configurable: true,
|
get: function() {
|
abort("You are getting ___wasm_call_ctors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "___wasm_call_ctors", {
|
configurable: true,
|
set: function() {
|
abort("You are setting ___wasm_call_ctors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_fflush")) {
|
Object.defineProperty(Module["ready"], "_fflush", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _fflush on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_fflush", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _fflush on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "___errno_location")) {
|
Object.defineProperty(Module["ready"], "___errno_location", {
|
configurable: true,
|
get: function() {
|
abort("You are getting ___errno_location on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "___errno_location", {
|
configurable: true,
|
set: function() {
|
abort("You are setting ___errno_location on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "___emscripten_pthread_data_constructor")) {
|
Object.defineProperty(Module["ready"], "___emscripten_pthread_data_constructor", {
|
configurable: true,
|
get: function() {
|
abort("You are getting ___emscripten_pthread_data_constructor on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "___emscripten_pthread_data_constructor", {
|
configurable: true,
|
set: function() {
|
abort("You are setting ___emscripten_pthread_data_constructor on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "___pthread_tsd_run_dtors")) {
|
Object.defineProperty(Module["ready"], "___pthread_tsd_run_dtors", {
|
configurable: true,
|
get: function() {
|
abort("You are getting ___pthread_tsd_run_dtors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "___pthread_tsd_run_dtors", {
|
configurable: true,
|
set: function() {
|
abort("You are setting ___pthread_tsd_run_dtors on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__emscripten_call_on_thread")) {
|
Object.defineProperty(Module["ready"], "__emscripten_call_on_thread", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __emscripten_call_on_thread on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__emscripten_call_on_thread", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __emscripten_call_on_thread on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__emscripten_do_dispatch_to_thread")) {
|
Object.defineProperty(Module["ready"], "__emscripten_do_dispatch_to_thread", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __emscripten_do_dispatch_to_thread on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__emscripten_do_dispatch_to_thread", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __emscripten_do_dispatch_to_thread on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__emscripten_main_thread_futex")) {
|
Object.defineProperty(Module["ready"], "__emscripten_main_thread_futex", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __emscripten_main_thread_futex on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__emscripten_main_thread_futex", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __emscripten_main_thread_futex on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__emscripten_thread_init")) {
|
Object.defineProperty(Module["ready"], "__emscripten_thread_init", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __emscripten_thread_init on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__emscripten_thread_init", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __emscripten_thread_init on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_current_thread_process_queued_calls")) {
|
Object.defineProperty(Module["ready"], "_emscripten_current_thread_process_queued_calls", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_current_thread_process_queued_calls on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_current_thread_process_queued_calls", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_current_thread_process_queued_calls on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__emscripten_allow_main_runtime_queued_calls")) {
|
Object.defineProperty(Module["ready"], "__emscripten_allow_main_runtime_queued_calls", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __emscripten_allow_main_runtime_queued_calls on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__emscripten_allow_main_runtime_queued_calls", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __emscripten_allow_main_runtime_queued_calls on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_futex_wake")) {
|
Object.defineProperty(Module["ready"], "_emscripten_futex_wake", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_futex_wake on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_futex_wake", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_futex_wake on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_get_global_libc")) {
|
Object.defineProperty(Module["ready"], "_emscripten_get_global_libc", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_get_global_libc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_get_global_libc", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_get_global_libc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_main_browser_thread_id")) {
|
Object.defineProperty(Module["ready"], "_emscripten_main_browser_thread_id", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_main_browser_thread_id on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_main_browser_thread_id", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_main_browser_thread_id on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_main_thread_process_queued_calls")) {
|
Object.defineProperty(Module["ready"], "_emscripten_main_thread_process_queued_calls", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_main_thread_process_queued_calls on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_main_thread_process_queued_calls", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_main_thread_process_queued_calls on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_register_main_browser_thread_id")) {
|
Object.defineProperty(Module["ready"], "_emscripten_register_main_browser_thread_id", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_register_main_browser_thread_id on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_register_main_browser_thread_id", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_register_main_browser_thread_id on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_run_in_main_runtime_thread_js")) {
|
Object.defineProperty(Module["ready"], "_emscripten_run_in_main_runtime_thread_js", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_run_in_main_runtime_thread_js on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_run_in_main_runtime_thread_js", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_run_in_main_runtime_thread_js on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_stack_set_limits")) {
|
Object.defineProperty(Module["ready"], "_emscripten_stack_set_limits", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_stack_set_limits on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_stack_set_limits", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_stack_set_limits on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_sync_run_in_main_thread_2")) {
|
Object.defineProperty(Module["ready"], "_emscripten_sync_run_in_main_thread_2", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_sync_run_in_main_thread_2 on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_sync_run_in_main_thread_2", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_sync_run_in_main_thread_2 on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_sync_run_in_main_thread_4")) {
|
Object.defineProperty(Module["ready"], "_emscripten_sync_run_in_main_thread_4", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_sync_run_in_main_thread_4 on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_sync_run_in_main_thread_4", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_sync_run_in_main_thread_4 on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_tls_init")) {
|
Object.defineProperty(Module["ready"], "_emscripten_tls_init", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_tls_init on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_tls_init", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_tls_init on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_pthread_self")) {
|
Object.defineProperty(Module["ready"], "_pthread_self", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _pthread_self on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_pthread_self", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _pthread_self on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_memalign")) {
|
Object.defineProperty(Module["ready"], "_memalign", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _memalign on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_memalign", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _memalign on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_proxy_main")) {
|
Object.defineProperty(Module["ready"], "_emscripten_proxy_main", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_proxy_main on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_proxy_main", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_proxy_main on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "establishStackSpace")) {
|
Object.defineProperty(Module["ready"], "establishStackSpace", {
|
configurable: true,
|
get: function() {
|
abort("You are getting establishStackSpace on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "establishStackSpace", {
|
configurable: true,
|
set: function() {
|
abort("You are setting establishStackSpace on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "invokeEntryPoint")) {
|
Object.defineProperty(Module["ready"], "invokeEntryPoint", {
|
configurable: true,
|
get: function() {
|
abort("You are getting invokeEntryPoint on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "invokeEntryPoint", {
|
configurable: true,
|
set: function() {
|
abort("You are setting invokeEntryPoint on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "keepRuntimeAlive")) {
|
Object.defineProperty(Module["ready"], "keepRuntimeAlive", {
|
configurable: true,
|
get: function() {
|
abort("You are getting keepRuntimeAlive on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "keepRuntimeAlive", {
|
configurable: true,
|
set: function() {
|
abort("You are setting keepRuntimeAlive on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_malloc")) {
|
Object.defineProperty(Module["ready"], "_malloc", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _malloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_malloc", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _malloc on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_free")) {
|
Object.defineProperty(Module["ready"], "_free", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_free", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _free on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_tzname")) {
|
Object.defineProperty(Module["ready"], "__get_tzname", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __get_tzname on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__get_tzname", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __get_tzname on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_daylight")) {
|
Object.defineProperty(Module["ready"], "__get_daylight", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __get_daylight on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__get_daylight", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __get_daylight on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "__get_timezone")) {
|
Object.defineProperty(Module["ready"], "__get_timezone", {
|
configurable: true,
|
get: function() {
|
abort("You are getting __get_timezone on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "__get_timezone", {
|
configurable: true,
|
set: function() {
|
abort("You are setting __get_timezone on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_webgl_make_context_current")) {
|
Object.defineProperty(Module["ready"], "_emscripten_webgl_make_context_current", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_webgl_make_context_current on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_webgl_make_context_current", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_webgl_make_context_current on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_emscripten_webgl_get_current_context")) {
|
Object.defineProperty(Module["ready"], "_emscripten_webgl_get_current_context", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _emscripten_webgl_get_current_context on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_emscripten_webgl_get_current_context", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _emscripten_webgl_get_current_context on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "_setThrew")) {
|
Object.defineProperty(Module["ready"], "_setThrew", {
|
configurable: true,
|
get: function() {
|
abort("You are getting _setThrew on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "_setThrew", {
|
configurable: true,
|
set: function() {
|
abort("You are setting _setThrew on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module["ready"], "onRuntimeInitialized")) {
|
Object.defineProperty(Module["ready"], "onRuntimeInitialized", {
|
configurable: true,
|
get: function() {
|
abort("You are getting onRuntimeInitialized on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
Object.defineProperty(Module["ready"], "onRuntimeInitialized", {
|
configurable: true,
|
set: function() {
|
abort("You are setting onRuntimeInitialized on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js");
|
}
|
});
|
}
|
|
var moduleOverrides = {};
|
|
var key;
|
|
for (key in Module) {
|
if (Module.hasOwnProperty(key)) {
|
moduleOverrides[key] = Module[key];
|
}
|
}
|
|
var arguments_ = [];
|
|
var thisProgram = "./this.program";
|
|
var quit_ = function(status, toThrow) {
|
throw toThrow;
|
};
|
|
var ENVIRONMENT_IS_WEB = false;
|
|
var ENVIRONMENT_IS_WORKER = false;
|
|
var ENVIRONMENT_IS_NODE = false;
|
|
var ENVIRONMENT_IS_SHELL = false;
|
|
ENVIRONMENT_IS_WEB = typeof window === "object";
|
|
ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
|
|
ENVIRONMENT_IS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string";
|
|
ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
|
|
if (Module["ENVIRONMENT"]) {
|
throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -s ENVIRONMENT=web or -s ENVIRONMENT=node)");
|
}
|
|
var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
buffer = Module["buffer"];
|
}
|
|
var scriptDirectory = "";
|
|
function locateFile(path) {
|
if (Module["locateFile"]) {
|
return Module["locateFile"](path, scriptDirectory);
|
}
|
return scriptDirectory + path;
|
}
|
|
var read_, readAsync, readBinary, setWindowTitle;
|
|
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 (_scriptDir) {
|
scriptDirectory = _scriptDir;
|
}
|
if (scriptDirectory.indexOf("blob:") !== 0) {
|
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1);
|
} else {
|
scriptDirectory = "";
|
}
|
if (!(typeof window === "object" || typeof importScripts === "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
|
{
|
read_ = function(url) {
|
var xhr = new XMLHttpRequest();
|
xhr.open("GET", url, false);
|
xhr.send(null);
|
return xhr.responseText;
|
};
|
if (ENVIRONMENT_IS_WORKER) {
|
readBinary = function(url) {
|
var xhr = new XMLHttpRequest();
|
xhr.open("GET", url, false);
|
xhr.responseType = "arraybuffer";
|
xhr.send(null);
|
return new Uint8Array(xhr.response);
|
};
|
}
|
readAsync = function(url, onload, onerror) {
|
var xhr = new XMLHttpRequest();
|
xhr.open("GET", url, true);
|
xhr.responseType = "arraybuffer";
|
xhr.onload = function() {
|
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
|
onload(xhr.response);
|
return;
|
}
|
onerror();
|
};
|
xhr.onerror = onerror;
|
xhr.send(null);
|
};
|
}
|
setWindowTitle = function(title) {
|
document.title = title;
|
};
|
} else {
|
throw new Error("environment detection error");
|
}
|
|
var out = Module["print"] || console.log.bind(console);
|
|
var err = Module["printErr"] || console.warn.bind(console);
|
|
for (key in moduleOverrides) {
|
if (moduleOverrides.hasOwnProperty(key)) {
|
Module[key] = moduleOverrides[key];
|
}
|
}
|
|
moduleOverrides = null;
|
|
if (Module["arguments"]) arguments_ = Module["arguments"];
|
|
if (!Object.getOwnPropertyDescriptor(Module, "arguments")) {
|
Object.defineProperty(Module, "arguments", {
|
configurable: true,
|
get: function() {
|
abort("Module.arguments has been replaced with plain arguments_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
|
|
if (!Object.getOwnPropertyDescriptor(Module, "thisProgram")) {
|
Object.defineProperty(Module, "thisProgram", {
|
configurable: true,
|
get: function() {
|
abort("Module.thisProgram has been replaced with plain thisProgram (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
if (Module["quit"]) quit_ = Module["quit"];
|
|
if (!Object.getOwnPropertyDescriptor(Module, "quit")) {
|
Object.defineProperty(Module, "quit", {
|
configurable: true,
|
get: function() {
|
abort("Module.quit has been replaced with plain quit_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
assert(typeof Module["memoryInitializerPrefixURL"] === "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
|
|
assert(typeof Module["pthreadMainPrefixURL"] === "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
|
|
assert(typeof Module["cdInitializerPrefixURL"] === "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
|
|
assert(typeof Module["filePackagePrefixURL"] === "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
|
|
assert(typeof Module["read"] === "undefined", "Module.read option was removed (modify read_ in JS)");
|
|
assert(typeof Module["readAsync"] === "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
|
|
assert(typeof Module["readBinary"] === "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
|
|
assert(typeof Module["setWindowTitle"] === "undefined", "Module.setWindowTitle option was removed (modify setWindowTitle in JS)");
|
|
assert(typeof Module["TOTAL_MEMORY"] === "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
|
|
if (!Object.getOwnPropertyDescriptor(Module, "read")) {
|
Object.defineProperty(Module, "read", {
|
configurable: true,
|
get: function() {
|
abort("Module.read has been replaced with plain read_ (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readAsync")) {
|
Object.defineProperty(Module, "readAsync", {
|
configurable: true,
|
get: function() {
|
abort("Module.readAsync has been replaced with plain readAsync (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readBinary")) {
|
Object.defineProperty(Module, "readBinary", {
|
configurable: true,
|
get: function() {
|
abort("Module.readBinary has been replaced with plain readBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setWindowTitle")) {
|
Object.defineProperty(Module, "setWindowTitle", {
|
configurable: true,
|
get: function() {
|
abort("Module.setWindowTitle has been replaced with plain setWindowTitle (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
|
|
var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
|
|
var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
|
|
var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
|
|
assert(ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER || ENVIRONMENT_IS_NODE, "Pthreads do not work in this environment yet (need Web Workers, or an alternative to them)");
|
|
var STACK_ALIGN = 16;
|
|
function alignMemory(size, factor) {
|
if (!factor) factor = STACK_ALIGN;
|
return Math.ceil(size / factor) * factor;
|
}
|
|
function getNativeTypeSize(type) {
|
switch (type) {
|
case "i1":
|
case "i8":
|
return 1;
|
|
case "i16":
|
return 2;
|
|
case "i32":
|
return 4;
|
|
case "i64":
|
return 8;
|
|
case "float":
|
return 4;
|
|
case "double":
|
return 8;
|
|
default:
|
{
|
if (type[type.length - 1] === "*") {
|
return 4;
|
} else if (type[0] === "i") {
|
var bits = Number(type.substr(1));
|
assert(bits % 8 === 0, "getNativeTypeSize invalid bits " + bits + ", type " + type);
|
return bits / 8;
|
} else {
|
return 0;
|
}
|
}
|
}
|
}
|
|
function warnOnce(text) {
|
if (!warnOnce.shown) warnOnce.shown = {};
|
if (!warnOnce.shown[text]) {
|
warnOnce.shown[text] = 1;
|
err(text);
|
}
|
}
|
|
function convertJsFunctionToWasm(func, sig) {
|
if (typeof WebAssembly.Function === "function") {
|
var typeNames = {
|
"i": "i32",
|
"j": "i64",
|
"f": "f32",
|
"d": "f64"
|
};
|
var type = {
|
parameters: [],
|
results: sig[0] == "v" ? [] : [ typeNames[sig[0]] ]
|
};
|
for (var i = 1; i < sig.length; ++i) {
|
type.parameters.push(typeNames[sig[i]]);
|
}
|
return new WebAssembly.Function(type, func);
|
}
|
var typeSection = [ 1, 0, 1, 96 ];
|
var sigRet = sig.slice(0, 1);
|
var sigParam = sig.slice(1);
|
var typeCodes = {
|
"i": 127,
|
"j": 126,
|
"f": 125,
|
"d": 124
|
};
|
typeSection.push(sigParam.length);
|
for (var i = 0; i < sigParam.length; ++i) {
|
typeSection.push(typeCodes[sigParam[i]]);
|
}
|
if (sigRet == "v") {
|
typeSection.push(0);
|
} else {
|
typeSection = typeSection.concat([ 1, typeCodes[sigRet] ]);
|
}
|
typeSection[1] = typeSection.length - 2;
|
var bytes = new Uint8Array([ 0, 97, 115, 109, 1, 0, 0, 0 ].concat(typeSection, [ 2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0 ]));
|
var module = new WebAssembly.Module(bytes);
|
var instance = new WebAssembly.Instance(module, {
|
"e": {
|
"f": func
|
}
|
});
|
var wrappedFunc = instance.exports["f"];
|
return wrappedFunc;
|
}
|
|
var freeTableIndexes = [];
|
|
var functionsInTableMap;
|
|
function getEmptyTableSlot() {
|
if (freeTableIndexes.length) {
|
return freeTableIndexes.pop();
|
}
|
try {
|
wasmTable.grow(1);
|
} catch (err) {
|
if (!(err instanceof RangeError)) {
|
throw err;
|
}
|
throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
|
}
|
return wasmTable.length - 1;
|
}
|
|
function addFunctionWasm(func, sig) {
|
if (!functionsInTableMap) {
|
functionsInTableMap = new WeakMap();
|
for (var i = 0; i < wasmTable.length; i++) {
|
var item = wasmTable.get(i);
|
if (item) {
|
functionsInTableMap.set(item, i);
|
}
|
}
|
}
|
if (functionsInTableMap.has(func)) {
|
return functionsInTableMap.get(func);
|
}
|
var ret = getEmptyTableSlot();
|
try {
|
wasmTable.set(ret, func);
|
} catch (err) {
|
if (!(err instanceof TypeError)) {
|
throw err;
|
}
|
assert(typeof sig !== "undefined", "Missing signature argument to addFunction: " + func);
|
var wrapped = convertJsFunctionToWasm(func, sig);
|
wasmTable.set(ret, wrapped);
|
}
|
functionsInTableMap.set(func, ret);
|
return ret;
|
}
|
|
function removeFunction(index) {
|
functionsInTableMap.delete(wasmTable.get(index));
|
freeTableIndexes.push(index);
|
}
|
|
function addFunction(func, sig) {
|
assert(typeof func !== "undefined");
|
return addFunctionWasm(func, sig);
|
}
|
|
function makeBigInt(low, high, unsigned) {
|
return unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
|
}
|
|
var tempRet0 = 0;
|
|
var setTempRet0 = function(value) {
|
tempRet0 = value;
|
};
|
|
var getTempRet0 = function() {
|
return tempRet0;
|
};
|
|
function getCompilerSetting(name) {
|
throw "You must build with -s RETAIN_COMPILER_SETTINGS=1 for getCompilerSetting or emscripten_get_compiler_setting to work";
|
}
|
|
var Atomics_load = Atomics.load;
|
|
var Atomics_store = Atomics.store;
|
|
var Atomics_compareExchange = Atomics.compareExchange;
|
|
var wasmBinary;
|
|
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
|
|
if (!Object.getOwnPropertyDescriptor(Module, "wasmBinary")) {
|
Object.defineProperty(Module, "wasmBinary", {
|
configurable: true,
|
get: function() {
|
abort("Module.wasmBinary has been replaced with plain wasmBinary (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
var noExitRuntime = Module["noExitRuntime"] || true;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "noExitRuntime")) {
|
Object.defineProperty(Module, "noExitRuntime", {
|
configurable: true,
|
get: function() {
|
abort("Module.noExitRuntime has been replaced with plain noExitRuntime (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
if (typeof WebAssembly !== "object") {
|
abort("no native wasm support detected");
|
}
|
|
function setValue(ptr, value, type, noSafe) {
|
type = type || "i8";
|
if (type.charAt(type.length - 1) === "*") type = "i32";
|
switch (type) {
|
case "i1":
|
GROWABLE_HEAP_I8()[ptr >> 0] = value;
|
break;
|
|
case "i8":
|
GROWABLE_HEAP_I8()[ptr >> 0] = value;
|
break;
|
|
case "i16":
|
GROWABLE_HEAP_I16()[ptr >> 1] = value;
|
break;
|
|
case "i32":
|
GROWABLE_HEAP_I32()[ptr >> 2] = value;
|
break;
|
|
case "i64":
|
tempI64 = [ value >>> 0, (tempDouble = value, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ],
|
GROWABLE_HEAP_I32()[ptr >> 2] = tempI64[0], GROWABLE_HEAP_I32()[ptr + 4 >> 2] = tempI64[1];
|
break;
|
|
case "float":
|
GROWABLE_HEAP_F32()[ptr >> 2] = value;
|
break;
|
|
case "double":
|
GROWABLE_HEAP_F64()[ptr >> 3] = value;
|
break;
|
|
default:
|
abort("invalid type for setValue: " + type);
|
}
|
}
|
|
function getValue(ptr, type, noSafe) {
|
type = type || "i8";
|
if (type.charAt(type.length - 1) === "*") type = "i32";
|
switch (type) {
|
case "i1":
|
return GROWABLE_HEAP_I8()[ptr >> 0];
|
|
case "i8":
|
return GROWABLE_HEAP_I8()[ptr >> 0];
|
|
case "i16":
|
return GROWABLE_HEAP_I16()[ptr >> 1];
|
|
case "i32":
|
return GROWABLE_HEAP_I32()[ptr >> 2];
|
|
case "i64":
|
return GROWABLE_HEAP_I32()[ptr >> 2];
|
|
case "float":
|
return GROWABLE_HEAP_F32()[ptr >> 2];
|
|
case "double":
|
return GROWABLE_HEAP_F64()[ptr >> 3];
|
|
default:
|
abort("invalid type for getValue: " + type);
|
}
|
return null;
|
}
|
|
var wasmMemory;
|
|
var wasmModule;
|
|
var ABORT = false;
|
|
var EXITSTATUS;
|
|
function assert(condition, text) {
|
if (!condition) {
|
abort("Assertion failed: " + text);
|
}
|
}
|
|
function getCFunc(ident) {
|
var func = Module["_" + ident];
|
assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
|
return func;
|
}
|
|
function ccall(ident, returnType, argTypes, args, opts) {
|
var toC = {
|
"string": function(str) {
|
var ret = 0;
|
if (str !== null && str !== undefined && str !== 0) {
|
var len = (str.length << 2) + 1;
|
ret = stackAlloc(len);
|
stringToUTF8(str, ret, len);
|
}
|
return ret;
|
},
|
"array": function(arr) {
|
var ret = stackAlloc(arr.length);
|
writeArrayToMemory(arr, ret);
|
return ret;
|
}
|
};
|
function convertReturnValue(ret) {
|
if (returnType === "string") return UTF8ToString(ret);
|
if (returnType === "boolean") return Boolean(ret);
|
return ret;
|
}
|
var func = getCFunc(ident);
|
var cArgs = [];
|
var stack = 0;
|
assert(returnType !== "array", 'Return type should not be "array".');
|
if (args) {
|
for (var i = 0; i < args.length; i++) {
|
var converter = toC[argTypes[i]];
|
if (converter) {
|
if (stack === 0) stack = stackSave();
|
cArgs[i] = converter(args[i]);
|
} else {
|
cArgs[i] = args[i];
|
}
|
}
|
}
|
var ret = func.apply(null, cArgs);
|
ret = convertReturnValue(ret);
|
if (stack !== 0) stackRestore(stack);
|
return ret;
|
}
|
|
function cwrap(ident, returnType, argTypes, opts) {
|
return function() {
|
return ccall(ident, returnType, argTypes, arguments, opts);
|
};
|
}
|
|
var ALLOC_NORMAL = 0;
|
|
var ALLOC_STACK = 1;
|
|
function allocate(slab, allocator) {
|
var ret;
|
assert(typeof allocator === "number", "allocate no longer takes a type argument");
|
assert(typeof slab !== "number", "allocate no longer takes a number as arg0");
|
if (allocator == ALLOC_STACK) {
|
ret = stackAlloc(slab.length);
|
} else {
|
ret = _malloc(slab.length);
|
}
|
if (slab.subarray || slab.slice) {
|
GROWABLE_HEAP_U8().set(slab, ret);
|
} else {
|
GROWABLE_HEAP_U8().set(new Uint8Array(slab), ret);
|
}
|
return ret;
|
}
|
|
function UTF8ArrayToString(heap, idx, maxBytesToRead) {
|
var endIdx = idx + maxBytesToRead;
|
var str = "";
|
while (!(idx >= endIdx)) {
|
var u0 = heap[idx++];
|
if (!u0) return str;
|
if (!(u0 & 128)) {
|
str += String.fromCharCode(u0);
|
continue;
|
}
|
var u1 = heap[idx++] & 63;
|
if ((u0 & 224) == 192) {
|
str += String.fromCharCode((u0 & 31) << 6 | u1);
|
continue;
|
}
|
var u2 = heap[idx++] & 63;
|
if ((u0 & 240) == 224) {
|
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
|
} else {
|
if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte 0x" + u0.toString(16) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
|
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[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(GROWABLE_HEAP_U8(), 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;
|
if (u >= 2097152) warnOnce("Invalid Unicode code point 0x" + u.toString(16) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x1FFFFF).");
|
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) {
|
assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
|
return stringToUTF8Array(str, GROWABLE_HEAP_U8(), outPtr, maxBytesToWrite);
|
}
|
|
function lengthBytesUTF8(str) {
|
var len = 0;
|
for (var i = 0; i < str.length; ++i) {
|
var u = str.charCodeAt(i);
|
if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
|
if (u <= 127) ++len; else if (u <= 2047) len += 2; else if (u <= 65535) len += 3; else len += 4;
|
}
|
return len;
|
}
|
|
function AsciiToString(ptr) {
|
var str = "";
|
while (1) {
|
var ch = GROWABLE_HEAP_U8()[ptr++ >> 0];
|
if (!ch) return str;
|
str += String.fromCharCode(ch);
|
}
|
}
|
|
function stringToAscii(str, outPtr) {
|
return writeAsciiToMemory(str, outPtr, false);
|
}
|
|
function UTF16ToString(ptr, maxBytesToRead) {
|
assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!");
|
var str = "";
|
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
|
var codeUnit = GROWABLE_HEAP_I16()[ptr + i * 2 >> 1];
|
if (codeUnit == 0) break;
|
str += String.fromCharCode(codeUnit);
|
}
|
return str;
|
}
|
|
function stringToUTF16(str, outPtr, maxBytesToWrite) {
|
assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!");
|
assert(typeof maxBytesToWrite == "number", "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
|
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);
|
GROWABLE_HEAP_I16()[outPtr >> 1] = codeUnit;
|
outPtr += 2;
|
}
|
GROWABLE_HEAP_I16()[outPtr >> 1] = 0;
|
return outPtr - startPtr;
|
}
|
|
function lengthBytesUTF16(str) {
|
return str.length * 2;
|
}
|
|
function UTF32ToString(ptr, maxBytesToRead) {
|
assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!");
|
var i = 0;
|
var str = "";
|
while (!(i >= maxBytesToRead / 4)) {
|
var utf32 = GROWABLE_HEAP_I32()[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) {
|
assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!");
|
assert(typeof maxBytesToWrite == "number", "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
|
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;
|
}
|
GROWABLE_HEAP_I32()[outPtr >> 2] = codeUnit;
|
outPtr += 4;
|
if (outPtr + 4 > endPtr) break;
|
}
|
GROWABLE_HEAP_I32()[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 allocateUTF8(str) {
|
var size = lengthBytesUTF8(str) + 1;
|
var ret = _malloc(size);
|
if (ret) stringToUTF8Array(str, GROWABLE_HEAP_I8(), ret, size);
|
return ret;
|
}
|
|
function allocateUTF8OnStack(str) {
|
var size = lengthBytesUTF8(str) + 1;
|
var ret = stackAlloc(size);
|
stringToUTF8Array(str, GROWABLE_HEAP_I8(), ret, size);
|
return ret;
|
}
|
|
function writeStringToMemory(string, buffer, dontAddNull) {
|
warnOnce("writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!");
|
var lastChar, end;
|
if (dontAddNull) {
|
end = buffer + lengthBytesUTF8(string);
|
lastChar = GROWABLE_HEAP_I8()[end];
|
}
|
stringToUTF8(string, buffer, Infinity);
|
if (dontAddNull) GROWABLE_HEAP_I8()[end] = lastChar;
|
}
|
|
function writeArrayToMemory(array, buffer) {
|
assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
|
GROWABLE_HEAP_I8().set(array, buffer);
|
}
|
|
function writeAsciiToMemory(str, buffer, dontAddNull) {
|
for (var i = 0; i < str.length; ++i) {
|
assert(str.charCodeAt(i) === str.charCodeAt(i) & 255);
|
GROWABLE_HEAP_I8()[buffer++ >> 0] = str.charCodeAt(i);
|
}
|
if (!dontAddNull) GROWABLE_HEAP_I8()[buffer >> 0] = 0;
|
}
|
|
function alignUp(x, multiple) {
|
if (x % multiple > 0) {
|
x += multiple - x % multiple;
|
}
|
return x;
|
}
|
|
var HEAP, 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);
|
}
|
|
var TOTAL_STACK = 5242880;
|
|
if (Module["TOTAL_STACK"]) assert(TOTAL_STACK === Module["TOTAL_STACK"], "the stack size can no longer be determined at runtime");
|
|
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 104857600;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "INITIAL_MEMORY")) {
|
Object.defineProperty(Module, "INITIAL_MEMORY", {
|
configurable: true,
|
get: function() {
|
abort("Module.INITIAL_MEMORY has been replaced with plain INITIAL_MEMORY (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
|
}
|
});
|
}
|
|
assert(INITIAL_MEMORY >= TOTAL_STACK, "INITIAL_MEMORY should be larger than TOTAL_STACK, was " + INITIAL_MEMORY + "! (TOTAL_STACK=" + TOTAL_STACK + ")");
|
|
assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray !== undefined && Int32Array.prototype.set !== undefined, "JS engine does not provide full typed array support");
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
wasmMemory = Module["wasmMemory"];
|
buffer = Module["buffer"];
|
} else {
|
if (Module["wasmMemory"]) {
|
wasmMemory = Module["wasmMemory"];
|
} else {
|
wasmMemory = new WebAssembly.Memory({
|
"initial": INITIAL_MEMORY / 65536,
|
"maximum": 1048576e3 / 65536,
|
"shared": true
|
});
|
if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
|
err("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag");
|
if (ENVIRONMENT_IS_NODE) {
|
console.log("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and also use a recent version)");
|
}
|
throw Error("bad memory");
|
}
|
}
|
}
|
|
if (wasmMemory) {
|
buffer = wasmMemory.buffer;
|
}
|
|
INITIAL_MEMORY = buffer.byteLength;
|
|
assert(INITIAL_MEMORY % 65536 === 0);
|
|
updateGlobalBufferAndViews(buffer);
|
|
var wasmTable;
|
|
function writeStackCookie() {
|
var max = _emscripten_stack_get_end();
|
assert((max & 3) == 0);
|
GROWABLE_HEAP_U32()[(max >> 2) + 1] = 34821223;
|
GROWABLE_HEAP_U32()[(max >> 2) + 2] = 2310721022;
|
GROWABLE_HEAP_I32()[0] = 1668509029;
|
}
|
|
function checkStackCookie() {
|
if (ABORT) return;
|
var max = _emscripten_stack_get_end();
|
var cookie1 = GROWABLE_HEAP_U32()[(max >> 2) + 1];
|
var cookie2 = GROWABLE_HEAP_U32()[(max >> 2) + 2];
|
if (cookie1 != 34821223 || cookie2 != 2310721022) {
|
abort("Stack overflow! Stack cookie has been overwritten, expected hex dwords 0x89BACDFE and 0x2135467, but received 0x" + cookie2.toString(16) + " " + cookie1.toString(16));
|
}
|
if (GROWABLE_HEAP_I32()[0] !== 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
|
}
|
|
(function() {
|
var h16 = new Int16Array(1);
|
var h8 = new Int8Array(h16.buffer);
|
h16[0] = 25459;
|
if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -s SUPPORT_BIG_ENDIAN=1 to bypass)";
|
})();
|
|
function abortFnPtrError(ptr, sig) {
|
abort("Invalid function pointer " + ptr + " called with signature '" + sig + "'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this). Build with ASSERTIONS=2 for more info.");
|
}
|
|
var __ATPRERUN__ = [];
|
|
var __ATINIT__ = [];
|
|
var __ATMAIN__ = [];
|
|
var __ATEXIT__ = [];
|
|
var __ATPOSTRUN__ = [];
|
|
var runtimeInitialized = false;
|
|
var runtimeExited = false;
|
|
function preRun() {
|
if (ENVIRONMENT_IS_PTHREAD) return;
|
if (Module["preRun"]) {
|
if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
|
while (Module["preRun"].length) {
|
addOnPreRun(Module["preRun"].shift());
|
}
|
}
|
callRuntimeCallbacks(__ATPRERUN__);
|
}
|
|
function initRuntime() {
|
checkStackCookie();
|
assert(!runtimeInitialized);
|
runtimeInitialized = true;
|
if (ENVIRONMENT_IS_PTHREAD) return;
|
if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
|
TTY.init();
|
callRuntimeCallbacks(__ATINIT__);
|
}
|
|
function preMain() {
|
checkStackCookie();
|
if (ENVIRONMENT_IS_PTHREAD) return;
|
FS.ignorePermissions = false;
|
callRuntimeCallbacks(__ATMAIN__);
|
}
|
|
function exitRuntime() {
|
checkStackCookie();
|
if (ENVIRONMENT_IS_PTHREAD) return;
|
runtimeExited = true;
|
}
|
|
function postRun() {
|
checkStackCookie();
|
if (ENVIRONMENT_IS_PTHREAD) return;
|
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 addOnPreMain(cb) {
|
__ATMAIN__.unshift(cb);
|
}
|
|
function addOnExit(cb) {}
|
|
function addOnPostRun(cb) {
|
__ATPOSTRUN__.unshift(cb);
|
}
|
|
assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
|
|
assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
|
|
assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
|
|
assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
|
|
var runDependencies = 0;
|
|
var runDependencyWatcher = null;
|
|
var dependenciesFulfilled = null;
|
|
var runDependencyTracking = {};
|
|
function getUniqueRunDependency(id) {
|
var orig = id;
|
while (1) {
|
if (!runDependencyTracking[id]) return id;
|
id = orig + Math.random();
|
}
|
}
|
|
function addRunDependency(id) {
|
assert(!ENVIRONMENT_IS_PTHREAD, "addRunDependency cannot be used in a pthread worker");
|
runDependencies++;
|
if (Module["monitorRunDependencies"]) {
|
Module["monitorRunDependencies"](runDependencies);
|
}
|
if (id) {
|
assert(!runDependencyTracking[id]);
|
runDependencyTracking[id] = 1;
|
if (runDependencyWatcher === null && typeof setInterval !== "undefined") {
|
runDependencyWatcher = setInterval(function() {
|
if (ABORT) {
|
clearInterval(runDependencyWatcher);
|
runDependencyWatcher = null;
|
return;
|
}
|
var shown = false;
|
for (var dep in runDependencyTracking) {
|
if (!shown) {
|
shown = true;
|
err("still waiting on run dependencies:");
|
}
|
err("dependency: " + dep);
|
}
|
if (shown) {
|
err("(end of list)");
|
}
|
}, 1e4);
|
}
|
} else {
|
err("warning: run dependency added without ID");
|
}
|
}
|
|
function removeRunDependency(id) {
|
runDependencies--;
|
if (Module["monitorRunDependencies"]) {
|
Module["monitorRunDependencies"](runDependencies);
|
}
|
if (id) {
|
assert(runDependencyTracking[id]);
|
delete runDependencyTracking[id];
|
} else {
|
err("warning: run dependency removed without ID");
|
}
|
if (runDependencies == 0) {
|
if (runDependencyWatcher !== null) {
|
clearInterval(runDependencyWatcher);
|
runDependencyWatcher = null;
|
}
|
if (dependenciesFulfilled) {
|
var callback = dependenciesFulfilled;
|
dependenciesFulfilled = null;
|
callback();
|
}
|
}
|
}
|
|
Module["preloadedImages"] = {};
|
|
Module["preloadedAudios"] = {};
|
|
function abort(what) {
|
if (Module["onAbort"]) {
|
Module["onAbort"](what);
|
}
|
if (ENVIRONMENT_IS_PTHREAD) console.error("Pthread aborting at " + new Error().stack);
|
what += "";
|
err(what);
|
ABORT = true;
|
EXITSTATUS = 1;
|
var output = "abort(" + what + ") at " + stackTrace();
|
what = output;
|
var e = new WebAssembly.RuntimeError(what);
|
readyPromiseReject(e);
|
throw e;
|
}
|
|
function hasPrefix(str, prefix) {
|
return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
|
}
|
|
var dataURIPrefix = "data:application/octet-stream;base64,";
|
|
function isDataURI(filename) {
|
return hasPrefix(filename, dataURIPrefix);
|
}
|
|
var fileURIPrefix = "file://";
|
|
function isFileURI(filename) {
|
return hasPrefix(filename, fileURIPrefix);
|
}
|
|
function createExportWrapper(name, fixedasm) {
|
return function() {
|
var displayName = name;
|
var asm = fixedasm;
|
if (!fixedasm) {
|
asm = Module["asm"];
|
}
|
assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization");
|
assert(!runtimeExited, "native function `" + displayName + "` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)");
|
if (!asm[name]) {
|
assert(asm[name], "exported native function `" + displayName + "` not found");
|
}
|
return asm[name].apply(null, arguments);
|
};
|
}
|
|
var wasmBinaryFile = "Decoder.wasm";
|
|
if (!isDataURI(wasmBinaryFile)) {
|
wasmBinaryFile = locateFile(wasmBinaryFile);
|
}
|
|
function getBinary(file) {
|
try {
|
if (file == wasmBinaryFile && wasmBinary) {
|
return new Uint8Array(wasmBinary);
|
}
|
if (readBinary) {
|
return readBinary(file);
|
} else {
|
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") {
|
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);
|
});
|
}
|
}
|
return Promise.resolve().then(function() {
|
return getBinary(wasmBinaryFile);
|
});
|
}
|
|
function createWasm() {
|
var info = {
|
"env": asmLibraryArg,
|
"wasi_snapshot_preview1": asmLibraryArg
|
};
|
function receiveInstance(instance, module) {
|
var exports = instance.exports;
|
Module["asm"] = exports;
|
wasmTable = Module["asm"]["__indirect_function_table"];
|
assert(wasmTable, "table not found in wasm exports");
|
addOnInit(Module["asm"]["__wasm_call_ctors"]);
|
PThread.tlsInitFunctions.push(Module["asm"]["emscripten_tls_init"]);
|
wasmModule = module;
|
if (!ENVIRONMENT_IS_PTHREAD) {
|
removeRunDependency("wasm-instantiate");
|
}
|
}
|
if (!ENVIRONMENT_IS_PTHREAD) {
|
addRunDependency("wasm-instantiate");
|
}
|
var trueModule = Module;
|
function receiveInstantiatedSource(output) {
|
assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
|
trueModule = null;
|
receiveInstance(output["instance"], output["module"]);
|
}
|
function instantiateArrayBuffer(receiver) {
|
return getBinaryPromise().then(function(binary) {
|
var result = WebAssembly.instantiate(binary, info);
|
return result;
|
}).then(receiver, function(reason) {
|
err("failed to asynchronously prepare wasm: " + reason);
|
if (isFileURI(wasmBinaryFile)) {
|
err("warning: Loading from a file URI (" + wasmBinaryFile + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing");
|
}
|
abort(reason);
|
});
|
}
|
function instantiateAsync() {
|
if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
|
return fetch(wasmBinaryFile, {
|
credentials: "same-origin"
|
}).then(function(response) {
|
var result = WebAssembly.instantiateStreaming(response, info);
|
return result.then(receiveInstantiatedSource, function(reason) {
|
err("wasm streaming compile failed: " + reason);
|
err("falling back to ArrayBuffer instantiation");
|
return instantiateArrayBuffer(receiveInstantiatedSource);
|
});
|
});
|
} else {
|
return instantiateArrayBuffer(receiveInstantiatedSource);
|
}
|
}
|
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().catch(readyPromiseReject);
|
return {};
|
}
|
|
var tempDouble;
|
|
var tempI64;
|
|
var ASM_CONSTS = {
|
626444: function() {
|
throw "Canceled!";
|
},
|
626462: function($0, $1) {
|
setTimeout(function() {
|
__emscripten_do_dispatch_to_thread($0, $1);
|
}, 0);
|
},
|
626541: function($0) {
|
Module["firstGLContextExt"] = GL.contexts[$0].GLctx.getExtension("WEBGL_lose_context");
|
},
|
626633: function() {
|
Module["firstGLContextExt"].loseContext();
|
}
|
};
|
|
function initPthreadsJS() {
|
PThread.initRuntime();
|
}
|
|
function callRuntimeCallbacks(callbacks) {
|
while (callbacks.length > 0) {
|
var callback = callbacks.shift();
|
if (typeof callback == "function") {
|
callback(Module);
|
continue;
|
}
|
var func = callback.func;
|
if (typeof func === "number") {
|
if (callback.arg === undefined) {
|
wasmTable.get(func)();
|
} else {
|
wasmTable.get(func)(callback.arg);
|
}
|
} else {
|
func(callback.arg === undefined ? null : callback.arg);
|
}
|
}
|
}
|
|
function demangle(func) {
|
warnOnce("warning: build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling");
|
return func;
|
}
|
|
function demangleAll(text) {
|
var regex = /\b_Z[\w\d_]+/g;
|
return text.replace(regex, function(x) {
|
var y = demangle(x);
|
return x === y ? x : y + " [" + x + "]";
|
});
|
}
|
|
var ERRNO_CODES = {
|
EPERM: 63,
|
ENOENT: 44,
|
ESRCH: 71,
|
EINTR: 27,
|
EIO: 29,
|
ENXIO: 60,
|
E2BIG: 1,
|
ENOEXEC: 45,
|
EBADF: 8,
|
ECHILD: 12,
|
EAGAIN: 6,
|
EWOULDBLOCK: 6,
|
ENOMEM: 48,
|
EACCES: 2,
|
EFAULT: 21,
|
ENOTBLK: 105,
|
EBUSY: 10,
|
EEXIST: 20,
|
EXDEV: 75,
|
ENODEV: 43,
|
ENOTDIR: 54,
|
EISDIR: 31,
|
EINVAL: 28,
|
ENFILE: 41,
|
EMFILE: 33,
|
ENOTTY: 59,
|
ETXTBSY: 74,
|
EFBIG: 22,
|
ENOSPC: 51,
|
ESPIPE: 70,
|
EROFS: 69,
|
EMLINK: 34,
|
EPIPE: 64,
|
EDOM: 18,
|
ERANGE: 68,
|
ENOMSG: 49,
|
EIDRM: 24,
|
ECHRNG: 106,
|
EL2NSYNC: 156,
|
EL3HLT: 107,
|
EL3RST: 108,
|
ELNRNG: 109,
|
EUNATCH: 110,
|
ENOCSI: 111,
|
EL2HLT: 112,
|
EDEADLK: 16,
|
ENOLCK: 46,
|
EBADE: 113,
|
EBADR: 114,
|
EXFULL: 115,
|
ENOANO: 104,
|
EBADRQC: 103,
|
EBADSLT: 102,
|
EDEADLOCK: 16,
|
EBFONT: 101,
|
ENOSTR: 100,
|
ENODATA: 116,
|
ETIME: 117,
|
ENOSR: 118,
|
ENONET: 119,
|
ENOPKG: 120,
|
EREMOTE: 121,
|
ENOLINK: 47,
|
EADV: 122,
|
ESRMNT: 123,
|
ECOMM: 124,
|
EPROTO: 65,
|
EMULTIHOP: 36,
|
EDOTDOT: 125,
|
EBADMSG: 9,
|
ENOTUNIQ: 126,
|
EBADFD: 127,
|
EREMCHG: 128,
|
ELIBACC: 129,
|
ELIBBAD: 130,
|
ELIBSCN: 131,
|
ELIBMAX: 132,
|
ELIBEXEC: 133,
|
ENOSYS: 52,
|
ENOTEMPTY: 55,
|
ENAMETOOLONG: 37,
|
ELOOP: 32,
|
EOPNOTSUPP: 138,
|
EPFNOSUPPORT: 139,
|
ECONNRESET: 15,
|
ENOBUFS: 42,
|
EAFNOSUPPORT: 5,
|
EPROTOTYPE: 67,
|
ENOTSOCK: 57,
|
ENOPROTOOPT: 50,
|
ESHUTDOWN: 140,
|
ECONNREFUSED: 14,
|
EADDRINUSE: 3,
|
ECONNABORTED: 13,
|
ENETUNREACH: 40,
|
ENETDOWN: 38,
|
ETIMEDOUT: 73,
|
EHOSTDOWN: 142,
|
EHOSTUNREACH: 23,
|
EINPROGRESS: 26,
|
EALREADY: 7,
|
EDESTADDRREQ: 17,
|
EMSGSIZE: 35,
|
EPROTONOSUPPORT: 66,
|
ESOCKTNOSUPPORT: 137,
|
EADDRNOTAVAIL: 4,
|
ENETRESET: 39,
|
EISCONN: 30,
|
ENOTCONN: 53,
|
ETOOMANYREFS: 141,
|
EUSERS: 136,
|
EDQUOT: 19,
|
ESTALE: 72,
|
ENOTSUP: 138,
|
ENOMEDIUM: 148,
|
EILSEQ: 25,
|
EOVERFLOW: 61,
|
ECANCELED: 11,
|
ENOTRECOVERABLE: 56,
|
EOWNERDEAD: 62,
|
ESTRPIPE: 135
|
};
|
|
function _emscripten_futex_wake(addr, count) {
|
if (addr <= 0 || addr > GROWABLE_HEAP_I8().length || addr & 3 != 0 || count < 0) return -28;
|
if (count == 0) return 0;
|
if (count >= 2147483647) count = Infinity;
|
assert(__emscripten_main_thread_futex > 0);
|
var mainThreadWaitAddress = Atomics.load(GROWABLE_HEAP_I32(), __emscripten_main_thread_futex >> 2);
|
var mainThreadWoken = 0;
|
if (mainThreadWaitAddress == addr) {
|
assert(!ENVIRONMENT_IS_WEB);
|
var loadedAddr = Atomics.compareExchange(GROWABLE_HEAP_I32(), __emscripten_main_thread_futex >> 2, mainThreadWaitAddress, 0);
|
if (loadedAddr == mainThreadWaitAddress) {
|
--count;
|
mainThreadWoken = 1;
|
if (count <= 0) return 1;
|
}
|
}
|
var ret = Atomics.notify(GROWABLE_HEAP_I32(), addr >> 2, count);
|
if (ret >= 0) return ret + mainThreadWoken;
|
throw "Atomics.notify returned an unexpected value " + ret;
|
}
|
|
Module["_emscripten_futex_wake"] = _emscripten_futex_wake;
|
|
function killThread(pthread_ptr) {
|
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! killThread() can only ever be called from main application thread!";
|
if (!pthread_ptr) throw "Internal Error! Null pthread_ptr in killThread!";
|
GROWABLE_HEAP_I32()[pthread_ptr + 12 >> 2] = 0;
|
var pthread = PThread.pthreads[pthread_ptr];
|
pthread.worker.terminate();
|
PThread.freeThreadData(pthread);
|
PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(pthread.worker), 1);
|
pthread.worker.pthread = undefined;
|
}
|
|
function cancelThread(pthread_ptr) {
|
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! cancelThread() can only ever be called from main application thread!";
|
if (!pthread_ptr) throw "Internal Error! Null pthread_ptr in cancelThread!";
|
var pthread = PThread.pthreads[pthread_ptr];
|
pthread.worker.postMessage({
|
"cmd": "cancel"
|
});
|
}
|
|
function cleanupThread(pthread_ptr) {
|
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! cleanupThread() can only ever be called from main application thread!";
|
if (!pthread_ptr) throw "Internal Error! Null pthread_ptr in cleanupThread!";
|
var pthread = PThread.pthreads[pthread_ptr];
|
if (pthread) {
|
GROWABLE_HEAP_I32()[pthread_ptr + 12 >> 2] = 0;
|
var worker = pthread.worker;
|
PThread.returnWorkerToPool(worker);
|
}
|
}
|
|
var PThread = {
|
unusedWorkers: [],
|
runningWorkers: [],
|
tlsInitFunctions: [],
|
initMainThreadBlock: function() {
|
assert(!ENVIRONMENT_IS_PTHREAD);
|
},
|
initRuntime: function() {
|
var tb = _malloc(228);
|
for (var i = 0; i < 228 / 4; ++i) GROWABLE_HEAP_U32()[tb / 4 + i] = 0;
|
GROWABLE_HEAP_I32()[tb + 12 >> 2] = tb;
|
var headPtr = tb + 152;
|
GROWABLE_HEAP_I32()[headPtr >> 2] = headPtr;
|
var tlsMemory = _malloc(512);
|
for (var i = 0; i < 128; ++i) GROWABLE_HEAP_U32()[tlsMemory / 4 + i] = 0;
|
Atomics.store(GROWABLE_HEAP_U32(), tb + 100 >> 2, tlsMemory);
|
Atomics.store(GROWABLE_HEAP_U32(), tb + 40 >> 2, tb);
|
__emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1);
|
_emscripten_register_main_browser_thread_id(tb);
|
PThread.mainRuntimeThread = true;
|
},
|
initWorker: function() {},
|
pthreads: {},
|
threadExitHandlers: [],
|
runExitHandlers: function() {
|
while (PThread.threadExitHandlers.length > 0) {
|
PThread.threadExitHandlers.pop()();
|
}
|
if (ENVIRONMENT_IS_PTHREAD && _pthread_self()) ___pthread_tsd_run_dtors();
|
},
|
runExitHandlersAndDeinitThread: function(tb, exitCode) {
|
Atomics.store(GROWABLE_HEAP_U32(), tb + 56 >> 2, 1);
|
Atomics.store(GROWABLE_HEAP_U32(), tb + 60 >> 2, 0);
|
PThread.runExitHandlers();
|
Atomics.store(GROWABLE_HEAP_U32(), tb + 4 >> 2, exitCode);
|
Atomics.store(GROWABLE_HEAP_U32(), tb + 0 >> 2, 1);
|
_emscripten_futex_wake(tb + 0, 2147483647);
|
__emscripten_thread_init(0, 0, 0);
|
},
|
setExitStatus: function(status) {
|
EXITSTATUS = status;
|
},
|
threadExit: function(exitCode) {
|
var tb = _pthread_self();
|
if (tb) {
|
err("Pthread 0x" + tb.toString(16) + " exited.");
|
PThread.runExitHandlersAndDeinitThread(tb, exitCode);
|
if (ENVIRONMENT_IS_PTHREAD) {
|
postMessage({
|
"cmd": "exit"
|
});
|
}
|
}
|
},
|
threadCancel: function() {
|
PThread.runExitHandlersAndDeinitThread(_pthread_self(), -1);
|
postMessage({
|
"cmd": "cancelDone"
|
});
|
},
|
terminateAllThreads: function() {
|
for (var t in PThread.pthreads) {
|
var pthread = PThread.pthreads[t];
|
if (pthread && pthread.worker) {
|
PThread.returnWorkerToPool(pthread.worker);
|
}
|
}
|
PThread.pthreads = {};
|
for (var i = 0; i < PThread.unusedWorkers.length; ++i) {
|
var worker = PThread.unusedWorkers[i];
|
assert(!worker.pthread);
|
worker.terminate();
|
}
|
PThread.unusedWorkers = [];
|
for (var i = 0; i < PThread.runningWorkers.length; ++i) {
|
var worker = PThread.runningWorkers[i];
|
var pthread = worker.pthread;
|
assert(pthread, "This Worker should have a pthread it is executing");
|
PThread.freeThreadData(pthread);
|
worker.terminate();
|
}
|
PThread.runningWorkers = [];
|
},
|
freeThreadData: function(pthread) {
|
if (!pthread) return;
|
if (pthread.threadInfoStruct) {
|
var tlsMemory = GROWABLE_HEAP_I32()[pthread.threadInfoStruct + 100 >> 2];
|
GROWABLE_HEAP_I32()[pthread.threadInfoStruct + 100 >> 2] = 0;
|
_free(tlsMemory);
|
_free(pthread.threadInfoStruct);
|
}
|
pthread.threadInfoStruct = 0;
|
if (pthread.allocatedOwnStack && pthread.stackBase) _free(pthread.stackBase);
|
pthread.stackBase = 0;
|
if (pthread.worker) pthread.worker.pthread = null;
|
},
|
returnWorkerToPool: function(worker) {
|
PThread.runWithoutMainThreadQueuedCalls(function() {
|
delete PThread.pthreads[worker.pthread.threadInfoStruct];
|
PThread.unusedWorkers.push(worker);
|
PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);
|
PThread.freeThreadData(worker.pthread);
|
worker.pthread = undefined;
|
});
|
},
|
runWithoutMainThreadQueuedCalls: function(func) {
|
assert(PThread.mainRuntimeThread, "runWithoutMainThreadQueuedCalls must be done on the main runtime thread");
|
assert(__emscripten_allow_main_runtime_queued_calls);
|
GROWABLE_HEAP_I32()[__emscripten_allow_main_runtime_queued_calls >> 2] = 0;
|
try {
|
func();
|
} finally {
|
GROWABLE_HEAP_I32()[__emscripten_allow_main_runtime_queued_calls >> 2] = 1;
|
}
|
},
|
receiveObjectTransfer: function(data) {
|
if (typeof GL !== "undefined") {
|
for (var i in data.offscreenCanvases) {
|
GL.offscreenCanvases[i] = data.offscreenCanvases[i];
|
}
|
if (!Module["canvas"] && data.moduleCanvasId && GL.offscreenCanvases[data.moduleCanvasId]) {
|
Module["canvas"] = GL.offscreenCanvases[data.moduleCanvasId].offscreenCanvas;
|
Module["canvas"].id = data.moduleCanvasId;
|
}
|
}
|
},
|
threadInit: function() {
|
for (var i in PThread.tlsInitFunctions) {
|
PThread.tlsInitFunctions[i]();
|
}
|
},
|
loadWasmModuleToWorker: function(worker, onFinishedLoading) {
|
worker.onmessage = function(e) {
|
var d = e["data"];
|
var cmd = d["cmd"];
|
if (worker.pthread) PThread.currentProxiedOperationCallerThread = worker.pthread.threadInfoStruct;
|
if (d["targetThread"] && d["targetThread"] != _pthread_self()) {
|
var thread = PThread.pthreads[d.targetThread];
|
if (thread) {
|
thread.worker.postMessage(e.data, d["transferList"]);
|
} else {
|
console.error('Internal error! Worker sent a message "' + cmd + '" to target pthread ' + d["targetThread"] + ", but that thread no longer exists!");
|
}
|
PThread.currentProxiedOperationCallerThread = undefined;
|
return;
|
}
|
if (cmd === "processQueuedMainThreadWork") {
|
_emscripten_main_thread_process_queued_calls();
|
} else if (cmd === "spawnThread") {
|
spawnThread(e.data);
|
} else if (cmd === "cleanupThread") {
|
cleanupThread(d["thread"]);
|
} else if (cmd === "killThread") {
|
killThread(d["thread"]);
|
} else if (cmd === "cancelThread") {
|
cancelThread(d["thread"]);
|
} else if (cmd === "loaded") {
|
worker.loaded = true;
|
if (onFinishedLoading) onFinishedLoading(worker);
|
if (worker.runPthread) {
|
worker.runPthread();
|
delete worker.runPthread;
|
}
|
} else if (cmd === "print") {
|
out("Thread " + d["threadId"] + ": " + d["text"]);
|
} else if (cmd === "printErr") {
|
err("Thread " + d["threadId"] + ": " + d["text"]);
|
} else if (cmd === "alert") {
|
alert("Thread " + d["threadId"] + ": " + d["text"]);
|
} else if (cmd === "exit") {
|
var detached = worker.pthread && Atomics.load(GROWABLE_HEAP_U32(), worker.pthread.threadInfoStruct + 64 >> 2);
|
if (detached) {
|
PThread.returnWorkerToPool(worker);
|
}
|
} else if (cmd === "exitProcess") {
|
err("exitProcess requested by worker");
|
try {
|
exit(d["returnCode"]);
|
} catch (e) {
|
if (e instanceof ExitStatus) return;
|
throw e;
|
}
|
} else if (cmd === "cancelDone") {
|
PThread.returnWorkerToPool(worker);
|
} else if (cmd === "objectTransfer") {
|
PThread.receiveObjectTransfer(e.data);
|
} else if (e.data.target === "setimmediate") {
|
worker.postMessage(e.data);
|
} else {
|
err("worker sent an unknown command " + cmd);
|
}
|
PThread.currentProxiedOperationCallerThread = undefined;
|
};
|
worker.onerror = function(e) {
|
err("pthread sent an error! " + e.filename + ":" + e.lineno + ": " + e.message);
|
};
|
assert(wasmMemory instanceof WebAssembly.Memory, "WebAssembly memory should have been loaded by now!");
|
assert(wasmModule instanceof WebAssembly.Module, "WebAssembly Module should have been loaded by now!");
|
worker.postMessage({
|
"cmd": "load",
|
"urlOrBlob": Module["mainScriptUrlOrBlob"] || _scriptDir,
|
"wasmMemory": wasmMemory,
|
"wasmModule": wasmModule
|
});
|
},
|
allocateUnusedWorker: function() {
|
var pthreadMainJs = locateFile("Decoder.worker.js");
|
PThread.unusedWorkers.push(new Worker(pthreadMainJs));
|
},
|
getNewWorker: function() {
|
if (PThread.unusedWorkers.length == 0) {
|
PThread.allocateUnusedWorker();
|
PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
|
}
|
return PThread.unusedWorkers.pop();
|
},
|
busySpinWait: function(msecs) {
|
var t = performance.now() + msecs;
|
while (performance.now() < t) {
|
}
|
}
|
};
|
|
function establishStackSpace(stackTop, stackMax) {
|
_emscripten_stack_set_limits(stackTop, stackMax);
|
stackRestore(stackTop);
|
writeStackCookie();
|
}
|
|
Module["establishStackSpace"] = establishStackSpace;
|
|
function invokeEntryPoint(ptr, arg) {
|
return wasmTable.get(ptr)(arg);
|
}
|
|
Module["invokeEntryPoint"] = invokeEntryPoint;
|
|
function jsStackTrace() {
|
var error = new Error();
|
if (!error.stack) {
|
try {
|
throw new Error();
|
} catch (e) {
|
error = e;
|
}
|
if (!error.stack) {
|
return "(no stack trace available)";
|
}
|
}
|
return error.stack.toString();
|
}
|
|
var runtimeKeepaliveCounter = 0;
|
|
function keepRuntimeAlive() {
|
return noExitRuntime || runtimeKeepaliveCounter > 0;
|
}
|
|
Module["keepRuntimeAlive"] = keepRuntimeAlive;
|
|
function stackTrace() {
|
var js = jsStackTrace();
|
if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
|
return demangleAll(js);
|
}
|
|
function _DecCB(port, pYUVPCMData, size, type, timestamp) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(1, 0, port, pYUVPCMData, size, type, timestamp);
|
var apYUVPCMData = new Uint8Array(size);
|
apYUVPCMData.set(Module.HEAPU8.subarray(pYUVPCMData, pYUVPCMData + size));
|
JSPlayM4_DecCallBack(port, apYUVPCMData, size, type, timestamp);
|
apYUVPCMData = null;
|
}
|
|
function _YUVDisplayCB(port, yuvData, size, timestamp) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(2, 0, port, yuvData, size, timestamp);
|
var aYUVData = new Uint8Array(size);
|
aYUVData.set(Module.HEAPU8.subarray(yuvData, yuvData + size));
|
JSPlayM4_DisplayCallBack(port, aYUVData, size, timestamp);
|
aYUVData = null;
|
}
|
|
function ___assert_fail(condition, filename, line, func) {
|
abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
|
}
|
|
function ___call_main(argc, argv) {
|
var returnCode = _main(argc, argv);
|
out("Proxied main thread 0x" + _pthread_self().toString(16) + " finished with return code " + returnCode + ". EXIT_RUNTIME=0 set, so keeping main thread alive for asynchronous event operations.");
|
}
|
|
var _emscripten_get_now;
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
_emscripten_get_now = function() {
|
return performance.now() - Module["__performance_now_clock_drift"];
|
};
|
} else _emscripten_get_now = function() {
|
return performance.now();
|
};
|
|
var _emscripten_get_now_is_monotonic = true;
|
|
function setErrNo(value) {
|
GROWABLE_HEAP_I32()[___errno_location() >> 2] = value;
|
return value;
|
}
|
|
function _clock_gettime(clk_id, tp) {
|
var now;
|
if (clk_id === 0) {
|
now = Date.now();
|
} else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) {
|
now = _emscripten_get_now();
|
} else {
|
setErrNo(28);
|
return -1;
|
}
|
GROWABLE_HEAP_I32()[tp >> 2] = now / 1e3 | 0;
|
GROWABLE_HEAP_I32()[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0;
|
return 0;
|
}
|
|
function ___clock_gettime(a0, a1) {
|
return _clock_gettime(a0, a1);
|
}
|
|
var ExceptionInfoAttrs = {
|
DESTRUCTOR_OFFSET: 0,
|
REFCOUNT_OFFSET: 4,
|
TYPE_OFFSET: 8,
|
CAUGHT_OFFSET: 12,
|
RETHROWN_OFFSET: 13,
|
SIZE: 16
|
};
|
|
function ___cxa_allocate_exception(size) {
|
return _malloc(size + ExceptionInfoAttrs.SIZE) + ExceptionInfoAttrs.SIZE;
|
}
|
|
function _atexit(func, arg) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(3, 1, func, arg);
|
}
|
|
function ___cxa_atexit(a0, a1) {
|
return _atexit(a0, a1);
|
}
|
|
function _pthread_cleanup_push(routine, arg) {
|
PThread.threadExitHandlers.push(function() {
|
wasmTable.get(routine)(arg);
|
});
|
}
|
|
function ___cxa_thread_atexit(a0, a1) {
|
return _pthread_cleanup_push(a0, a1);
|
}
|
|
function ExceptionInfo(excPtr) {
|
this.excPtr = excPtr;
|
this.ptr = excPtr - ExceptionInfoAttrs.SIZE;
|
this.set_type = function(type) {
|
GROWABLE_HEAP_I32()[this.ptr + ExceptionInfoAttrs.TYPE_OFFSET >> 2] = type;
|
};
|
this.get_type = function() {
|
return GROWABLE_HEAP_I32()[this.ptr + ExceptionInfoAttrs.TYPE_OFFSET >> 2];
|
};
|
this.set_destructor = function(destructor) {
|
GROWABLE_HEAP_I32()[this.ptr + ExceptionInfoAttrs.DESTRUCTOR_OFFSET >> 2] = destructor;
|
};
|
this.get_destructor = function() {
|
return GROWABLE_HEAP_I32()[this.ptr + ExceptionInfoAttrs.DESTRUCTOR_OFFSET >> 2];
|
};
|
this.set_refcount = function(refcount) {
|
GROWABLE_HEAP_I32()[this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET >> 2] = refcount;
|
};
|
this.set_caught = function(caught) {
|
caught = caught ? 1 : 0;
|
GROWABLE_HEAP_I8()[this.ptr + ExceptionInfoAttrs.CAUGHT_OFFSET >> 0] = caught;
|
};
|
this.get_caught = function() {
|
return GROWABLE_HEAP_I8()[this.ptr + ExceptionInfoAttrs.CAUGHT_OFFSET >> 0] != 0;
|
};
|
this.set_rethrown = function(rethrown) {
|
rethrown = rethrown ? 1 : 0;
|
GROWABLE_HEAP_I8()[this.ptr + ExceptionInfoAttrs.RETHROWN_OFFSET >> 0] = rethrown;
|
};
|
this.get_rethrown = function() {
|
return GROWABLE_HEAP_I8()[this.ptr + ExceptionInfoAttrs.RETHROWN_OFFSET >> 0] != 0;
|
};
|
this.init = function(type, destructor) {
|
this.set_type(type);
|
this.set_destructor(destructor);
|
this.set_refcount(0);
|
this.set_caught(false);
|
this.set_rethrown(false);
|
};
|
this.add_ref = function() {
|
Atomics.add(GROWABLE_HEAP_I32(), this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET >> 2, 1);
|
};
|
this.release_ref = function() {
|
var prev = Atomics.sub(GROWABLE_HEAP_I32(), this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET >> 2, 1);
|
assert(prev > 0);
|
return prev === 1;
|
};
|
}
|
|
var exceptionLast = 0;
|
|
var uncaughtExceptionCount = 0;
|
|
function ___cxa_throw(ptr, type, destructor) {
|
var info = new ExceptionInfo(ptr);
|
info.init(type, destructor);
|
exceptionLast = ptr;
|
uncaughtExceptionCount++;
|
throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s NO_DISABLE_EXCEPTION_CATCHING or -s EXCEPTION_CATCHING_ALLOWED=[..] to catch.";
|
}
|
|
function _tzset() {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(4, 1);
|
if (_tzset.called) return;
|
_tzset.called = true;
|
var currentYear = new Date().getFullYear();
|
var winter = new Date(currentYear, 0, 1);
|
var summer = new Date(currentYear, 6, 1);
|
var winterOffset = winter.getTimezoneOffset();
|
var summerOffset = summer.getTimezoneOffset();
|
var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
|
GROWABLE_HEAP_I32()[__get_timezone() >> 2] = stdTimezoneOffset * 60;
|
GROWABLE_HEAP_I32()[__get_daylight() >> 2] = Number(winterOffset != summerOffset);
|
function extractZone(date) {
|
var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
|
return match ? match[1] : "GMT";
|
}
|
var winterName = extractZone(winter);
|
var summerName = extractZone(summer);
|
var winterNamePtr = allocateUTF8(winterName);
|
var summerNamePtr = allocateUTF8(summerName);
|
if (summerOffset < winterOffset) {
|
GROWABLE_HEAP_I32()[__get_tzname() >> 2] = winterNamePtr;
|
GROWABLE_HEAP_I32()[__get_tzname() + 4 >> 2] = summerNamePtr;
|
} else {
|
GROWABLE_HEAP_I32()[__get_tzname() >> 2] = summerNamePtr;
|
GROWABLE_HEAP_I32()[__get_tzname() + 4 >> 2] = winterNamePtr;
|
}
|
}
|
|
function _localtime_r(time, tmPtr) {
|
_tzset();
|
var date = new Date(GROWABLE_HEAP_I32()[time >> 2] * 1e3);
|
GROWABLE_HEAP_I32()[tmPtr >> 2] = date.getSeconds();
|
GROWABLE_HEAP_I32()[tmPtr + 4 >> 2] = date.getMinutes();
|
GROWABLE_HEAP_I32()[tmPtr + 8 >> 2] = date.getHours();
|
GROWABLE_HEAP_I32()[tmPtr + 12 >> 2] = date.getDate();
|
GROWABLE_HEAP_I32()[tmPtr + 16 >> 2] = date.getMonth();
|
GROWABLE_HEAP_I32()[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
|
GROWABLE_HEAP_I32()[tmPtr + 24 >> 2] = date.getDay();
|
var start = new Date(date.getFullYear(), 0, 1);
|
var yday = (date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24) | 0;
|
GROWABLE_HEAP_I32()[tmPtr + 28 >> 2] = yday;
|
GROWABLE_HEAP_I32()[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
|
var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
|
var winterOffset = start.getTimezoneOffset();
|
var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
|
GROWABLE_HEAP_I32()[tmPtr + 32 >> 2] = dst;
|
var zonePtr = GROWABLE_HEAP_I32()[__get_tzname() + (dst ? 4 : 0) >> 2];
|
GROWABLE_HEAP_I32()[tmPtr + 40 >> 2] = zonePtr;
|
return tmPtr;
|
}
|
|
function ___localtime_r(a0, a1) {
|
return _localtime_r(a0, a1);
|
}
|
|
var PATH = {
|
splitPath: function(filename) {
|
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
return splitPathRe.exec(filename).slice(1);
|
},
|
normalizeArray: function(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: function(path) {
|
var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/";
|
path = PATH.normalizeArray(path.split("/").filter(function(p) {
|
return !!p;
|
}), !isAbsolute).join("/");
|
if (!path && !isAbsolute) {
|
path = ".";
|
}
|
if (path && trailingSlash) {
|
path += "/";
|
}
|
return (isAbsolute ? "/" : "") + path;
|
},
|
dirname: function(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: function(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);
|
},
|
extname: function(path) {
|
return PATH.splitPath(path)[3];
|
},
|
join: function() {
|
var paths = Array.prototype.slice.call(arguments, 0);
|
return PATH.normalize(paths.join("/"));
|
},
|
join2: function(l, r) {
|
return PATH.normalize(l + "/" + r);
|
}
|
};
|
|
function getRandomDevice() {
|
if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
|
var randomBuffer = new Uint8Array(1);
|
return function() {
|
crypto.getRandomValues(randomBuffer);
|
return randomBuffer[0];
|
};
|
} else return function() {
|
abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };");
|
};
|
}
|
|
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.charAt(0) === "/";
|
}
|
resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function(p) {
|
return !!p;
|
}), !resolvedAbsolute).join("/");
|
return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
|
},
|
relative: function(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("/");
|
}
|
};
|
|
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 (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 mmapAlloc(size) {
|
var alignedSize = alignMemory(size, 16384);
|
var ptr = _malloc(alignedSize);
|
while (size < alignedSize) GROWABLE_HEAP_I8()[ptr + size++] = 0;
|
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);
|
assert(size >= 0);
|
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) {
|
assert(!(buffer instanceof ArrayBuffer));
|
if (buffer.buffer === GROWABLE_HEAP_I8().buffer) {
|
canOwn = false;
|
}
|
if (!length) return 0;
|
var node = stream.node;
|
node.timestamp = Date.now();
|
if (buffer.subarray && (!node.contents || node.contents.subarray)) {
|
if (canOwn) {
|
assert(position === 0, "canOwn must imply no weird position inside the file");
|
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, address, length, position, prot, flags) {
|
if (address !== 0) {
|
throw new FS.ErrnoError(28);
|
}
|
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);
|
}
|
GROWABLE_HEAP_I8().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;
|
}
|
var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
|
return 0;
|
}
|
}
|
};
|
|
var ERRNO_MESSAGES = {
|
0: "Success",
|
1: "Arg list too long",
|
2: "Permission denied",
|
3: "Address already in use",
|
4: "Address not available",
|
5: "Address family not supported by protocol family",
|
6: "No more processes",
|
7: "Socket already connected",
|
8: "Bad file number",
|
9: "Trying to read unreadable message",
|
10: "Mount device busy",
|
11: "Operation canceled",
|
12: "No children",
|
13: "Connection aborted",
|
14: "Connection refused",
|
15: "Connection reset by peer",
|
16: "File locking deadlock error",
|
17: "Destination address required",
|
18: "Math arg out of domain of func",
|
19: "Quota exceeded",
|
20: "File exists",
|
21: "Bad address",
|
22: "File too large",
|
23: "Host is unreachable",
|
24: "Identifier removed",
|
25: "Illegal byte sequence",
|
26: "Connection already in progress",
|
27: "Interrupted system call",
|
28: "Invalid argument",
|
29: "I/O error",
|
30: "Socket is already connected",
|
31: "Is a directory",
|
32: "Too many symbolic links",
|
33: "Too many open files",
|
34: "Too many links",
|
35: "Message too long",
|
36: "Multihop attempted",
|
37: "File or path name too long",
|
38: "Network interface is not configured",
|
39: "Connection reset by network",
|
40: "Network is unreachable",
|
41: "Too many open files in system",
|
42: "No buffer space available",
|
43: "No such device",
|
44: "No such file or directory",
|
45: "Exec format error",
|
46: "No record locks available",
|
47: "The link has been severed",
|
48: "Not enough core",
|
49: "No message of desired type",
|
50: "Protocol not available",
|
51: "No space left on device",
|
52: "Function not implemented",
|
53: "Socket is not connected",
|
54: "Not a directory",
|
55: "Directory not empty",
|
56: "State not recoverable",
|
57: "Socket operation on non-socket",
|
59: "Not a typewriter",
|
60: "No such device or address",
|
61: "Value too large for defined data type",
|
62: "Previous owner died",
|
63: "Not super-user",
|
64: "Broken pipe",
|
65: "Protocol error",
|
66: "Unknown protocol",
|
67: "Protocol wrong type for socket",
|
68: "Math result not representable",
|
69: "Read only file system",
|
70: "Illegal seek",
|
71: "No such process",
|
72: "Stale file handle",
|
73: "Connection timed out",
|
74: "Text file busy",
|
75: "Cross-device link",
|
100: "Device not a stream",
|
101: "Bad font file fmt",
|
102: "Invalid slot",
|
103: "Invalid request code",
|
104: "No anode",
|
105: "Block device required",
|
106: "Channel number out of range",
|
107: "Level 3 halted",
|
108: "Level 3 reset",
|
109: "Link number out of range",
|
110: "Protocol driver not attached",
|
111: "No CSI structure available",
|
112: "Level 2 halted",
|
113: "Invalid exchange",
|
114: "Invalid request descriptor",
|
115: "Exchange full",
|
116: "No data (for no delay io)",
|
117: "Timer expired",
|
118: "Out of streams resources",
|
119: "Machine is not on the network",
|
120: "Package not installed",
|
121: "The object is remote",
|
122: "Advertise error",
|
123: "Srmount error",
|
124: "Communication error on send",
|
125: "Cross mount point (not really error)",
|
126: "Given log. name not unique",
|
127: "f.d. invalid for this operation",
|
128: "Remote address changed",
|
129: "Can access a needed shared lib",
|
130: "Accessing a corrupted shared lib",
|
131: ".lib section in a.out corrupted",
|
132: "Attempting to link in too many libs",
|
133: "Attempting to exec a shared library",
|
135: "Streams pipe error",
|
136: "Too many users",
|
137: "Socket type not supported",
|
138: "Not supported",
|
139: "Protocol family not supported",
|
140: "Can't send after socket shutdown",
|
141: "Too many references",
|
142: "Host is down",
|
148: "No medium (in tape drive)",
|
156: "Level 2 not synchronized"
|
};
|
|
var FS = {
|
root: null,
|
mounts: [],
|
devices: {},
|
streams: [],
|
nextInode: 1,
|
nameTable: null,
|
currentPath: "/",
|
initialized: false,
|
ignorePermissions: true,
|
trackingDelegate: {},
|
tracking: {
|
openFlags: {
|
READ: 1,
|
WRITE: 2
|
}
|
},
|
ErrnoError: null,
|
genericErrors: {},
|
filesystems: null,
|
syncFSRequests: 0,
|
lookupPath: function(path, opts) {
|
path = PATH_FS.resolve(FS.cwd(), path);
|
opts = opts || {};
|
if (!path) return {
|
path: "",
|
node: null
|
};
|
var defaults = {
|
follow_mount: true,
|
recurse_count: 0
|
};
|
for (var key in defaults) {
|
if (opts[key] === undefined) {
|
opts[key] = defaults[key];
|
}
|
}
|
if (opts.recurse_count > 8) {
|
throw new FS.ErrnoError(32);
|
}
|
var parts = PATH.normalizeArray(path.split("/").filter(function(p) {
|
return !!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
|
});
|
current = lookup.node;
|
if (count++ > 40) {
|
throw new FS.ErrnoError(32);
|
}
|
}
|
}
|
}
|
return {
|
path: current_path,
|
node: current
|
};
|
},
|
getPath: function(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: function(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: function(node) {
|
var hash = FS.hashName(node.parent.id, node.name);
|
node.name_next = FS.nameTable[hash];
|
FS.nameTable[hash] = node;
|
},
|
hashRemoveNode: function(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: function(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: function(parent, name, mode, rdev) {
|
assert(typeof parent === "object");
|
var node = new FS.FSNode(parent, name, mode, rdev);
|
FS.hashAddNode(node);
|
return node;
|
},
|
destroyNode: function(node) {
|
FS.hashRemoveNode(node);
|
},
|
isRoot: function(node) {
|
return node === node.parent;
|
},
|
isMountpoint: function(node) {
|
return !!node.mounted;
|
},
|
isFile: function(mode) {
|
return (mode & 61440) === 32768;
|
},
|
isDir: function(mode) {
|
return (mode & 61440) === 16384;
|
},
|
isLink: function(mode) {
|
return (mode & 61440) === 40960;
|
},
|
isChrdev: function(mode) {
|
return (mode & 61440) === 8192;
|
},
|
isBlkdev: function(mode) {
|
return (mode & 61440) === 24576;
|
},
|
isFIFO: function(mode) {
|
return (mode & 61440) === 4096;
|
},
|
isSocket: function(mode) {
|
return (mode & 49152) === 49152;
|
},
|
flagModes: {
|
"r": 0,
|
"r+": 2,
|
"w": 577,
|
"w+": 578,
|
"a": 1089,
|
"a+": 1090
|
},
|
modeStringToFlags: function(str) {
|
var flags = FS.flagModes[str];
|
if (typeof flags === "undefined") {
|
throw new Error("Unknown file open mode: " + str);
|
}
|
return flags;
|
},
|
flagsToPermissionString: function(flag) {
|
var perms = [ "r", "w", "rw" ][flag & 3];
|
if (flag & 512) {
|
perms += "w";
|
}
|
return perms;
|
},
|
nodePermissions: function(node, perms) {
|
if (FS.ignorePermissions) {
|
return 0;
|
}
|
if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
|
return 2;
|
} else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
|
return 2;
|
} else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
|
return 2;
|
}
|
return 0;
|
},
|
mayLookup: function(dir) {
|
var errCode = FS.nodePermissions(dir, "x");
|
if (errCode) return errCode;
|
if (!dir.node_ops.lookup) return 2;
|
return 0;
|
},
|
mayCreate: function(dir, name) {
|
try {
|
var node = FS.lookupNode(dir, name);
|
return 20;
|
} catch (e) {}
|
return FS.nodePermissions(dir, "wx");
|
},
|
mayDelete: function(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: function(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(fd_start, fd_end) {
|
fd_start = fd_start || 0;
|
fd_end = fd_end || 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: function(fd) {
|
return FS.streams[fd];
|
},
|
createStream: function(stream, fd_start, fd_end) {
|
if (!FS.FSStream) {
|
FS.FSStream = function() {};
|
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;
|
}
|
}
|
};
|
}
|
var newStream = new FS.FSStream();
|
for (var p in stream) {
|
newStream[p] = stream[p];
|
}
|
stream = newStream;
|
var fd = FS.nextfd(fd_start, fd_end);
|
stream.fd = fd;
|
FS.streams[fd] = stream;
|
return stream;
|
},
|
closeStream: function(fd) {
|
FS.streams[fd] = null;
|
},
|
chrdev_stream_ops: {
|
open: function(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: function() {
|
throw new FS.ErrnoError(70);
|
}
|
},
|
major: function(dev) {
|
return dev >> 8;
|
},
|
minor: function(dev) {
|
return dev & 255;
|
},
|
makedev: function(ma, mi) {
|
return ma << 8 | mi;
|
},
|
registerDevice: function(dev, ops) {
|
FS.devices[dev] = {
|
stream_ops: ops
|
};
|
},
|
getDevice: function(dev) {
|
return FS.devices[dev];
|
},
|
getMounts: function(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: function(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) {
|
assert(FS.syncFSRequests > 0);
|
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(function(mount) {
|
if (!mount.type.syncfs) {
|
return done(null);
|
}
|
mount.type.syncfs(mount, populate, done);
|
});
|
},
|
mount: function(type, opts, mountpoint) {
|
if (typeof type === "string") {
|
throw type;
|
}
|
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: function(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(function(hash) {
|
var current = FS.nameTable[hash];
|
while (current) {
|
var next = current.name_next;
|
if (mounts.indexOf(current.mount) !== -1) {
|
FS.destroyNode(current);
|
}
|
current = next;
|
}
|
});
|
node.mounted = null;
|
var idx = node.mount.mounts.indexOf(mount);
|
assert(idx !== -1);
|
node.mount.mounts.splice(idx, 1);
|
},
|
lookup: function(parent, name) {
|
return parent.node_ops.lookup(parent, name);
|
},
|
mknod: function(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: function(path, mode) {
|
mode = mode !== undefined ? mode : 438;
|
mode &= 4095;
|
mode |= 32768;
|
return FS.mknod(path, mode, 0);
|
},
|
mkdir: function(path, mode) {
|
mode = mode !== undefined ? mode : 511;
|
mode &= 511 | 512;
|
mode |= 16384;
|
return FS.mknod(path, mode, 0);
|
},
|
mkdirTree: function(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: function(path, mode, dev) {
|
if (typeof dev === "undefined") {
|
dev = mode;
|
mode = 438;
|
}
|
mode |= 8192;
|
return FS.mknod(path, mode, dev);
|
},
|
symlink: function(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: function(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);
|
}
|
}
|
try {
|
if (FS.trackingDelegate["willMovePath"]) {
|
FS.trackingDelegate["willMovePath"](old_path, new_path);
|
}
|
} catch (e) {
|
err("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message);
|
}
|
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);
|
}
|
try {
|
if (FS.trackingDelegate["onMovePath"]) FS.trackingDelegate["onMovePath"](old_path, new_path);
|
} catch (e) {
|
err("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message);
|
}
|
},
|
rmdir: function(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);
|
}
|
try {
|
if (FS.trackingDelegate["willDeletePath"]) {
|
FS.trackingDelegate["willDeletePath"](path);
|
}
|
} catch (e) {
|
err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message);
|
}
|
parent.node_ops.rmdir(parent, name);
|
FS.destroyNode(node);
|
try {
|
if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path);
|
} catch (e) {
|
err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message);
|
}
|
},
|
readdir: function(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: function(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, 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);
|
}
|
try {
|
if (FS.trackingDelegate["willDeletePath"]) {
|
FS.trackingDelegate["willDeletePath"](path);
|
}
|
} catch (e) {
|
err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message);
|
}
|
parent.node_ops.unlink(parent, name);
|
FS.destroyNode(node);
|
try {
|
if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path);
|
} catch (e) {
|
err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message);
|
}
|
},
|
readlink: function(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: function(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: function(path) {
|
return FS.stat(path, true);
|
},
|
chmod: function(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: function(path, mode) {
|
FS.chmod(path, mode, true);
|
},
|
fchmod: function(fd, mode) {
|
var stream = FS.getStream(fd);
|
if (!stream) {
|
throw new FS.ErrnoError(8);
|
}
|
FS.chmod(stream.node, mode);
|
},
|
chown: function(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: function(path, uid, gid) {
|
FS.chown(path, uid, gid, true);
|
},
|
fchown: function(fd, uid, gid) {
|
var stream = FS.getStream(fd);
|
if (!stream) {
|
throw new FS.ErrnoError(8);
|
}
|
FS.chown(stream.node, uid, gid);
|
},
|
truncate: function(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: function(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: function(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: function(path, flags, mode, fd_start, fd_end) {
|
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) {
|
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
|
}, fd_start, fd_end);
|
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;
|
err("FS.trackingDelegate error on read file: " + path);
|
}
|
}
|
try {
|
if (FS.trackingDelegate["onOpenFile"]) {
|
var trackingFlags = 0;
|
if ((flags & 2097155) !== 1) {
|
trackingFlags |= FS.tracking.openFlags.READ;
|
}
|
if ((flags & 2097155) !== 0) {
|
trackingFlags |= FS.tracking.openFlags.WRITE;
|
}
|
FS.trackingDelegate["onOpenFile"](path, trackingFlags);
|
}
|
} catch (e) {
|
err("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message);
|
}
|
return stream;
|
},
|
close: function(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: function(stream) {
|
return stream.fd === null;
|
},
|
llseek: function(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: function(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: function(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;
|
try {
|
if (stream.path && FS.trackingDelegate["onWriteToFile"]) FS.trackingDelegate["onWriteToFile"](stream.path);
|
} catch (e) {
|
err("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message);
|
}
|
return bytesWritten;
|
},
|
allocate: function(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: function(stream, address, 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, address, length, position, prot, flags);
|
},
|
msync: function(stream, buffer, offset, length, mmapFlags) {
|
if (!stream || !stream.stream_ops.msync) {
|
return 0;
|
}
|
return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
|
},
|
munmap: function(stream) {
|
return 0;
|
},
|
ioctl: function(stream, cmd, arg) {
|
if (!stream.stream_ops.ioctl) {
|
throw new FS.ErrnoError(59);
|
}
|
return stream.stream_ops.ioctl(stream, cmd, arg);
|
},
|
readFile: function(path, opts) {
|
opts = opts || {};
|
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, opts) {
|
opts = opts || {};
|
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: function() {
|
return FS.currentPath;
|
},
|
chdir: function(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: function() {
|
FS.mkdir("/tmp");
|
FS.mkdir("/home");
|
FS.mkdir("/home/web_user");
|
},
|
createDefaultDevices: function() {
|
FS.mkdir("/dev");
|
FS.registerDevice(FS.makedev(1, 3), {
|
read: function() {
|
return 0;
|
},
|
write: function(stream, buffer, offset, length, pos) {
|
return 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: function() {
|
FS.mkdir("/proc");
|
var proc_self = FS.mkdir("/proc/self");
|
FS.mkdir("/proc/self/fd");
|
FS.mount({
|
mount: function() {
|
var node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
|
node.node_ops = {
|
lookup: function(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: function() {
|
return stream.path;
|
}
|
}
|
};
|
ret.parent = ret;
|
return ret;
|
}
|
};
|
return node;
|
}
|
}, {}, "/proc/self/fd");
|
},
|
createStandardStreams: function() {
|
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");
|
}
|
var stdin = FS.open("/dev/stdin", 0);
|
var stdout = FS.open("/dev/stdout", 1);
|
var stderr = FS.open("/dev/stderr", 1);
|
assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")");
|
assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")");
|
assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")");
|
},
|
ensureErrnoError: function() {
|
if (FS.ErrnoError) return;
|
FS.ErrnoError = function ErrnoError(errno, node) {
|
this.node = node;
|
this.setErrno = function(errno) {
|
this.errno = errno;
|
for (var key in ERRNO_CODES) {
|
if (ERRNO_CODES[key] === errno) {
|
this.code = key;
|
break;
|
}
|
}
|
};
|
this.setErrno(errno);
|
this.message = ERRNO_MESSAGES[errno];
|
if (this.stack) {
|
Object.defineProperty(this, "stack", {
|
value: new Error().stack,
|
writable: true
|
});
|
this.stack = demangleAll(this.stack);
|
}
|
};
|
FS.ErrnoError.prototype = new Error();
|
FS.ErrnoError.prototype.constructor = FS.ErrnoError;
|
[ 44 ].forEach(function(code) {
|
FS.genericErrors[code] = new FS.ErrnoError(code);
|
FS.genericErrors[code].stack = "<generic error, no stack>";
|
});
|
},
|
staticInit: function() {
|
FS.ensureErrnoError();
|
FS.nameTable = new Array(4096);
|
FS.mount(MEMFS, {}, "/");
|
FS.createDefaultDirectories();
|
FS.createDefaultDevices();
|
FS.createSpecialDirectories();
|
FS.filesystems = {
|
"MEMFS": MEMFS
|
};
|
},
|
init: function(input, output, error) {
|
assert(!FS.init.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
|
FS.init.initialized = true;
|
FS.ensureErrnoError();
|
Module["stdin"] = input || Module["stdin"];
|
Module["stdout"] = output || Module["stdout"];
|
Module["stderr"] = error || Module["stderr"];
|
FS.createStandardStreams();
|
},
|
quit: function() {
|
FS.init.initialized = false;
|
var fflush = Module["_fflush"];
|
if (fflush) fflush(0);
|
for (var i = 0; i < FS.streams.length; i++) {
|
var stream = FS.streams[i];
|
if (!stream) {
|
continue;
|
}
|
FS.close(stream);
|
}
|
},
|
getMode: function(canRead, canWrite) {
|
var mode = 0;
|
if (canRead) mode |= 292 | 73;
|
if (canWrite) mode |= 146;
|
return mode;
|
},
|
findObject: function(path, dontResolveLastLink) {
|
var ret = FS.analyzePath(path, dontResolveLastLink);
|
if (ret.exists) {
|
return ret.object;
|
} else {
|
return null;
|
}
|
},
|
analyzePath: function(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: function(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: function(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: function(parent, name, data, canRead, canWrite, canOwn) {
|
var path = name ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(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: function(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: function(stream) {
|
stream.seekable = false;
|
},
|
close: function(stream) {
|
if (output && output.buffer && output.buffer.length) {
|
output(10);
|
}
|
},
|
read: function(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: function(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: function(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: function(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 = function(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);
|
if (typeof Uint8Array != "undefined") 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 || []);
|
} else {
|
return intArrayFromString(xhr.responseText || "", true);
|
}
|
};
|
var lazyArray = this;
|
lazyArray.setDataGetter(function(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(function(key) {
|
var fn = node.stream_ops[key];
|
stream_ops[key] = function forceLoadLazyFile() {
|
FS.forceLoadFile(node);
|
return fn.apply(null, arguments);
|
};
|
});
|
stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
|
FS.forceLoadFile(node);
|
var contents = stream.node.contents;
|
if (position >= contents.length) return 0;
|
var size = Math.min(contents.length - position, length);
|
assert(size >= 0);
|
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;
|
};
|
node.stream_ops = stream_ops;
|
return node;
|
},
|
createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {
|
Browser.init();
|
var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
|
var dep = getUniqueRunDependency("cp " + fullname);
|
function processData(byteArray) {
|
function finish(byteArray) {
|
if (preFinish) preFinish();
|
if (!dontCreateFile) {
|
FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
|
}
|
if (onload) onload();
|
removeRunDependency(dep);
|
}
|
var handled = false;
|
Module["preloadPlugins"].forEach(function(plugin) {
|
if (handled) return;
|
if (plugin["canHandle"](fullname)) {
|
plugin["handle"](byteArray, fullname, finish, function() {
|
if (onerror) onerror();
|
removeRunDependency(dep);
|
});
|
handled = true;
|
}
|
});
|
if (!handled) finish(byteArray);
|
}
|
addRunDependency(dep);
|
if (typeof url == "string") {
|
Browser.asyncLoad(url, function(byteArray) {
|
processData(byteArray);
|
}, onerror);
|
} else {
|
processData(url);
|
}
|
},
|
indexedDB: function() {
|
return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
},
|
DB_NAME: function() {
|
return "EM_FS_" + window.location.pathname;
|
},
|
DB_VERSION: 20,
|
DB_STORE_NAME: "FILE_DATA",
|
saveFilesToDB: function(paths, onload, onerror) {
|
onload = onload || function() {};
|
onerror = onerror || function() {};
|
var indexedDB = FS.indexedDB();
|
try {
|
var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
|
} catch (e) {
|
return onerror(e);
|
}
|
openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
|
out("creating db");
|
var db = openRequest.result;
|
db.createObjectStore(FS.DB_STORE_NAME);
|
};
|
openRequest.onsuccess = function 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(function(path) {
|
var putRequest = files.put(FS.analyzePath(path).object.contents, path);
|
putRequest.onsuccess = function putRequest_onsuccess() {
|
ok++;
|
if (ok + fail == total) finish();
|
};
|
putRequest.onerror = function putRequest_onerror() {
|
fail++;
|
if (ok + fail == total) finish();
|
};
|
});
|
transaction.onerror = onerror;
|
};
|
openRequest.onerror = onerror;
|
},
|
loadFilesFromDB: function(paths, onload, onerror) {
|
onload = onload || function() {};
|
onerror = onerror || function() {};
|
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 = function 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(function(path) {
|
var getRequest = files.get(path);
|
getRequest.onsuccess = function 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 = function getRequest_onerror() {
|
fail++;
|
if (ok + fail == total) finish();
|
};
|
});
|
transaction.onerror = onerror;
|
};
|
openRequest.onerror = onerror;
|
},
|
absolutePath: function() {
|
abort("FS.absolutePath has been removed; use PATH_FS.resolve instead");
|
},
|
createFolder: function() {
|
abort("FS.createFolder has been removed; use FS.mkdir instead");
|
},
|
createLink: function() {
|
abort("FS.createLink has been removed; use FS.symlink instead");
|
},
|
joinPath: function() {
|
abort("FS.joinPath has been removed; use PATH.join instead");
|
},
|
mmapAlloc: function() {
|
abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc");
|
},
|
standardizePath: function() {
|
abort("FS.standardizePath has been removed; use PATH.normalize instead");
|
}
|
};
|
|
var SYSCALLS = {
|
mappings: {},
|
DEFAULT_POLLMASK: 5,
|
umask: 511,
|
calculateAt: function(dirfd, path, allowEmpty) {
|
if (path[0] === "/") {
|
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;
|
}
|
GROWABLE_HEAP_I32()[buf >> 2] = stat.dev;
|
GROWABLE_HEAP_I32()[buf + 4 >> 2] = 0;
|
GROWABLE_HEAP_I32()[buf + 8 >> 2] = stat.ino;
|
GROWABLE_HEAP_I32()[buf + 12 >> 2] = stat.mode;
|
GROWABLE_HEAP_I32()[buf + 16 >> 2] = stat.nlink;
|
GROWABLE_HEAP_I32()[buf + 20 >> 2] = stat.uid;
|
GROWABLE_HEAP_I32()[buf + 24 >> 2] = stat.gid;
|
GROWABLE_HEAP_I32()[buf + 28 >> 2] = stat.rdev;
|
GROWABLE_HEAP_I32()[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) ],
|
GROWABLE_HEAP_I32()[buf + 40 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 44 >> 2] = tempI64[1];
|
GROWABLE_HEAP_I32()[buf + 48 >> 2] = 4096;
|
GROWABLE_HEAP_I32()[buf + 52 >> 2] = stat.blocks;
|
GROWABLE_HEAP_I32()[buf + 56 >> 2] = stat.atime.getTime() / 1e3 | 0;
|
GROWABLE_HEAP_I32()[buf + 60 >> 2] = 0;
|
GROWABLE_HEAP_I32()[buf + 64 >> 2] = stat.mtime.getTime() / 1e3 | 0;
|
GROWABLE_HEAP_I32()[buf + 68 >> 2] = 0;
|
GROWABLE_HEAP_I32()[buf + 72 >> 2] = stat.ctime.getTime() / 1e3 | 0;
|
GROWABLE_HEAP_I32()[buf + 76 >> 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) ],
|
GROWABLE_HEAP_I32()[buf + 80 >> 2] = tempI64[0], GROWABLE_HEAP_I32()[buf + 84 >> 2] = tempI64[1];
|
return 0;
|
},
|
doMsync: function(addr, stream, len, flags, offset) {
|
var buffer = GROWABLE_HEAP_U8().slice(addr, addr + len);
|
FS.msync(stream, buffer, offset, len, flags);
|
},
|
doMkdir: function(path, mode) {
|
path = PATH.normalize(path);
|
if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1);
|
FS.mkdir(path, mode, 0);
|
return 0;
|
},
|
doMknod: function(path, mode, dev) {
|
switch (mode & 61440) {
|
case 32768:
|
case 8192:
|
case 24576:
|
case 4096:
|
case 49152:
|
break;
|
|
default:
|
return -28;
|
}
|
FS.mknod(path, mode, dev);
|
return 0;
|
},
|
doReadlink: function(path, buf, bufsize) {
|
if (bufsize <= 0) return -28;
|
var ret = FS.readlink(path);
|
var len = Math.min(bufsize, lengthBytesUTF8(ret));
|
var endChar = GROWABLE_HEAP_I8()[buf + len];
|
stringToUTF8(ret, buf, bufsize + 1);
|
GROWABLE_HEAP_I8()[buf + len] = endChar;
|
return len;
|
},
|
doAccess: function(path, amode) {
|
if (amode & ~7) {
|
return -28;
|
}
|
var node;
|
var lookup = FS.lookupPath(path, {
|
follow: true
|
});
|
node = lookup.node;
|
if (!node) {
|
return -44;
|
}
|
var perms = "";
|
if (amode & 4) perms += "r";
|
if (amode & 2) perms += "w";
|
if (amode & 1) perms += "x";
|
if (perms && FS.nodePermissions(node, perms)) {
|
return -2;
|
}
|
return 0;
|
},
|
doDup: function(path, flags, suggestFD) {
|
var suggest = FS.getStream(suggestFD);
|
if (suggest) FS.close(suggest);
|
return FS.open(path, flags, 0, suggestFD, suggestFD).fd;
|
},
|
doReadv: function(stream, iov, iovcnt, offset) {
|
var ret = 0;
|
for (var i = 0; i < iovcnt; i++) {
|
var ptr = GROWABLE_HEAP_I32()[iov + i * 8 >> 2];
|
var len = GROWABLE_HEAP_I32()[iov + (i * 8 + 4) >> 2];
|
var curr = FS.read(stream, GROWABLE_HEAP_I8(), ptr, len, offset);
|
if (curr < 0) return -1;
|
ret += curr;
|
if (curr < len) break;
|
}
|
return ret;
|
},
|
doWritev: function(stream, iov, iovcnt, offset) {
|
var ret = 0;
|
for (var i = 0; i < iovcnt; i++) {
|
var ptr = GROWABLE_HEAP_I32()[iov + i * 8 >> 2];
|
var len = GROWABLE_HEAP_I32()[iov + (i * 8 + 4) >> 2];
|
var curr = FS.write(stream, GROWABLE_HEAP_I8(), ptr, len, offset);
|
if (curr < 0) return -1;
|
ret += curr;
|
}
|
return ret;
|
},
|
varargs: undefined,
|
get: function() {
|
assert(SYSCALLS.varargs != undefined);
|
SYSCALLS.varargs += 4;
|
var ret = GROWABLE_HEAP_I32()[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;
|
},
|
get64: function(low, high) {
|
if (low >= 0) assert(high === 0); else assert(high === -1);
|
return low;
|
}
|
};
|
|
function ___sys_fcntl64(fd, cmd, varargs) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(5, 1, 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.open(stream.path, stream.flags, 0, 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 12:
|
{
|
var arg = SYSCALLS.get();
|
var offset = 0;
|
GROWABLE_HEAP_I16()[arg + offset >> 1] = 2;
|
return 0;
|
}
|
|
case 13:
|
case 14:
|
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)) abort(e);
|
return -e.errno;
|
}
|
}
|
|
function ___sys_ioctl(fd, op, varargs) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(6, 1, fd, op, varargs);
|
SYSCALLS.varargs = varargs;
|
try {
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
switch (op) {
|
case 21509:
|
case 21505:
|
{
|
if (!stream.tty) return -59;
|
return 0;
|
}
|
|
case 21510:
|
case 21511:
|
case 21512:
|
case 21506:
|
case 21507:
|
case 21508:
|
{
|
if (!stream.tty) return -59;
|
return 0;
|
}
|
|
case 21519:
|
{
|
if (!stream.tty) return -59;
|
var argp = SYSCALLS.get();
|
GROWABLE_HEAP_I32()[argp >> 2] = 0;
|
return 0;
|
}
|
|
case 21520:
|
{
|
if (!stream.tty) return -59;
|
return -28;
|
}
|
|
case 21531:
|
{
|
var argp = SYSCALLS.get();
|
return FS.ioctl(stream, op, argp);
|
}
|
|
case 21523:
|
{
|
if (!stream.tty) return -59;
|
return 0;
|
}
|
|
case 21524:
|
{
|
if (!stream.tty) return -59;
|
return 0;
|
}
|
|
default:
|
abort("bad ioctl syscall " + op);
|
}
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return -e.errno;
|
}
|
}
|
|
function ___sys_open(path, flags, varargs) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(7, 1, path, flags, varargs);
|
SYSCALLS.varargs = varargs;
|
try {
|
var pathname = SYSCALLS.getStr(path);
|
var mode = varargs ? SYSCALLS.get() : 0;
|
var stream = FS.open(pathname, flags, mode);
|
return stream.fd;
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return -e.errno;
|
}
|
}
|
|
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 (GROWABLE_HEAP_U8()[c]) {
|
ret += embind_charCodes[GROWABLE_HEAP_U8()[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;
|
} else {
|
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(function(dt, i) {
|
if (registeredTypes.hasOwnProperty(dt)) {
|
typeConverters[i] = registeredTypes[dt];
|
} else {
|
unregisteredTypes.push(dt);
|
if (!awaitingDependencies.hasOwnProperty(dt)) {
|
awaitingDependencies[dt] = [];
|
}
|
awaitingDependencies[dt].push(function() {
|
typeConverters[i] = registeredTypes[dt];
|
++registered;
|
if (registered === unregisteredTypes.length) {
|
onComplete(typeConverters);
|
}
|
});
|
}
|
});
|
if (0 === unregisteredTypes.length) {
|
onComplete(typeConverters);
|
}
|
}
|
|
function registerType(rawType, registeredInstance, options) {
|
options = options || {};
|
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(function(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 = GROWABLE_HEAP_I8();
|
} else if (size === 2) {
|
heap = GROWABLE_HEAP_I16();
|
} else if (size === 4) {
|
heap = GROWABLE_HEAP_I32();
|
} else {
|
throw new TypeError("Unknown boolean type size: " + name);
|
}
|
return this["fromWireType"](heap[pointer >> shift]);
|
},
|
destructorFunction: null
|
});
|
}
|
|
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;
|
}
|
|
function __emval_register(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 simpleReadValueFromPointer(pointer) {
|
return this["fromWireType"](GROWABLE_HEAP_U32()[pointer >> 2]);
|
}
|
|
function __embind_register_emval(rawType, name) {
|
name = readLatin1String(name);
|
registerType(rawType, {
|
name: name,
|
"fromWireType": function(handle) {
|
var rv = emval_handle_array[handle].value;
|
__emval_decref(handle);
|
return rv;
|
},
|
"toWireType": function(destructors, value) {
|
return __emval_register(value);
|
},
|
"argPackAdvance": 8,
|
"readValueFromPointer": simpleReadValueFromPointer,
|
destructorFunction: null
|
});
|
}
|
|
function _embind_repr(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"](GROWABLE_HEAP_F32()[pointer >> 2]);
|
};
|
|
case 3:
|
return function(pointer) {
|
return this["fromWireType"](GROWABLE_HEAP_F64()[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) {
|
if (typeof value !== "number" && typeof value !== "boolean") {
|
throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
|
}
|
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 GROWABLE_HEAP_I8()[pointer];
|
} : function readU8FromPointer(pointer) {
|
return GROWABLE_HEAP_U8()[pointer];
|
};
|
|
case 1:
|
return signed ? function readS16FromPointer(pointer) {
|
return GROWABLE_HEAP_I16()[pointer >> 1];
|
} : function readU16FromPointer(pointer) {
|
return GROWABLE_HEAP_U16()[pointer >> 1];
|
};
|
|
case 2:
|
return signed ? function readS32FromPointer(pointer) {
|
return GROWABLE_HEAP_I32()[pointer >> 2];
|
} : function readU32FromPointer(pointer) {
|
return GROWABLE_HEAP_U32()[pointer >> 2];
|
};
|
|
default:
|
throw new TypeError("Unknown integer type: " + name);
|
}
|
}
|
|
function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
|
name = readLatin1String(name);
|
if (maxRange === -1) {
|
maxRange = 4294967295;
|
}
|
var shift = getShiftFromSize(size);
|
var fromWireType = function(value) {
|
return value;
|
};
|
if (minRange === 0) {
|
var bitshift = 32 - 8 * size;
|
fromWireType = function(value) {
|
return value << bitshift >>> bitshift;
|
};
|
}
|
var isUnsignedType = name.indexOf("unsigned") != -1;
|
registerType(primitiveType, {
|
name: name,
|
"fromWireType": fromWireType,
|
"toWireType": function(destructors, value) {
|
if (typeof value !== "number" && typeof value !== "boolean") {
|
throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
|
}
|
if (value < minRange || value > maxRange) {
|
throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ", " + maxRange + "]!");
|
}
|
return isUnsignedType ? value >>> 0 : value | 0;
|
},
|
"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 = GROWABLE_HEAP_U32();
|
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 = GROWABLE_HEAP_U32()[value >> 2];
|
var str;
|
if (stdStringIsUTF8) {
|
var decodeStartPtr = value + 4;
|
for (var i = 0; i <= length; ++i) {
|
var currentBytePtr = value + 4 + i;
|
if (i == length || GROWABLE_HEAP_U8()[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(GROWABLE_HEAP_U8()[value + 4 + i]);
|
}
|
str = a.join("");
|
}
|
_free(value);
|
return str;
|
},
|
"toWireType": function(destructors, value) {
|
if (value instanceof ArrayBuffer) {
|
value = new Uint8Array(value);
|
}
|
var getLength;
|
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) {
|
getLength = function() {
|
return lengthBytesUTF8(value);
|
};
|
} else {
|
getLength = function() {
|
return value.length;
|
};
|
}
|
var length = getLength();
|
var ptr = _malloc(4 + length + 1);
|
GROWABLE_HEAP_U32()[ptr >> 2] = length;
|
if (stdStringIsUTF8 && valueIsOfTypeString) {
|
stringToUTF8(value, ptr + 4, 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");
|
}
|
GROWABLE_HEAP_U8()[ptr + 4 + i] = charCode;
|
}
|
} else {
|
for (var i = 0; i < length; ++i) {
|
GROWABLE_HEAP_U8()[ptr + 4 + i] = value[i];
|
}
|
}
|
}
|
if (destructors !== null) {
|
destructors.push(_free, ptr);
|
}
|
return ptr;
|
},
|
"argPackAdvance": 8,
|
"readValueFromPointer": simpleReadValueFromPointer,
|
destructorFunction: function(ptr) {
|
_free(ptr);
|
}
|
});
|
}
|
|
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 = function() {
|
return GROWABLE_HEAP_U16();
|
};
|
shift = 1;
|
} else if (charSize === 4) {
|
decodeString = UTF32ToString;
|
encodeString = stringToUTF32;
|
lengthBytesUTF = lengthBytesUTF32;
|
getHeap = function() {
|
return GROWABLE_HEAP_U32();
|
};
|
shift = 2;
|
}
|
registerType(rawType, {
|
name: name,
|
"fromWireType": function(value) {
|
var length = GROWABLE_HEAP_U32()[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);
|
GROWABLE_HEAP_U32()[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_notify_thread_queue(targetThreadId, mainThreadId) {
|
if (targetThreadId == mainThreadId) {
|
postMessage({
|
"cmd": "processQueuedMainThreadWork"
|
});
|
} else if (ENVIRONMENT_IS_PTHREAD) {
|
postMessage({
|
"targetThread": targetThreadId,
|
"cmd": "processThreadQueue"
|
});
|
} else {
|
var pthread = PThread.pthreads[targetThreadId];
|
var worker = pthread && pthread.worker;
|
if (!worker) {
|
err("Cannot send message to thread with ID " + targetThreadId + ", unknown thread ID!");
|
return;
|
}
|
worker.postMessage({
|
"cmd": "processThreadQueue"
|
});
|
}
|
return 1;
|
}
|
|
function _abort() {
|
abort();
|
}
|
|
function _emscripten_set_main_loop_timing(mode, value) {
|
Browser.mainLoop.timingMode = mode;
|
Browser.mainLoop.timingValue = value;
|
if (!Browser.mainLoop.func) {
|
console.error("emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.");
|
return 1;
|
}
|
if (!Browser.mainLoop.running) {
|
runtimeKeepalivePush();
|
Browser.mainLoop.running = true;
|
}
|
if (mode == 0) {
|
Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() {
|
var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0;
|
setTimeout(Browser.mainLoop.runner, timeUntilNextTick);
|
};
|
Browser.mainLoop.method = "timeout";
|
} else if (mode == 1) {
|
Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
|
Browser.requestAnimationFrame(Browser.mainLoop.runner);
|
};
|
Browser.mainLoop.method = "rAF";
|
} else if (mode == 2) {
|
if (typeof setImmediate === "undefined") {
|
var setImmediates = [];
|
var emscriptenMainLoopMessageId = "setimmediate";
|
var Browser_setImmediate_messageHandler = function(event) {
|
if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) {
|
event.stopPropagation();
|
setImmediates.shift()();
|
}
|
};
|
addEventListener("message", Browser_setImmediate_messageHandler, true);
|
setImmediate = function Browser_emulated_setImmediate(func) {
|
setImmediates.push(func);
|
if (ENVIRONMENT_IS_WORKER) {
|
if (Module["setImmediates"] === undefined) Module["setImmediates"] = [];
|
Module["setImmediates"].push(func);
|
postMessage({
|
target: emscriptenMainLoopMessageId
|
});
|
} else postMessage(emscriptenMainLoopMessageId, "*");
|
};
|
}
|
Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() {
|
setImmediate(Browser.mainLoop.runner);
|
};
|
Browser.mainLoop.method = "immediate";
|
}
|
return 0;
|
}
|
|
function runtimeKeepalivePush() {
|
runtimeKeepaliveCounter += 1;
|
}
|
|
function _exit(status) {
|
exit(status);
|
}
|
|
function _pthread_exit(status) {
|
if (!ENVIRONMENT_IS_PTHREAD) _exit(status); else PThread.threadExit(status);
|
if (ENVIRONMENT_IS_NODE) {
|
process.exit(status);
|
}
|
throw "unwind";
|
}
|
|
function maybeExit() {
|
if (!keepRuntimeAlive()) {
|
try {
|
if (ENVIRONMENT_IS_PTHREAD) _pthread_exit(EXITSTATUS); else _exit(EXITSTATUS);
|
} catch (e) {
|
if (e instanceof ExitStatus) {
|
return;
|
}
|
throw e;
|
}
|
}
|
}
|
|
function setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop, arg, noSetTiming) {
|
assert(!Browser.mainLoop.func, "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.");
|
Browser.mainLoop.func = browserIterationFunc;
|
Browser.mainLoop.arg = arg;
|
var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;
|
function checkIsRunning() {
|
if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) {
|
runtimeKeepalivePop();
|
maybeExit();
|
return false;
|
}
|
return true;
|
}
|
Browser.mainLoop.running = false;
|
Browser.mainLoop.runner = function Browser_mainLoop_runner() {
|
if (ABORT) return;
|
if (Browser.mainLoop.queue.length > 0) {
|
var start = Date.now();
|
var blocker = Browser.mainLoop.queue.shift();
|
blocker.func(blocker.arg);
|
if (Browser.mainLoop.remainingBlockers) {
|
var remaining = Browser.mainLoop.remainingBlockers;
|
var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
|
if (blocker.counted) {
|
Browser.mainLoop.remainingBlockers = next;
|
} else {
|
next = next + .5;
|
Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9;
|
}
|
}
|
console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms");
|
Browser.mainLoop.updateStatus();
|
if (!checkIsRunning()) return;
|
setTimeout(Browser.mainLoop.runner, 0);
|
return;
|
}
|
if (!checkIsRunning()) return;
|
Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0;
|
if (Browser.mainLoop.timingMode == 1 && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) {
|
Browser.mainLoop.scheduler();
|
return;
|
} else if (Browser.mainLoop.timingMode == 0) {
|
Browser.mainLoop.tickStartTime = _emscripten_get_now();
|
}
|
if (typeof GL !== "undefined" && GL.currentContext && !GL.currentContextIsProxied && !GL.currentContext.attributes.explicitSwapControl && GL.currentContext.GLctx.commit) {
|
GL.currentContext.GLctx.commit();
|
}
|
if (Browser.mainLoop.method === "timeout" && Module.ctx) {
|
warnOnce("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!");
|
Browser.mainLoop.method = "";
|
}
|
Browser.mainLoop.runIter(browserIterationFunc);
|
checkStackCookie();
|
if (!checkIsRunning()) return;
|
if (typeof SDL === "object" && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData();
|
Browser.mainLoop.scheduler();
|
};
|
if (!noSetTiming) {
|
if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps); else _emscripten_set_main_loop_timing(1, 1);
|
Browser.mainLoop.scheduler();
|
}
|
if (simulateInfiniteLoop) {
|
throw "unwind";
|
}
|
}
|
|
function callUserCallback(func) {
|
if (ABORT) {
|
err("user callback triggered after application aborted. Ignoring.");
|
return;
|
}
|
try {
|
func();
|
} catch (e) {
|
if (e instanceof ExitStatus) {
|
return;
|
} else if (e !== "unwind") {
|
if (e && typeof e === "object" && e.stack) err("exception thrown: " + [ e, e.stack ]);
|
throw e;
|
}
|
}
|
if (ENVIRONMENT_IS_PTHREAD) maybeExit();
|
}
|
|
function runtimeKeepalivePop() {
|
assert(runtimeKeepaliveCounter > 0);
|
runtimeKeepaliveCounter -= 1;
|
}
|
|
var Browser = {
|
mainLoop: {
|
running: false,
|
scheduler: null,
|
method: "",
|
currentlyRunningMainloop: 0,
|
func: null,
|
arg: 0,
|
timingMode: 0,
|
timingValue: 0,
|
currentFrameNumber: 0,
|
queue: [],
|
pause: function() {
|
Browser.mainLoop.scheduler = null;
|
Browser.mainLoop.currentlyRunningMainloop++;
|
},
|
resume: function() {
|
Browser.mainLoop.currentlyRunningMainloop++;
|
var timingMode = Browser.mainLoop.timingMode;
|
var timingValue = Browser.mainLoop.timingValue;
|
var func = Browser.mainLoop.func;
|
Browser.mainLoop.func = null;
|
setMainLoop(func, 0, false, Browser.mainLoop.arg, true);
|
_emscripten_set_main_loop_timing(timingMode, timingValue);
|
Browser.mainLoop.scheduler();
|
},
|
updateStatus: function() {
|
if (Module["setStatus"]) {
|
var message = Module["statusMessage"] || "Please wait...";
|
var remaining = Browser.mainLoop.remainingBlockers;
|
var expected = Browser.mainLoop.expectedBlockers;
|
if (remaining) {
|
if (remaining < expected) {
|
Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")");
|
} else {
|
Module["setStatus"](message);
|
}
|
} else {
|
Module["setStatus"]("");
|
}
|
}
|
},
|
runIter: function(func) {
|
if (ABORT) return;
|
if (Module["preMainLoop"]) {
|
var preRet = Module["preMainLoop"]();
|
if (preRet === false) {
|
return;
|
}
|
}
|
callUserCallback(func);
|
if (Module["postMainLoop"]) Module["postMainLoop"]();
|
}
|
},
|
isFullscreen: false,
|
pointerLock: false,
|
moduleContextCreatedCallbacks: [],
|
workers: [],
|
init: function() {
|
if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
|
if (Browser.initted) return;
|
Browser.initted = true;
|
try {
|
new Blob();
|
Browser.hasBlobConstructor = true;
|
} catch (e) {
|
Browser.hasBlobConstructor = false;
|
console.log("warning: no blob constructor, cannot create blobs with mimetypes");
|
}
|
Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : !Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null;
|
Browser.URLObject = typeof window != "undefined" ? window.URL ? window.URL : window.webkitURL : undefined;
|
if (!Module.noImageDecoding && typeof Browser.URLObject === "undefined") {
|
console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
|
Module.noImageDecoding = true;
|
}
|
var imagePlugin = {};
|
imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
|
return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
|
};
|
imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) {
|
var b = null;
|
if (Browser.hasBlobConstructor) {
|
try {
|
b = new Blob([ byteArray ], {
|
type: Browser.getMimetype(name)
|
});
|
if (b.size !== byteArray.length) {
|
b = new Blob([ new Uint8Array(byteArray).buffer ], {
|
type: Browser.getMimetype(name)
|
});
|
}
|
} catch (e) {
|
warnOnce("Blob constructor present but fails: " + e + "; falling back to blob builder");
|
}
|
}
|
if (!b) {
|
var bb = new Browser.BlobBuilder();
|
bb.append(new Uint8Array(byteArray).buffer);
|
b = bb.getBlob();
|
}
|
var url = Browser.URLObject.createObjectURL(b);
|
assert(typeof url == "string", "createObjectURL must return a url as a string");
|
var img = new Image();
|
img.onload = function img_onload() {
|
assert(img.complete, "Image " + name + " could not be decoded");
|
var canvas = document.createElement("canvas");
|
canvas.width = img.width;
|
canvas.height = img.height;
|
var ctx = canvas.getContext("2d");
|
ctx.drawImage(img, 0, 0);
|
Module["preloadedImages"][name] = canvas;
|
Browser.URLObject.revokeObjectURL(url);
|
if (onload) onload(byteArray);
|
};
|
img.onerror = function img_onerror(event) {
|
console.log("Image " + url + " could not be decoded");
|
if (onerror) onerror();
|
};
|
img.src = url;
|
};
|
Module["preloadPlugins"].push(imagePlugin);
|
var audioPlugin = {};
|
audioPlugin["canHandle"] = function audioPlugin_canHandle(name) {
|
return !Module.noAudioDecoding && name.substr(-4) in {
|
".ogg": 1,
|
".wav": 1,
|
".mp3": 1
|
};
|
};
|
audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) {
|
var done = false;
|
function finish(audio) {
|
if (done) return;
|
done = true;
|
Module["preloadedAudios"][name] = audio;
|
if (onload) onload(byteArray);
|
}
|
function fail() {
|
if (done) return;
|
done = true;
|
Module["preloadedAudios"][name] = new Audio();
|
if (onerror) onerror();
|
}
|
if (Browser.hasBlobConstructor) {
|
try {
|
var b = new Blob([ byteArray ], {
|
type: Browser.getMimetype(name)
|
});
|
} catch (e) {
|
return fail();
|
}
|
var url = Browser.URLObject.createObjectURL(b);
|
assert(typeof url == "string", "createObjectURL must return a url as a string");
|
var audio = new Audio();
|
audio.addEventListener("canplaythrough", function() {
|
finish(audio);
|
}, false);
|
audio.onerror = function audio_onerror(event) {
|
if (done) return;
|
console.log("warning: browser could not fully decode audio " + name + ", trying slower base64 approach");
|
function encode64(data) {
|
var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
var PAD = "=";
|
var ret = "";
|
var leftchar = 0;
|
var leftbits = 0;
|
for (var i = 0; i < data.length; i++) {
|
leftchar = leftchar << 8 | data[i];
|
leftbits += 8;
|
while (leftbits >= 6) {
|
var curr = leftchar >> leftbits - 6 & 63;
|
leftbits -= 6;
|
ret += BASE[curr];
|
}
|
}
|
if (leftbits == 2) {
|
ret += BASE[(leftchar & 3) << 4];
|
ret += PAD + PAD;
|
} else if (leftbits == 4) {
|
ret += BASE[(leftchar & 15) << 2];
|
ret += PAD;
|
}
|
return ret;
|
}
|
audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray);
|
finish(audio);
|
};
|
audio.src = url;
|
Browser.safeSetTimeout(function() {
|
finish(audio);
|
}, 1e4);
|
} else {
|
return fail();
|
}
|
};
|
Module["preloadPlugins"].push(audioPlugin);
|
function pointerLockChange() {
|
Browser.pointerLock = document["pointerLockElement"] === Module["canvas"] || document["mozPointerLockElement"] === Module["canvas"] || document["webkitPointerLockElement"] === Module["canvas"] || document["msPointerLockElement"] === Module["canvas"];
|
}
|
var canvas = Module["canvas"];
|
if (canvas) {
|
canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || function() {};
|
canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || function() {};
|
canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
|
document.addEventListener("pointerlockchange", pointerLockChange, false);
|
document.addEventListener("mozpointerlockchange", pointerLockChange, false);
|
document.addEventListener("webkitpointerlockchange", pointerLockChange, false);
|
document.addEventListener("mspointerlockchange", pointerLockChange, false);
|
if (Module["elementPointerLock"]) {
|
canvas.addEventListener("click", function(ev) {
|
if (!Browser.pointerLock && Module["canvas"].requestPointerLock) {
|
Module["canvas"].requestPointerLock();
|
ev.preventDefault();
|
}
|
}, false);
|
}
|
}
|
},
|
createContext: function(canvas, useWebGL, setInModule, webGLContextAttributes) {
|
if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx;
|
var ctx;
|
var contextHandle;
|
if (useWebGL) {
|
var contextAttributes = {
|
antialias: false,
|
alpha: false,
|
majorVersion: typeof WebGL2RenderingContext !== "undefined" ? 2 : 1
|
};
|
if (webGLContextAttributes) {
|
for (var attribute in webGLContextAttributes) {
|
contextAttributes[attribute] = webGLContextAttributes[attribute];
|
}
|
}
|
if (typeof GL !== "undefined") {
|
contextHandle = GL.createContext(canvas, contextAttributes);
|
if (contextHandle) {
|
ctx = GL.getContext(contextHandle).GLctx;
|
}
|
}
|
} else {
|
ctx = canvas.getContext("2d");
|
}
|
if (!ctx) return null;
|
if (setInModule) {
|
if (!useWebGL) assert(typeof GLctx === "undefined", "cannot set in module if GLctx is used, but we are a non-GL context that would replace it");
|
Module.ctx = ctx;
|
if (useWebGL) GL.makeContextCurrent(contextHandle);
|
Module.useWebGL = useWebGL;
|
Browser.moduleContextCreatedCallbacks.forEach(function(callback) {
|
callback();
|
});
|
Browser.init();
|
}
|
return ctx;
|
},
|
destroyContext: function(canvas, useWebGL, setInModule) {},
|
fullscreenHandlersInstalled: false,
|
lockPointer: undefined,
|
resizeCanvas: undefined,
|
requestFullscreen: function(lockPointer, resizeCanvas) {
|
Browser.lockPointer = lockPointer;
|
Browser.resizeCanvas = resizeCanvas;
|
if (typeof Browser.lockPointer === "undefined") Browser.lockPointer = true;
|
if (typeof Browser.resizeCanvas === "undefined") Browser.resizeCanvas = false;
|
var canvas = Module["canvas"];
|
function fullscreenChange() {
|
Browser.isFullscreen = false;
|
var canvasContainer = canvas.parentNode;
|
if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvasContainer) {
|
canvas.exitFullscreen = Browser.exitFullscreen;
|
if (Browser.lockPointer) canvas.requestPointerLock();
|
Browser.isFullscreen = true;
|
if (Browser.resizeCanvas) {
|
Browser.setFullscreenCanvasSize();
|
} else {
|
Browser.updateCanvasDimensions(canvas);
|
}
|
} else {
|
canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
|
canvasContainer.parentNode.removeChild(canvasContainer);
|
if (Browser.resizeCanvas) {
|
Browser.setWindowedCanvasSize();
|
} else {
|
Browser.updateCanvasDimensions(canvas);
|
}
|
}
|
if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen);
|
if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen);
|
}
|
if (!Browser.fullscreenHandlersInstalled) {
|
Browser.fullscreenHandlersInstalled = true;
|
document.addEventListener("fullscreenchange", fullscreenChange, false);
|
document.addEventListener("mozfullscreenchange", fullscreenChange, false);
|
document.addEventListener("webkitfullscreenchange", fullscreenChange, false);
|
document.addEventListener("MSFullscreenChange", fullscreenChange, false);
|
}
|
var canvasContainer = document.createElement("div");
|
canvas.parentNode.insertBefore(canvasContainer, canvas);
|
canvasContainer.appendChild(canvas);
|
canvasContainer.requestFullscreen = canvasContainer["requestFullscreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullscreen"] ? function() {
|
canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]);
|
} : null) || (canvasContainer["webkitRequestFullScreen"] ? function() {
|
canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]);
|
} : null);
|
canvasContainer.requestFullscreen();
|
},
|
requestFullScreen: function() {
|
abort("Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)");
|
},
|
exitFullscreen: function() {
|
if (!Browser.isFullscreen) {
|
return false;
|
}
|
var CFS = document["exitFullscreen"] || document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["msExitFullscreen"] || document["webkitCancelFullScreen"] || function() {};
|
CFS.apply(document, []);
|
return true;
|
},
|
nextRAF: 0,
|
fakeRequestAnimationFrame: function(func) {
|
var now = Date.now();
|
if (Browser.nextRAF === 0) {
|
Browser.nextRAF = now + 1e3 / 60;
|
} else {
|
while (now + 2 >= Browser.nextRAF) {
|
Browser.nextRAF += 1e3 / 60;
|
}
|
}
|
var delay = Math.max(Browser.nextRAF - now, 0);
|
setTimeout(func, delay);
|
},
|
requestAnimationFrame: function(func) {
|
if (typeof requestAnimationFrame === "function") {
|
requestAnimationFrame(func);
|
return;
|
}
|
var RAF = Browser.fakeRequestAnimationFrame;
|
RAF(func);
|
},
|
safeRequestAnimationFrame: function(func) {
|
runtimeKeepalivePush();
|
return Browser.requestAnimationFrame(function() {
|
runtimeKeepalivePop();
|
callUserCallback(func);
|
});
|
},
|
safeSetTimeout: function(func, timeout) {
|
runtimeKeepalivePush();
|
return setTimeout(function() {
|
runtimeKeepalivePop();
|
callUserCallback(func);
|
}, timeout);
|
},
|
getMimetype: function(name) {
|
return {
|
"jpg": "image/jpeg",
|
"jpeg": "image/jpeg",
|
"png": "image/png",
|
"bmp": "image/bmp",
|
"ogg": "audio/ogg",
|
"wav": "audio/wav",
|
"mp3": "audio/mpeg"
|
}[name.substr(name.lastIndexOf(".") + 1)];
|
},
|
getUserMedia: function(func) {
|
if (!window.getUserMedia) {
|
window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"];
|
}
|
window.getUserMedia(func);
|
},
|
getMovementX: function(event) {
|
return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0;
|
},
|
getMovementY: function(event) {
|
return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0;
|
},
|
getMouseWheelDelta: function(event) {
|
var delta = 0;
|
switch (event.type) {
|
case "DOMMouseScroll":
|
delta = event.detail / 3;
|
break;
|
|
case "mousewheel":
|
delta = event.wheelDelta / 120;
|
break;
|
|
case "wheel":
|
delta = event.deltaY;
|
switch (event.deltaMode) {
|
case 0:
|
delta /= 100;
|
break;
|
|
case 1:
|
delta /= 3;
|
break;
|
|
case 2:
|
delta *= 80;
|
break;
|
|
default:
|
throw "unrecognized mouse wheel delta mode: " + event.deltaMode;
|
}
|
break;
|
|
default:
|
throw "unrecognized mouse wheel event: " + event.type;
|
}
|
return delta;
|
},
|
mouseX: 0,
|
mouseY: 0,
|
mouseMovementX: 0,
|
mouseMovementY: 0,
|
touches: {},
|
lastTouches: {},
|
calculateMouseEvent: function(event) {
|
if (Browser.pointerLock) {
|
if (event.type != "mousemove" && "mozMovementX" in event) {
|
Browser.mouseMovementX = Browser.mouseMovementY = 0;
|
} else {
|
Browser.mouseMovementX = Browser.getMovementX(event);
|
Browser.mouseMovementY = Browser.getMovementY(event);
|
}
|
if (typeof SDL != "undefined") {
|
Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
|
Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
|
} else {
|
Browser.mouseX += Browser.mouseMovementX;
|
Browser.mouseY += Browser.mouseMovementY;
|
}
|
} else {
|
var rect = Module["canvas"].getBoundingClientRect();
|
var cw = Module["canvas"].width;
|
var ch = Module["canvas"].height;
|
var scrollX = typeof window.scrollX !== "undefined" ? window.scrollX : window.pageXOffset;
|
var scrollY = typeof window.scrollY !== "undefined" ? window.scrollY : window.pageYOffset;
|
assert(typeof scrollX !== "undefined" && typeof scrollY !== "undefined", "Unable to retrieve scroll position, mouse positions likely broken.");
|
if (event.type === "touchstart" || event.type === "touchend" || event.type === "touchmove") {
|
var touch = event.touch;
|
if (touch === undefined) {
|
return;
|
}
|
var adjustedX = touch.pageX - (scrollX + rect.left);
|
var adjustedY = touch.pageY - (scrollY + rect.top);
|
adjustedX = adjustedX * (cw / rect.width);
|
adjustedY = adjustedY * (ch / rect.height);
|
var coords = {
|
x: adjustedX,
|
y: adjustedY
|
};
|
if (event.type === "touchstart") {
|
Browser.lastTouches[touch.identifier] = coords;
|
Browser.touches[touch.identifier] = coords;
|
} else if (event.type === "touchend" || event.type === "touchmove") {
|
var last = Browser.touches[touch.identifier];
|
if (!last) last = coords;
|
Browser.lastTouches[touch.identifier] = last;
|
Browser.touches[touch.identifier] = coords;
|
}
|
return;
|
}
|
var x = event.pageX - (scrollX + rect.left);
|
var y = event.pageY - (scrollY + rect.top);
|
x = x * (cw / rect.width);
|
y = y * (ch / rect.height);
|
Browser.mouseMovementX = x - Browser.mouseX;
|
Browser.mouseMovementY = y - Browser.mouseY;
|
Browser.mouseX = x;
|
Browser.mouseY = y;
|
}
|
},
|
asyncLoad: function(url, onload, onerror, noRunDep) {
|
var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
|
readAsync(url, function(arrayBuffer) {
|
assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
|
onload(new Uint8Array(arrayBuffer));
|
if (dep) removeRunDependency(dep);
|
}, function(event) {
|
if (onerror) {
|
onerror();
|
} else {
|
throw 'Loading data file "' + url + '" failed.';
|
}
|
});
|
if (dep) addRunDependency(dep);
|
},
|
resizeListeners: [],
|
updateResizeListeners: function() {
|
var canvas = Module["canvas"];
|
Browser.resizeListeners.forEach(function(listener) {
|
listener(canvas.width, canvas.height);
|
});
|
},
|
setCanvasSize: function(width, height, noUpdates) {
|
var canvas = Module["canvas"];
|
Browser.updateCanvasDimensions(canvas, width, height);
|
if (!noUpdates) Browser.updateResizeListeners();
|
},
|
windowedWidth: 0,
|
windowedHeight: 0,
|
setFullscreenCanvasSize: function() {
|
if (typeof SDL != "undefined") {
|
var flags = GROWABLE_HEAP_U32()[SDL.screen >> 2];
|
flags = flags | 8388608;
|
GROWABLE_HEAP_I32()[SDL.screen >> 2] = flags;
|
}
|
Browser.updateCanvasDimensions(Module["canvas"]);
|
Browser.updateResizeListeners();
|
},
|
setWindowedCanvasSize: function() {
|
if (typeof SDL != "undefined") {
|
var flags = GROWABLE_HEAP_U32()[SDL.screen >> 2];
|
flags = flags & ~8388608;
|
GROWABLE_HEAP_I32()[SDL.screen >> 2] = flags;
|
}
|
Browser.updateCanvasDimensions(Module["canvas"]);
|
Browser.updateResizeListeners();
|
},
|
updateCanvasDimensions: function(canvas, wNative, hNative) {
|
if (wNative && hNative) {
|
canvas.widthNative = wNative;
|
canvas.heightNative = hNative;
|
} else {
|
wNative = canvas.widthNative;
|
hNative = canvas.heightNative;
|
}
|
var w = wNative;
|
var h = hNative;
|
if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) {
|
if (w / h < Module["forcedAspectRatio"]) {
|
w = Math.round(h * Module["forcedAspectRatio"]);
|
} else {
|
h = Math.round(w / Module["forcedAspectRatio"]);
|
}
|
}
|
if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvas.parentNode && typeof screen != "undefined") {
|
var factor = Math.min(screen.width / w, screen.height / h);
|
w = Math.round(w * factor);
|
h = Math.round(h * factor);
|
}
|
if (Browser.resizeCanvas) {
|
if (canvas.width != w) canvas.width = w;
|
if (canvas.height != h) canvas.height = h;
|
if (typeof canvas.style != "undefined") {
|
canvas.style.removeProperty("width");
|
canvas.style.removeProperty("height");
|
}
|
} else {
|
if (canvas.width != wNative) canvas.width = wNative;
|
if (canvas.height != hNative) canvas.height = hNative;
|
if (typeof canvas.style != "undefined") {
|
if (w != wNative || h != hNative) {
|
canvas.style.setProperty("width", w + "px", "important");
|
canvas.style.setProperty("height", h + "px", "important");
|
} else {
|
canvas.style.removeProperty("width");
|
canvas.style.removeProperty("height");
|
}
|
}
|
}
|
},
|
wgetRequests: {},
|
nextWgetRequestHandle: 0,
|
getNextWgetRequestHandle: function() {
|
var handle = Browser.nextWgetRequestHandle;
|
Browser.nextWgetRequestHandle++;
|
return handle;
|
}
|
};
|
|
var AL = {
|
QUEUE_INTERVAL: 25,
|
QUEUE_LOOKAHEAD: .1,
|
DEVICE_NAME: "Emscripten OpenAL",
|
CAPTURE_DEVICE_NAME: "Emscripten OpenAL capture",
|
ALC_EXTENSIONS: {
|
ALC_SOFT_pause_device: true,
|
ALC_SOFT_HRTF: true
|
},
|
AL_EXTENSIONS: {
|
AL_EXT_float32: true,
|
AL_SOFT_loop_points: true,
|
AL_SOFT_source_length: true,
|
AL_EXT_source_distance_model: true,
|
AL_SOFT_source_spatialize: true
|
},
|
_alcErr: 0,
|
alcErr: 0,
|
deviceRefCounts: {},
|
alcStringCache: {},
|
paused: false,
|
stringCache: {},
|
contexts: {},
|
currentCtx: null,
|
buffers: {
|
0: {
|
id: 0,
|
refCount: 0,
|
audioBuf: null,
|
frequency: 0,
|
bytesPerSample: 2,
|
channels: 1,
|
length: 0
|
}
|
},
|
paramArray: [],
|
_nextId: 1,
|
newId: function() {
|
return AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++;
|
},
|
freeIds: [],
|
scheduleContextAudio: function(ctx) {
|
if (Browser.mainLoop.timingMode === 1 && document["visibilityState"] != "visible") {
|
return;
|
}
|
for (var i in ctx.sources) {
|
AL.scheduleSourceAudio(ctx.sources[i]);
|
}
|
},
|
scheduleSourceAudio: function(src, lookahead) {
|
if (Browser.mainLoop.timingMode === 1 && document["visibilityState"] != "visible") {
|
return;
|
}
|
if (src.state !== 4114) {
|
return;
|
}
|
var currentTime = AL.updateSourceTime(src);
|
var startTime = src.bufStartTime;
|
var startOffset = src.bufOffset;
|
var bufCursor = src.bufsProcessed;
|
for (var i = 0; i < src.audioQueue.length; i++) {
|
var audioSrc = src.audioQueue[i];
|
startTime = audioSrc._startTime + audioSrc._duration;
|
startOffset = 0;
|
bufCursor += audioSrc._skipCount + 1;
|
}
|
if (!lookahead) {
|
lookahead = AL.QUEUE_LOOKAHEAD;
|
}
|
var lookaheadTime = currentTime + lookahead;
|
var skipCount = 0;
|
while (startTime < lookaheadTime) {
|
if (bufCursor >= src.bufQueue.length) {
|
if (src.looping) {
|
bufCursor %= src.bufQueue.length;
|
} else {
|
break;
|
}
|
}
|
var buf = src.bufQueue[bufCursor % src.bufQueue.length];
|
if (buf.length === 0) {
|
skipCount++;
|
if (skipCount === src.bufQueue.length) {
|
break;
|
}
|
} else {
|
var audioSrc = src.context.audioCtx.createBufferSource();
|
audioSrc.buffer = buf.audioBuf;
|
audioSrc.playbackRate.value = src.playbackRate;
|
if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) {
|
audioSrc.loopStart = buf.audioBuf._loopStart;
|
audioSrc.loopEnd = buf.audioBuf._loopEnd;
|
}
|
var duration = 0;
|
if (src.type === 4136 && src.looping) {
|
duration = Number.POSITIVE_INFINITY;
|
audioSrc.loop = true;
|
if (buf.audioBuf._loopStart) {
|
audioSrc.loopStart = buf.audioBuf._loopStart;
|
}
|
if (buf.audioBuf._loopEnd) {
|
audioSrc.loopEnd = buf.audioBuf._loopEnd;
|
}
|
} else {
|
duration = (buf.audioBuf.duration - startOffset) / src.playbackRate;
|
}
|
audioSrc._startOffset = startOffset;
|
audioSrc._duration = duration;
|
audioSrc._skipCount = skipCount;
|
skipCount = 0;
|
audioSrc.connect(src.gain);
|
if (typeof audioSrc.start !== "undefined") {
|
startTime = Math.max(startTime, src.context.audioCtx.currentTime);
|
audioSrc.start(startTime, startOffset);
|
} else if (typeof audioSrc.noteOn !== "undefined") {
|
startTime = Math.max(startTime, src.context.audioCtx.currentTime);
|
audioSrc.noteOn(startTime);
|
}
|
audioSrc._startTime = startTime;
|
src.audioQueue.push(audioSrc);
|
startTime += duration;
|
}
|
startOffset = 0;
|
bufCursor++;
|
}
|
},
|
updateSourceTime: function(src) {
|
var currentTime = src.context.audioCtx.currentTime;
|
if (src.state !== 4114) {
|
return currentTime;
|
}
|
if (!isFinite(src.bufStartTime)) {
|
src.bufStartTime = currentTime - src.bufOffset / src.playbackRate;
|
src.bufOffset = 0;
|
}
|
var nextStartTime = 0;
|
while (src.audioQueue.length) {
|
var audioSrc = src.audioQueue[0];
|
src.bufsProcessed += audioSrc._skipCount;
|
nextStartTime = audioSrc._startTime + audioSrc._duration;
|
if (currentTime < nextStartTime) {
|
break;
|
}
|
src.audioQueue.shift();
|
src.bufStartTime = nextStartTime;
|
src.bufOffset = 0;
|
src.bufsProcessed++;
|
}
|
if (src.bufsProcessed >= src.bufQueue.length && !src.looping) {
|
AL.setSourceState(src, 4116);
|
} else if (src.type === 4136 && src.looping) {
|
var buf = src.bufQueue[0];
|
if (buf.length === 0) {
|
src.bufOffset = 0;
|
} else {
|
var delta = (currentTime - src.bufStartTime) * src.playbackRate;
|
var loopStart = buf.audioBuf._loopStart || 0;
|
var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration;
|
if (loopEnd <= loopStart) {
|
loopEnd = buf.audioBuf.duration;
|
}
|
if (delta < loopEnd) {
|
src.bufOffset = delta;
|
} else {
|
src.bufOffset = loopStart + (delta - loopStart) % (loopEnd - loopStart);
|
}
|
}
|
} else if (src.audioQueue[0]) {
|
src.bufOffset = (currentTime - src.audioQueue[0]._startTime) * src.playbackRate;
|
} else {
|
if (src.type !== 4136 && src.looping) {
|
var srcDuration = AL.sourceDuration(src) / src.playbackRate;
|
if (srcDuration > 0) {
|
src.bufStartTime += Math.floor((currentTime - src.bufStartTime) / srcDuration) * srcDuration;
|
}
|
}
|
for (var i = 0; i < src.bufQueue.length; i++) {
|
if (src.bufsProcessed >= src.bufQueue.length) {
|
if (src.looping) {
|
src.bufsProcessed %= src.bufQueue.length;
|
} else {
|
AL.setSourceState(src, 4116);
|
break;
|
}
|
}
|
var buf = src.bufQueue[src.bufsProcessed];
|
if (buf.length > 0) {
|
nextStartTime = src.bufStartTime + buf.audioBuf.duration / src.playbackRate;
|
if (currentTime < nextStartTime) {
|
src.bufOffset = (currentTime - src.bufStartTime) * src.playbackRate;
|
break;
|
}
|
src.bufStartTime = nextStartTime;
|
}
|
src.bufOffset = 0;
|
src.bufsProcessed++;
|
}
|
}
|
return currentTime;
|
},
|
cancelPendingSourceAudio: function(src) {
|
AL.updateSourceTime(src);
|
for (var i = 1; i < src.audioQueue.length; i++) {
|
var audioSrc = src.audioQueue[i];
|
audioSrc.stop();
|
}
|
if (src.audioQueue.length > 1) {
|
src.audioQueue.length = 1;
|
}
|
},
|
stopSourceAudio: function(src) {
|
for (var i = 0; i < src.audioQueue.length; i++) {
|
src.audioQueue[i].stop();
|
}
|
src.audioQueue.length = 0;
|
},
|
setSourceState: function(src, state) {
|
if (state === 4114) {
|
if (src.state === 4114 || src.state == 4116) {
|
src.bufsProcessed = 0;
|
src.bufOffset = 0;
|
} else {}
|
AL.stopSourceAudio(src);
|
src.state = 4114;
|
src.bufStartTime = Number.NEGATIVE_INFINITY;
|
AL.scheduleSourceAudio(src);
|
} else if (state === 4115) {
|
if (src.state === 4114) {
|
AL.updateSourceTime(src);
|
AL.stopSourceAudio(src);
|
src.state = 4115;
|
}
|
} else if (state === 4116) {
|
if (src.state !== 4113) {
|
src.state = 4116;
|
src.bufsProcessed = src.bufQueue.length;
|
src.bufStartTime = Number.NEGATIVE_INFINITY;
|
src.bufOffset = 0;
|
AL.stopSourceAudio(src);
|
}
|
} else if (state === 4113) {
|
if (src.state !== 4113) {
|
src.state = 4113;
|
src.bufsProcessed = 0;
|
src.bufStartTime = Number.NEGATIVE_INFINITY;
|
src.bufOffset = 0;
|
AL.stopSourceAudio(src);
|
}
|
}
|
},
|
initSourcePanner: function(src) {
|
if (src.type === 4144) {
|
return;
|
}
|
var templateBuf = AL.buffers[0];
|
for (var i = 0; i < src.bufQueue.length; i++) {
|
if (src.bufQueue[i].id !== 0) {
|
templateBuf = src.bufQueue[i];
|
break;
|
}
|
}
|
if (src.spatialize === 1 || src.spatialize === 2 && templateBuf.channels === 1) {
|
if (src.panner) {
|
return;
|
}
|
src.panner = src.context.audioCtx.createPanner();
|
AL.updateSourceGlobal(src);
|
AL.updateSourceSpace(src);
|
src.panner.connect(src.context.gain);
|
src.gain.disconnect();
|
src.gain.connect(src.panner);
|
} else {
|
if (!src.panner) {
|
return;
|
}
|
src.panner.disconnect();
|
src.gain.disconnect();
|
src.gain.connect(src.context.gain);
|
src.panner = null;
|
}
|
},
|
updateContextGlobal: function(ctx) {
|
for (var i in ctx.sources) {
|
AL.updateSourceGlobal(ctx.sources[i]);
|
}
|
},
|
updateSourceGlobal: function(src) {
|
var panner = src.panner;
|
if (!panner) {
|
return;
|
}
|
panner.refDistance = src.refDistance;
|
panner.maxDistance = src.maxDistance;
|
panner.rolloffFactor = src.rolloffFactor;
|
panner.panningModel = src.context.hrtf ? "HRTF" : "equalpower";
|
var distanceModel = src.context.sourceDistanceModel ? src.distanceModel : src.context.distanceModel;
|
switch (distanceModel) {
|
case 0:
|
panner.distanceModel = "inverse";
|
panner.refDistance = 3.40282e38;
|
break;
|
|
case 53249:
|
case 53250:
|
panner.distanceModel = "inverse";
|
break;
|
|
case 53251:
|
case 53252:
|
panner.distanceModel = "linear";
|
break;
|
|
case 53253:
|
case 53254:
|
panner.distanceModel = "exponential";
|
break;
|
}
|
},
|
updateListenerSpace: function(ctx) {
|
var listener = ctx.audioCtx.listener;
|
if (listener.positionX) {
|
listener.positionX.value = ctx.listener.position[0];
|
listener.positionY.value = ctx.listener.position[1];
|
listener.positionZ.value = ctx.listener.position[2];
|
} else {
|
listener.setPosition(ctx.listener.position[0], ctx.listener.position[1], ctx.listener.position[2]);
|
}
|
if (listener.forwardX) {
|
listener.forwardX.value = ctx.listener.direction[0];
|
listener.forwardY.value = ctx.listener.direction[1];
|
listener.forwardZ.value = ctx.listener.direction[2];
|
listener.upX.value = ctx.listener.up[0];
|
listener.upY.value = ctx.listener.up[1];
|
listener.upZ.value = ctx.listener.up[2];
|
} else {
|
listener.setOrientation(ctx.listener.direction[0], ctx.listener.direction[1], ctx.listener.direction[2], ctx.listener.up[0], ctx.listener.up[1], ctx.listener.up[2]);
|
}
|
for (var i in ctx.sources) {
|
AL.updateSourceSpace(ctx.sources[i]);
|
}
|
},
|
updateSourceSpace: function(src) {
|
if (!src.panner) {
|
return;
|
}
|
var panner = src.panner;
|
var posX = src.position[0];
|
var posY = src.position[1];
|
var posZ = src.position[2];
|
var dirX = src.direction[0];
|
var dirY = src.direction[1];
|
var dirZ = src.direction[2];
|
var listener = src.context.listener;
|
var lPosX = listener.position[0];
|
var lPosY = listener.position[1];
|
var lPosZ = listener.position[2];
|
if (src.relative) {
|
var lBackX = -listener.direction[0];
|
var lBackY = -listener.direction[1];
|
var lBackZ = -listener.direction[2];
|
var lUpX = listener.up[0];
|
var lUpY = listener.up[1];
|
var lUpZ = listener.up[2];
|
var inverseMagnitude = function(x, y, z) {
|
var length = Math.sqrt(x * x + y * y + z * z);
|
if (length < Number.EPSILON) {
|
return 0;
|
}
|
return 1 / length;
|
};
|
var invMag = inverseMagnitude(lBackX, lBackY, lBackZ);
|
lBackX *= invMag;
|
lBackY *= invMag;
|
lBackZ *= invMag;
|
invMag = inverseMagnitude(lUpX, lUpY, lUpZ);
|
lUpX *= invMag;
|
lUpY *= invMag;
|
lUpZ *= invMag;
|
var lRightX = lUpY * lBackZ - lUpZ * lBackY;
|
var lRightY = lUpZ * lBackX - lUpX * lBackZ;
|
var lRightZ = lUpX * lBackY - lUpY * lBackX;
|
invMag = inverseMagnitude(lRightX, lRightY, lRightZ);
|
lRightX *= invMag;
|
lRightY *= invMag;
|
lRightZ *= invMag;
|
lUpX = lBackY * lRightZ - lBackZ * lRightY;
|
lUpY = lBackZ * lRightX - lBackX * lRightZ;
|
lUpZ = lBackX * lRightY - lBackY * lRightX;
|
var oldX = dirX;
|
var oldY = dirY;
|
var oldZ = dirZ;
|
dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
|
dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
|
dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
|
oldX = posX;
|
oldY = posY;
|
oldZ = posZ;
|
posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
|
posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
|
posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
|
posX += lPosX;
|
posY += lPosY;
|
posZ += lPosZ;
|
}
|
if (panner.positionX) {
|
panner.positionX.value = posX;
|
panner.positionY.value = posY;
|
panner.positionZ.value = posZ;
|
} else {
|
panner.setPosition(posX, posY, posZ);
|
}
|
if (panner.orientationX) {
|
panner.orientationX.value = dirX;
|
panner.orientationY.value = dirY;
|
panner.orientationZ.value = dirZ;
|
} else {
|
panner.setOrientation(dirX, dirY, dirZ);
|
}
|
var oldShift = src.dopplerShift;
|
var velX = src.velocity[0];
|
var velY = src.velocity[1];
|
var velZ = src.velocity[2];
|
var lVelX = listener.velocity[0];
|
var lVelY = listener.velocity[1];
|
var lVelZ = listener.velocity[2];
|
if (posX === lPosX && posY === lPosY && posZ === lPosZ || velX === lVelX && velY === lVelY && velZ === lVelZ) {
|
src.dopplerShift = 1;
|
} else {
|
var speedOfSound = src.context.speedOfSound;
|
var dopplerFactor = src.context.dopplerFactor;
|
var slX = lPosX - posX;
|
var slY = lPosY - posY;
|
var slZ = lPosZ - posZ;
|
var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ);
|
var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl;
|
var vss = (slX * velX + slY * velY + slZ * velZ) / magSl;
|
vls = Math.min(vls, speedOfSound / dopplerFactor);
|
vss = Math.min(vss, speedOfSound / dopplerFactor);
|
src.dopplerShift = (speedOfSound - dopplerFactor * vls) / (speedOfSound - dopplerFactor * vss);
|
}
|
if (src.dopplerShift !== oldShift) {
|
AL.updateSourceRate(src);
|
}
|
},
|
updateSourceRate: function(src) {
|
if (src.state === 4114) {
|
AL.cancelPendingSourceAudio(src);
|
var audioSrc = src.audioQueue[0];
|
if (!audioSrc) {
|
return;
|
}
|
var duration;
|
if (src.type === 4136 && src.looping) {
|
duration = Number.POSITIVE_INFINITY;
|
} else {
|
duration = (audioSrc.buffer.duration - audioSrc._startOffset) / src.playbackRate;
|
}
|
audioSrc._duration = duration;
|
audioSrc.playbackRate.value = src.playbackRate;
|
AL.scheduleSourceAudio(src);
|
}
|
},
|
sourceDuration: function(src) {
|
var length = 0;
|
for (var i = 0; i < src.bufQueue.length; i++) {
|
var audioBuf = src.bufQueue[i].audioBuf;
|
length += audioBuf ? audioBuf.duration : 0;
|
}
|
return length;
|
},
|
sourceTell: function(src) {
|
AL.updateSourceTime(src);
|
var offset = 0;
|
for (var i = 0; i < src.bufsProcessed; i++) {
|
offset += src.bufQueue[i].audioBuf.duration;
|
}
|
offset += src.bufOffset;
|
return offset;
|
},
|
sourceSeek: function(src, offset) {
|
var playing = src.state == 4114;
|
if (playing) {
|
AL.setSourceState(src, 4113);
|
}
|
if (src.bufQueue[src.bufsProcessed].audioBuf !== null) {
|
src.bufsProcessed = 0;
|
while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) {
|
offset -= src.bufQueue[src.bufsProcessed].audiobuf.duration;
|
src.bufsProcessed++;
|
}
|
src.bufOffset = offset;
|
}
|
if (playing) {
|
AL.setSourceState(src, 4114);
|
}
|
},
|
getGlobalParam: function(funcname, param) {
|
if (!AL.currentCtx) {
|
return null;
|
}
|
switch (param) {
|
case 49152:
|
return AL.currentCtx.dopplerFactor;
|
|
case 49155:
|
return AL.currentCtx.speedOfSound;
|
|
case 53248:
|
return AL.currentCtx.distanceModel;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return null;
|
}
|
},
|
setGlobalParam: function(funcname, param, value) {
|
if (!AL.currentCtx) {
|
return;
|
}
|
switch (param) {
|
case 49152:
|
if (!Number.isFinite(value) || value < 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
AL.currentCtx.dopplerFactor = value;
|
AL.updateListenerSpace(AL.currentCtx);
|
break;
|
|
case 49155:
|
if (!Number.isFinite(value) || value <= 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
AL.currentCtx.speedOfSound = value;
|
AL.updateListenerSpace(AL.currentCtx);
|
break;
|
|
case 53248:
|
switch (value) {
|
case 0:
|
case 53249:
|
case 53250:
|
case 53251:
|
case 53252:
|
case 53253:
|
case 53254:
|
AL.currentCtx.distanceModel = value;
|
AL.updateContextGlobal(AL.currentCtx);
|
break;
|
|
default:
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
break;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
},
|
getListenerParam: function(funcname, param) {
|
if (!AL.currentCtx) {
|
return null;
|
}
|
switch (param) {
|
case 4100:
|
return AL.currentCtx.listener.position;
|
|
case 4102:
|
return AL.currentCtx.listener.velocity;
|
|
case 4111:
|
return AL.currentCtx.listener.direction.concat(AL.currentCtx.listener.up);
|
|
case 4106:
|
return AL.currentCtx.gain.gain.value;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return null;
|
}
|
},
|
setListenerParam: function(funcname, param, value) {
|
if (!AL.currentCtx) {
|
return;
|
}
|
if (value === null) {
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
var listener = AL.currentCtx.listener;
|
switch (param) {
|
case 4100:
|
if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
listener.position[0] = value[0];
|
listener.position[1] = value[1];
|
listener.position[2] = value[2];
|
AL.updateListenerSpace(AL.currentCtx);
|
break;
|
|
case 4102:
|
if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
listener.velocity[0] = value[0];
|
listener.velocity[1] = value[1];
|
listener.velocity[2] = value[2];
|
AL.updateListenerSpace(AL.currentCtx);
|
break;
|
|
case 4106:
|
if (!Number.isFinite(value) || value < 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
AL.currentCtx.gain.gain.value = value;
|
break;
|
|
case 4111:
|
if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2]) || !Number.isFinite(value[3]) || !Number.isFinite(value[4]) || !Number.isFinite(value[5])) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
listener.direction[0] = value[0];
|
listener.direction[1] = value[1];
|
listener.direction[2] = value[2];
|
listener.up[0] = value[3];
|
listener.up[1] = value[4];
|
listener.up[2] = value[5];
|
AL.updateListenerSpace(AL.currentCtx);
|
break;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
},
|
getBufferParam: function(funcname, bufferId, param) {
|
if (!AL.currentCtx) {
|
return;
|
}
|
var buf = AL.buffers[bufferId];
|
if (!buf || bufferId === 0) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
switch (param) {
|
case 8193:
|
return buf.frequency;
|
|
case 8194:
|
return buf.bytesPerSample * 8;
|
|
case 8195:
|
return buf.channels;
|
|
case 8196:
|
return buf.length * buf.bytesPerSample * buf.channels;
|
|
case 8213:
|
if (buf.length === 0) {
|
return [ 0, 0 ];
|
} else {
|
return [ (buf.audioBuf._loopStart || 0) * buf.frequency, (buf.audioBuf._loopEnd || buf.length) * buf.frequency ];
|
}
|
|
default:
|
AL.currentCtx.err = 40962;
|
return null;
|
}
|
},
|
setBufferParam: function(funcname, bufferId, param, value) {
|
if (!AL.currentCtx) {
|
return;
|
}
|
var buf = AL.buffers[bufferId];
|
if (!buf || bufferId === 0) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
if (value === null) {
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
switch (param) {
|
case 8196:
|
if (value !== 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
break;
|
|
case 8213:
|
if (value[0] < 0 || value[0] > buf.length || value[1] < 0 || value[1] > buf.Length || value[0] >= value[1]) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
if (buf.refCount > 0) {
|
AL.currentCtx.err = 40964;
|
return;
|
}
|
if (buf.audioBuf) {
|
buf.audioBuf._loopStart = value[0] / buf.frequency;
|
buf.audioBuf._loopEnd = value[1] / buf.frequency;
|
}
|
break;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
},
|
getSourceParam: function(funcname, sourceId, param) {
|
if (!AL.currentCtx) {
|
return null;
|
}
|
var src = AL.currentCtx.sources[sourceId];
|
if (!src) {
|
AL.currentCtx.err = 40961;
|
return null;
|
}
|
switch (param) {
|
case 514:
|
return src.relative;
|
|
case 4097:
|
return src.coneInnerAngle;
|
|
case 4098:
|
return src.coneOuterAngle;
|
|
case 4099:
|
return src.pitch;
|
|
case 4100:
|
return src.position;
|
|
case 4101:
|
return src.direction;
|
|
case 4102:
|
return src.velocity;
|
|
case 4103:
|
return src.looping;
|
|
case 4105:
|
if (src.type === 4136) {
|
return src.bufQueue[0].id;
|
} else {
|
return 0;
|
}
|
|
case 4106:
|
return src.gain.gain.value;
|
|
case 4109:
|
return src.minGain;
|
|
case 4110:
|
return src.maxGain;
|
|
case 4112:
|
return src.state;
|
|
case 4117:
|
if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
|
return 0;
|
} else {
|
return src.bufQueue.length;
|
}
|
|
case 4118:
|
if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 || src.looping) {
|
return 0;
|
} else {
|
return src.bufsProcessed;
|
}
|
|
case 4128:
|
return src.refDistance;
|
|
case 4129:
|
return src.rolloffFactor;
|
|
case 4130:
|
return src.coneOuterGain;
|
|
case 4131:
|
return src.maxDistance;
|
|
case 4132:
|
return AL.sourceTell(src);
|
|
case 4133:
|
var offset = AL.sourceTell(src);
|
if (offset > 0) {
|
offset *= src.bufQueue[0].frequency;
|
}
|
return offset;
|
|
case 4134:
|
var offset = AL.sourceTell(src);
|
if (offset > 0) {
|
offset *= src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample;
|
}
|
return offset;
|
|
case 4135:
|
return src.type;
|
|
case 4628:
|
return src.spatialize;
|
|
case 8201:
|
var length = 0;
|
var bytesPerFrame = 0;
|
for (var i = 0; i < src.bufQueue.length; i++) {
|
length += src.bufQueue[i].length;
|
if (src.bufQueue[i].id !== 0) {
|
bytesPerFrame = src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels;
|
}
|
}
|
return length * bytesPerFrame;
|
|
case 8202:
|
var length = 0;
|
for (var i = 0; i < src.bufQueue.length; i++) {
|
length += src.bufQueue[i].length;
|
}
|
return length;
|
|
case 8203:
|
return AL.sourceDuration(src);
|
|
case 53248:
|
return src.distanceModel;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return null;
|
}
|
},
|
setSourceParam: function(funcname, sourceId, param, value) {
|
if (!AL.currentCtx) {
|
return;
|
}
|
var src = AL.currentCtx.sources[sourceId];
|
if (!src) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
if (value === null) {
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
switch (param) {
|
case 514:
|
if (value === 1) {
|
src.relative = true;
|
AL.updateSourceSpace(src);
|
} else if (value === 0) {
|
src.relative = false;
|
AL.updateSourceSpace(src);
|
} else {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
break;
|
|
case 4097:
|
if (!Number.isFinite(value)) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.coneInnerAngle = value;
|
if (src.panner) {
|
src.panner.coneInnerAngle = value % 360;
|
}
|
break;
|
|
case 4098:
|
if (!Number.isFinite(value)) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.coneOuterAngle = value;
|
if (src.panner) {
|
src.panner.coneOuterAngle = value % 360;
|
}
|
break;
|
|
case 4099:
|
if (!Number.isFinite(value) || value <= 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
if (src.pitch === value) {
|
break;
|
}
|
src.pitch = value;
|
AL.updateSourceRate(src);
|
break;
|
|
case 4100:
|
if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.position[0] = value[0];
|
src.position[1] = value[1];
|
src.position[2] = value[2];
|
AL.updateSourceSpace(src);
|
break;
|
|
case 4101:
|
if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.direction[0] = value[0];
|
src.direction[1] = value[1];
|
src.direction[2] = value[2];
|
AL.updateSourceSpace(src);
|
break;
|
|
case 4102:
|
if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.velocity[0] = value[0];
|
src.velocity[1] = value[1];
|
src.velocity[2] = value[2];
|
AL.updateSourceSpace(src);
|
break;
|
|
case 4103:
|
if (value === 1) {
|
src.looping = true;
|
AL.updateSourceTime(src);
|
if (src.type === 4136 && src.audioQueue.length > 0) {
|
var audioSrc = src.audioQueue[0];
|
audioSrc.loop = true;
|
audioSrc._duration = Number.POSITIVE_INFINITY;
|
}
|
} else if (value === 0) {
|
src.looping = false;
|
var currentTime = AL.updateSourceTime(src);
|
if (src.type === 4136 && src.audioQueue.length > 0) {
|
var audioSrc = src.audioQueue[0];
|
audioSrc.loop = false;
|
audioSrc._duration = src.bufQueue[0].audioBuf.duration / src.playbackRate;
|
audioSrc._startTime = currentTime - src.bufOffset / src.playbackRate;
|
}
|
} else {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
break;
|
|
case 4105:
|
if (src.state === 4114 || src.state === 4115) {
|
AL.currentCtx.err = 40964;
|
return;
|
}
|
if (value === 0) {
|
for (var i in src.bufQueue) {
|
src.bufQueue[i].refCount--;
|
}
|
src.bufQueue.length = 1;
|
src.bufQueue[0] = AL.buffers[0];
|
src.bufsProcessed = 0;
|
src.type = 4144;
|
} else {
|
var buf = AL.buffers[value];
|
if (!buf) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
for (var i in src.bufQueue) {
|
src.bufQueue[i].refCount--;
|
}
|
src.bufQueue.length = 0;
|
buf.refCount++;
|
src.bufQueue = [ buf ];
|
src.bufsProcessed = 0;
|
src.type = 4136;
|
}
|
AL.initSourcePanner(src);
|
AL.scheduleSourceAudio(src);
|
break;
|
|
case 4106:
|
if (!Number.isFinite(value) || value < 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.gain.gain.value = value;
|
break;
|
|
case 4109:
|
if (!Number.isFinite(value) || value < 0 || value > Math.min(src.maxGain, 1)) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.minGain = value;
|
break;
|
|
case 4110:
|
if (!Number.isFinite(value) || value < Math.max(0, src.minGain) || value > 1) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.maxGain = value;
|
break;
|
|
case 4128:
|
if (!Number.isFinite(value) || value < 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.refDistance = value;
|
if (src.panner) {
|
src.panner.refDistance = value;
|
}
|
break;
|
|
case 4129:
|
if (!Number.isFinite(value) || value < 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.rolloffFactor = value;
|
if (src.panner) {
|
src.panner.rolloffFactor = value;
|
}
|
break;
|
|
case 4130:
|
if (!Number.isFinite(value) || value < 0 || value > 1) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.coneOuterGain = value;
|
if (src.panner) {
|
src.panner.coneOuterGain = value;
|
}
|
break;
|
|
case 4131:
|
if (!Number.isFinite(value) || value < 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.maxDistance = value;
|
if (src.panner) {
|
src.panner.maxDistance = value;
|
}
|
break;
|
|
case 4132:
|
if (value < 0 || value > AL.sourceDuration(src)) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
AL.sourceSeek(src, value);
|
break;
|
|
case 4133:
|
var srcLen = AL.sourceDuration(src);
|
if (srcLen > 0) {
|
var frequency;
|
for (var bufId in src.bufQueue) {
|
if (bufId) {
|
frequency = src.bufQueue[bufId].frequency;
|
break;
|
}
|
}
|
value /= frequency;
|
}
|
if (value < 0 || value > srcLen) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
AL.sourceSeek(src, value);
|
break;
|
|
case 4134:
|
var srcLen = AL.sourceDuration(src);
|
if (srcLen > 0) {
|
var bytesPerSec;
|
for (var bufId in src.bufQueue) {
|
if (bufId) {
|
var buf = src.bufQueue[bufId];
|
bytesPerSec = buf.frequency * buf.bytesPerSample * buf.channels;
|
break;
|
}
|
}
|
value /= bytesPerSec;
|
}
|
if (value < 0 || value > srcLen) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
AL.sourceSeek(src, value);
|
break;
|
|
case 4628:
|
if (value !== 0 && value !== 1 && value !== 2) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
src.spatialize = value;
|
AL.initSourcePanner(src);
|
break;
|
|
case 8201:
|
case 8202:
|
case 8203:
|
AL.currentCtx.err = 40964;
|
break;
|
|
case 53248:
|
switch (value) {
|
case 0:
|
case 53249:
|
case 53250:
|
case 53251:
|
case 53252:
|
case 53253:
|
case 53254:
|
src.distanceModel = value;
|
if (AL.currentCtx.sourceDistanceModel) {
|
AL.updateContextGlobal(AL.currentCtx);
|
}
|
break;
|
|
default:
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
break;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
},
|
captures: {},
|
sharedCaptureAudioCtx: null,
|
requireValidCaptureDevice: function(deviceId, funcname) {
|
if (deviceId === 0) {
|
AL.alcErr = 40961;
|
return null;
|
}
|
var c = AL.captures[deviceId];
|
if (!c) {
|
AL.alcErr = 40961;
|
return null;
|
}
|
var err = c.mediaStreamError;
|
if (err) {
|
AL.alcErr = 40961;
|
return null;
|
}
|
return c;
|
}
|
};
|
|
function _alBufferData(bufferId, format, pData, size, freq) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(8, 1, bufferId, format, pData, size, freq);
|
if (!AL.currentCtx) {
|
return;
|
}
|
var buf = AL.buffers[bufferId];
|
if (!buf) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
if (freq <= 0) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
var audioBuf = null;
|
try {
|
switch (format) {
|
case 4352:
|
if (size > 0) {
|
audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size, freq);
|
var channel0 = audioBuf.getChannelData(0);
|
for (var i = 0; i < size; ++i) {
|
channel0[i] = GROWABLE_HEAP_U8()[pData++] * .0078125 - 1;
|
}
|
}
|
buf.bytesPerSample = 1;
|
buf.channels = 1;
|
buf.length = size;
|
break;
|
|
case 4353:
|
if (size > 0) {
|
audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 1, freq);
|
var channel0 = audioBuf.getChannelData(0);
|
pData >>= 1;
|
for (var i = 0; i < size >> 1; ++i) {
|
channel0[i] = GROWABLE_HEAP_I16()[pData++] * 30517578125e-15;
|
}
|
}
|
buf.bytesPerSample = 2;
|
buf.channels = 1;
|
buf.length = size >> 1;
|
break;
|
|
case 4354:
|
if (size > 0) {
|
audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 1, freq);
|
var channel0 = audioBuf.getChannelData(0);
|
var channel1 = audioBuf.getChannelData(1);
|
for (var i = 0; i < size >> 1; ++i) {
|
channel0[i] = GROWABLE_HEAP_U8()[pData++] * .0078125 - 1;
|
channel1[i] = GROWABLE_HEAP_U8()[pData++] * .0078125 - 1;
|
}
|
}
|
buf.bytesPerSample = 1;
|
buf.channels = 2;
|
buf.length = size >> 1;
|
break;
|
|
case 4355:
|
if (size > 0) {
|
audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 2, freq);
|
var channel0 = audioBuf.getChannelData(0);
|
var channel1 = audioBuf.getChannelData(1);
|
pData >>= 1;
|
for (var i = 0; i < size >> 2; ++i) {
|
channel0[i] = GROWABLE_HEAP_I16()[pData++] * 30517578125e-15;
|
channel1[i] = GROWABLE_HEAP_I16()[pData++] * 30517578125e-15;
|
}
|
}
|
buf.bytesPerSample = 2;
|
buf.channels = 2;
|
buf.length = size >> 2;
|
break;
|
|
case 65552:
|
if (size > 0) {
|
audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 2, freq);
|
var channel0 = audioBuf.getChannelData(0);
|
pData >>= 2;
|
for (var i = 0; i < size >> 2; ++i) {
|
channel0[i] = GROWABLE_HEAP_F32()[pData++];
|
}
|
}
|
buf.bytesPerSample = 4;
|
buf.channels = 1;
|
buf.length = size >> 2;
|
break;
|
|
case 65553:
|
if (size > 0) {
|
audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 3, freq);
|
var channel0 = audioBuf.getChannelData(0);
|
var channel1 = audioBuf.getChannelData(1);
|
pData >>= 2;
|
for (var i = 0; i < size >> 3; ++i) {
|
channel0[i] = GROWABLE_HEAP_F32()[pData++];
|
channel1[i] = GROWABLE_HEAP_F32()[pData++];
|
}
|
}
|
buf.bytesPerSample = 4;
|
buf.channels = 2;
|
buf.length = size >> 3;
|
break;
|
|
default:
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
buf.frequency = freq;
|
buf.audioBuf = audioBuf;
|
} catch (e) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
}
|
|
function _alDeleteBuffers(count, pBufferIds) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(9, 1, count, pBufferIds);
|
if (!AL.currentCtx) {
|
return;
|
}
|
for (var i = 0; i < count; ++i) {
|
var bufId = GROWABLE_HEAP_I32()[pBufferIds + i * 4 >> 2];
|
if (bufId === 0) {
|
continue;
|
}
|
if (!AL.buffers[bufId]) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
if (AL.buffers[bufId].refCount) {
|
AL.currentCtx.err = 40964;
|
return;
|
}
|
}
|
for (var i = 0; i < count; ++i) {
|
var bufId = GROWABLE_HEAP_I32()[pBufferIds + i * 4 >> 2];
|
if (bufId === 0) {
|
continue;
|
}
|
AL.deviceRefCounts[AL.buffers[bufId].deviceId]--;
|
delete AL.buffers[bufId];
|
AL.freeIds.push(bufId);
|
}
|
}
|
|
function _alSourcei(sourceId, param, value) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(10, 1, sourceId, param, value);
|
switch (param) {
|
case 514:
|
case 4097:
|
case 4098:
|
case 4103:
|
case 4105:
|
case 4128:
|
case 4129:
|
case 4131:
|
case 4132:
|
case 4133:
|
case 4134:
|
case 4628:
|
case 8201:
|
case 8202:
|
case 53248:
|
AL.setSourceParam("alSourcei", sourceId, param, value);
|
break;
|
|
default:
|
AL.setSourceParam("alSourcei", sourceId, param, null);
|
break;
|
}
|
}
|
|
function _alDeleteSources(count, pSourceIds) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(11, 1, count, pSourceIds);
|
if (!AL.currentCtx) {
|
return;
|
}
|
for (var i = 0; i < count; ++i) {
|
var srcId = GROWABLE_HEAP_I32()[pSourceIds + i * 4 >> 2];
|
if (!AL.currentCtx.sources[srcId]) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
}
|
for (var i = 0; i < count; ++i) {
|
var srcId = GROWABLE_HEAP_I32()[pSourceIds + i * 4 >> 2];
|
AL.setSourceState(AL.currentCtx.sources[srcId], 4116);
|
_alSourcei(srcId, 4105, 0);
|
delete AL.currentCtx.sources[srcId];
|
AL.freeIds.push(srcId);
|
}
|
}
|
|
function _alGenBuffers(count, pBufferIds) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(12, 1, count, pBufferIds);
|
if (!AL.currentCtx) {
|
return;
|
}
|
for (var i = 0; i < count; ++i) {
|
var buf = {
|
deviceId: AL.currentCtx.deviceId,
|
id: AL.newId(),
|
refCount: 0,
|
audioBuf: null,
|
frequency: 0,
|
bytesPerSample: 2,
|
channels: 1,
|
length: 0
|
};
|
AL.deviceRefCounts[buf.deviceId]++;
|
AL.buffers[buf.id] = buf;
|
GROWABLE_HEAP_I32()[pBufferIds + i * 4 >> 2] = buf.id;
|
}
|
}
|
|
function _alGenSources(count, pSourceIds) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(13, 1, count, pSourceIds);
|
if (!AL.currentCtx) {
|
return;
|
}
|
for (var i = 0; i < count; ++i) {
|
var gain = AL.currentCtx.audioCtx.createGain();
|
gain.connect(AL.currentCtx.gain);
|
var src = {
|
context: AL.currentCtx,
|
id: AL.newId(),
|
type: 4144,
|
state: 4113,
|
bufQueue: [ AL.buffers[0] ],
|
audioQueue: [],
|
looping: false,
|
pitch: 1,
|
dopplerShift: 1,
|
gain: gain,
|
minGain: 0,
|
maxGain: 1,
|
panner: null,
|
bufsProcessed: 0,
|
bufStartTime: Number.NEGATIVE_INFINITY,
|
bufOffset: 0,
|
relative: false,
|
refDistance: 1,
|
maxDistance: 3.40282e38,
|
rolloffFactor: 1,
|
position: [ 0, 0, 0 ],
|
velocity: [ 0, 0, 0 ],
|
direction: [ 0, 0, 0 ],
|
coneOuterGain: 0,
|
coneInnerAngle: 360,
|
coneOuterAngle: 360,
|
distanceModel: 53250,
|
spatialize: 2,
|
get playbackRate() {
|
return this.pitch * this.dopplerShift;
|
}
|
};
|
AL.currentCtx.sources[src.id] = src;
|
GROWABLE_HEAP_I32()[pSourceIds + i * 4 >> 2] = src.id;
|
}
|
}
|
|
function _alGetError() {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(14, 1);
|
if (!AL.currentCtx) {
|
return 40964;
|
} else {
|
var err = AL.currentCtx.err;
|
AL.currentCtx.err = 0;
|
return err;
|
}
|
}
|
|
function _alGetSourcef(sourceId, param, pValue) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(15, 1, sourceId, param, pValue);
|
var val = AL.getSourceParam("alGetSourcef", sourceId, param);
|
if (val === null) {
|
return;
|
}
|
if (!pValue) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
switch (param) {
|
case 4097:
|
case 4098:
|
case 4099:
|
case 4106:
|
case 4109:
|
case 4110:
|
case 4128:
|
case 4129:
|
case 4130:
|
case 4131:
|
case 4132:
|
case 4133:
|
case 4134:
|
case 8203:
|
GROWABLE_HEAP_F32()[pValue >> 2] = val;
|
break;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
}
|
|
function _alGetSourcei(sourceId, param, pValue) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(16, 1, sourceId, param, pValue);
|
var val = AL.getSourceParam("alGetSourcei", sourceId, param);
|
if (val === null) {
|
return;
|
}
|
if (!pValue) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
switch (param) {
|
case 514:
|
case 4097:
|
case 4098:
|
case 4103:
|
case 4105:
|
case 4112:
|
case 4117:
|
case 4118:
|
case 4128:
|
case 4129:
|
case 4131:
|
case 4132:
|
case 4133:
|
case 4134:
|
case 4135:
|
case 4628:
|
case 8201:
|
case 8202:
|
case 53248:
|
GROWABLE_HEAP_I32()[pValue >> 2] = val;
|
break;
|
|
default:
|
AL.currentCtx.err = 40962;
|
return;
|
}
|
}
|
|
function _alListenerfv(param, pValues) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(17, 1, param, pValues);
|
if (!AL.currentCtx) {
|
return;
|
}
|
if (!pValues) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
switch (param) {
|
case 4100:
|
case 4102:
|
AL.paramArray[0] = GROWABLE_HEAP_F32()[pValues >> 2];
|
AL.paramArray[1] = GROWABLE_HEAP_F32()[pValues + 4 >> 2];
|
AL.paramArray[2] = GROWABLE_HEAP_F32()[pValues + 8 >> 2];
|
AL.setListenerParam("alListenerfv", param, AL.paramArray);
|
break;
|
|
case 4111:
|
AL.paramArray[0] = GROWABLE_HEAP_F32()[pValues >> 2];
|
AL.paramArray[1] = GROWABLE_HEAP_F32()[pValues + 4 >> 2];
|
AL.paramArray[2] = GROWABLE_HEAP_F32()[pValues + 8 >> 2];
|
AL.paramArray[3] = GROWABLE_HEAP_F32()[pValues + 12 >> 2];
|
AL.paramArray[4] = GROWABLE_HEAP_F32()[pValues + 16 >> 2];
|
AL.paramArray[5] = GROWABLE_HEAP_F32()[pValues + 20 >> 2];
|
AL.setListenerParam("alListenerfv", param, AL.paramArray);
|
break;
|
|
default:
|
AL.setListenerParam("alListenerfv", param, null);
|
break;
|
}
|
}
|
|
function _alSourcePlay(sourceId) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(18, 1, sourceId);
|
if (!AL.currentCtx) {
|
return;
|
}
|
var src = AL.currentCtx.sources[sourceId];
|
if (!src) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
AL.setSourceState(src, 4114);
|
}
|
|
function _alSourceQueueBuffers(sourceId, count, pBufferIds) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(19, 1, sourceId, count, pBufferIds);
|
if (!AL.currentCtx) {
|
return;
|
}
|
var src = AL.currentCtx.sources[sourceId];
|
if (!src) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
if (src.type === 4136) {
|
AL.currentCtx.err = 40964;
|
return;
|
}
|
if (count === 0) {
|
return;
|
}
|
var templateBuf = AL.buffers[0];
|
for (var i = 0; i < src.bufQueue.length; i++) {
|
if (src.bufQueue[i].id !== 0) {
|
templateBuf = src.bufQueue[i];
|
break;
|
}
|
}
|
for (var i = 0; i < count; ++i) {
|
var bufId = GROWABLE_HEAP_I32()[pBufferIds + i * 4 >> 2];
|
var buf = AL.buffers[bufId];
|
if (!buf) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
if (templateBuf.id !== 0 && (buf.frequency !== templateBuf.frequency || buf.bytesPerSample !== templateBuf.bytesPerSample || buf.channels !== templateBuf.channels)) {
|
AL.currentCtx.err = 40964;
|
}
|
}
|
if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
|
src.bufQueue.length = 0;
|
}
|
src.type = 4137;
|
for (var i = 0; i < count; ++i) {
|
var bufId = GROWABLE_HEAP_I32()[pBufferIds + i * 4 >> 2];
|
var buf = AL.buffers[bufId];
|
buf.refCount++;
|
src.bufQueue.push(buf);
|
}
|
if (src.looping) {
|
AL.cancelPendingSourceAudio(src);
|
}
|
AL.initSourcePanner(src);
|
AL.scheduleSourceAudio(src);
|
}
|
|
function _alSourceStop(sourceId) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(20, 1, sourceId);
|
if (!AL.currentCtx) {
|
return;
|
}
|
var src = AL.currentCtx.sources[sourceId];
|
if (!src) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
AL.setSourceState(src, 4116);
|
}
|
|
function _alSourceUnqueueBuffers(sourceId, count, pBufferIds) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(21, 1, sourceId, count, pBufferIds);
|
if (!AL.currentCtx) {
|
return;
|
}
|
var src = AL.currentCtx.sources[sourceId];
|
if (!src) {
|
AL.currentCtx.err = 40961;
|
return;
|
}
|
if (count > (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 ? 0 : src.bufsProcessed)) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
if (count === 0) {
|
return;
|
}
|
for (var i = 0; i < count; i++) {
|
var buf = src.bufQueue.shift();
|
buf.refCount--;
|
GROWABLE_HEAP_I32()[pBufferIds + i * 4 >> 2] = buf.id;
|
src.bufsProcessed--;
|
}
|
if (src.bufQueue.length === 0) {
|
src.bufQueue.push(AL.buffers[0]);
|
}
|
AL.initSourcePanner(src);
|
AL.scheduleSourceAudio(src);
|
}
|
|
function _alSourcef(sourceId, param, value) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(22, 1, sourceId, param, value);
|
switch (param) {
|
case 4097:
|
case 4098:
|
case 4099:
|
case 4106:
|
case 4109:
|
case 4110:
|
case 4128:
|
case 4129:
|
case 4130:
|
case 4131:
|
case 4132:
|
case 4133:
|
case 4134:
|
case 8203:
|
AL.setSourceParam("alSourcef", sourceId, param, value);
|
break;
|
|
default:
|
AL.setSourceParam("alSourcef", sourceId, param, null);
|
break;
|
}
|
}
|
|
function _alSourcefv(sourceId, param, pValues) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(23, 1, sourceId, param, pValues);
|
if (!AL.currentCtx) {
|
return;
|
}
|
if (!pValues) {
|
AL.currentCtx.err = 40963;
|
return;
|
}
|
switch (param) {
|
case 4097:
|
case 4098:
|
case 4099:
|
case 4106:
|
case 4109:
|
case 4110:
|
case 4128:
|
case 4129:
|
case 4130:
|
case 4131:
|
case 4132:
|
case 4133:
|
case 4134:
|
case 8203:
|
var val = GROWABLE_HEAP_F32()[pValues >> 2];
|
AL.setSourceParam("alSourcefv", sourceId, param, val);
|
break;
|
|
case 4100:
|
case 4101:
|
case 4102:
|
AL.paramArray[0] = GROWABLE_HEAP_F32()[pValues >> 2];
|
AL.paramArray[1] = GROWABLE_HEAP_F32()[pValues + 4 >> 2];
|
AL.paramArray[2] = GROWABLE_HEAP_F32()[pValues + 8 >> 2];
|
AL.setSourceParam("alSourcefv", sourceId, param, AL.paramArray);
|
break;
|
|
default:
|
AL.setSourceParam("alSourcefv", sourceId, param, null);
|
break;
|
}
|
}
|
|
function listenOnce(object, event, func) {
|
object.addEventListener(event, func, {
|
"once": true
|
});
|
}
|
|
function autoResumeAudioContext(ctx, elements) {
|
if (!elements) {
|
elements = [ document, document.getElementById("canvas") ];
|
}
|
[ "keydown", "mousedown", "touchstart" ].forEach(function(event) {
|
elements.forEach(function(element) {
|
if (element) {
|
listenOnce(element, event, function() {
|
if (ctx.state === "suspended") ctx.resume();
|
});
|
}
|
});
|
});
|
}
|
|
function _alcCreateContext(deviceId, pAttrList) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(24, 1, deviceId, pAttrList);
|
if (!(deviceId in AL.deviceRefCounts)) {
|
AL.alcErr = 40961;
|
return 0;
|
}
|
var options = null;
|
var attrs = [];
|
var hrtf = null;
|
pAttrList >>= 2;
|
if (pAttrList) {
|
var attr = 0;
|
var val = 0;
|
while (true) {
|
attr = GROWABLE_HEAP_I32()[pAttrList++];
|
attrs.push(attr);
|
if (attr === 0) {
|
break;
|
}
|
val = GROWABLE_HEAP_I32()[pAttrList++];
|
attrs.push(val);
|
switch (attr) {
|
case 4103:
|
if (!options) {
|
options = {};
|
}
|
options.sampleRate = val;
|
break;
|
|
case 4112:
|
case 4113:
|
break;
|
|
case 6546:
|
switch (val) {
|
case 0:
|
hrtf = false;
|
break;
|
|
case 1:
|
hrtf = true;
|
break;
|
|
case 2:
|
break;
|
|
default:
|
AL.alcErr = 40964;
|
return 0;
|
}
|
break;
|
|
case 6550:
|
if (val !== 0) {
|
AL.alcErr = 40964;
|
return 0;
|
}
|
break;
|
|
default:
|
AL.alcErr = 40964;
|
return 0;
|
}
|
}
|
}
|
var AudioContext = window.AudioContext || window.webkitAudioContext;
|
var ac = null;
|
try {
|
if (options) {
|
ac = new AudioContext(options);
|
} else {
|
ac = new AudioContext();
|
}
|
} catch (e) {
|
if (e.name === "NotSupportedError") {
|
AL.alcErr = 40964;
|
} else {
|
AL.alcErr = 40961;
|
}
|
return 0;
|
}
|
autoResumeAudioContext(ac);
|
if (typeof ac.createGain === "undefined") {
|
ac.createGain = ac.createGainNode;
|
}
|
var gain = ac.createGain();
|
gain.connect(ac.destination);
|
var ctx = {
|
deviceId: deviceId,
|
id: AL.newId(),
|
attrs: attrs,
|
audioCtx: ac,
|
listener: {
|
position: [ 0, 0, 0 ],
|
velocity: [ 0, 0, 0 ],
|
direction: [ 0, 0, 0 ],
|
up: [ 0, 0, 0 ]
|
},
|
sources: [],
|
interval: setInterval(function() {
|
AL.scheduleContextAudio(ctx);
|
}, AL.QUEUE_INTERVAL),
|
gain: gain,
|
distanceModel: 53250,
|
speedOfSound: 343.3,
|
dopplerFactor: 1,
|
sourceDistanceModel: false,
|
hrtf: hrtf || false,
|
_err: 0,
|
get err() {
|
return this._err;
|
},
|
set err(val) {
|
if (this._err === 0 || val === 0) {
|
this._err = val;
|
}
|
}
|
};
|
AL.deviceRefCounts[deviceId]++;
|
AL.contexts[ctx.id] = ctx;
|
if (hrtf !== null) {
|
for (var ctxId in AL.contexts) {
|
var c = AL.contexts[ctxId];
|
if (c.deviceId === deviceId) {
|
c.hrtf = hrtf;
|
AL.updateContextGlobal(c);
|
}
|
}
|
}
|
return ctx.id;
|
}
|
|
function _alcGetCurrentContext() {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(25, 1);
|
if (AL.currentCtx !== null) {
|
return AL.currentCtx.id;
|
} else {
|
return 0;
|
}
|
}
|
|
function _alcGetString(deviceId, param) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(26, 1, deviceId, param);
|
if (AL.alcStringCache[param]) {
|
return AL.alcStringCache[param];
|
}
|
var ret;
|
switch (param) {
|
case 0:
|
ret = "No Error";
|
break;
|
|
case 40961:
|
ret = "Invalid Device";
|
break;
|
|
case 40962:
|
ret = "Invalid Context";
|
break;
|
|
case 40963:
|
ret = "Invalid Enum";
|
break;
|
|
case 40964:
|
ret = "Invalid Value";
|
break;
|
|
case 40965:
|
ret = "Out of Memory";
|
break;
|
|
case 4100:
|
if (typeof AudioContext !== "undefined" || typeof webkitAudioContext !== "undefined") {
|
ret = AL.DEVICE_NAME;
|
} else {
|
return 0;
|
}
|
break;
|
|
case 4101:
|
if (typeof AudioContext !== "undefined" || typeof webkitAudioContext !== "undefined") {
|
ret = AL.DEVICE_NAME.concat("\0");
|
} else {
|
ret = "\0";
|
}
|
break;
|
|
case 785:
|
ret = AL.CAPTURE_DEVICE_NAME;
|
break;
|
|
case 784:
|
if (deviceId === 0) ret = AL.CAPTURE_DEVICE_NAME.concat("\0"); else {
|
var c = AL.requireValidCaptureDevice(deviceId, "alcGetString");
|
if (!c) {
|
return 0;
|
}
|
ret = c.deviceName;
|
}
|
break;
|
|
case 4102:
|
if (!deviceId) {
|
AL.alcErr = 40961;
|
return 0;
|
}
|
ret = "";
|
for (var ext in AL.ALC_EXTENSIONS) {
|
ret = ret.concat(ext);
|
ret = ret.concat(" ");
|
}
|
ret = ret.trim();
|
break;
|
|
default:
|
AL.alcErr = 40963;
|
return 0;
|
}
|
ret = allocate(intArrayFromString(ret), ALLOC_NORMAL);
|
AL.alcStringCache[param] = ret;
|
return ret;
|
}
|
|
function _alcMakeContextCurrent(contextId) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(27, 1, contextId);
|
if (contextId === 0) {
|
AL.currentCtx = null;
|
return 0;
|
} else {
|
AL.currentCtx = AL.contexts[contextId];
|
return 1;
|
}
|
}
|
|
function _alcOpenDevice(pDeviceName) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(28, 1, pDeviceName);
|
if (pDeviceName) {
|
var name = UTF8ToString(pDeviceName);
|
if (name !== AL.DEVICE_NAME) {
|
return 0;
|
}
|
}
|
if (typeof AudioContext !== "undefined" || typeof webkitAudioContext !== "undefined") {
|
var deviceId = AL.newId();
|
AL.deviceRefCounts[deviceId] = 0;
|
return deviceId;
|
} else {
|
return 0;
|
}
|
}
|
|
var readAsmConstArgsArray = [];
|
|
function readAsmConstArgs(sigPtr, buf) {
|
assert(Array.isArray(readAsmConstArgsArray));
|
assert(buf % 16 == 0);
|
readAsmConstArgsArray.length = 0;
|
var ch;
|
buf >>= 2;
|
while (ch = GROWABLE_HEAP_U8()[sigPtr++]) {
|
assert(ch === 100 || ch === 102 || ch === 105);
|
var double = ch < 105;
|
if (double && buf & 1) buf++;
|
readAsmConstArgsArray.push(double ? GROWABLE_HEAP_F64()[buf++ >> 1] : GROWABLE_HEAP_I32()[buf]);
|
++buf;
|
}
|
return readAsmConstArgsArray;
|
}
|
|
function _emscripten_asm_const_int(code, sigPtr, argbuf) {
|
var args = readAsmConstArgs(sigPtr, argbuf);
|
if (!ASM_CONSTS.hasOwnProperty(code)) abort("No EM_ASM constant found at address " + code);
|
return ASM_CONSTS[code].apply(null, args);
|
}
|
|
function _emscripten_cancel_main_loop() {
|
Browser.mainLoop.pause();
|
Browser.mainLoop.func = null;
|
}
|
|
function _emscripten_check_blocking_allowed() {
|
if (ENVIRONMENT_IS_WORKER) return;
|
warnOnce("Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread");
|
}
|
|
function _emscripten_conditional_set_current_thread_status_js(expectedStatus, newStatus) {}
|
|
function _emscripten_conditional_set_current_thread_status(expectedStatus, newStatus) {}
|
|
function _emscripten_futex_wait(addr, val, timeout) {
|
if (addr <= 0 || addr > GROWABLE_HEAP_I8().length || addr & 3 != 0) return -28;
|
if (!ENVIRONMENT_IS_WEB) {
|
var ret = Atomics.wait(GROWABLE_HEAP_I32(), addr >> 2, val, timeout);
|
if (ret === "timed-out") return -73;
|
if (ret === "not-equal") return -6;
|
if (ret === "ok") return 0;
|
throw "Atomics.wait returned an unexpected value " + ret;
|
} else {
|
if (Atomics.load(GROWABLE_HEAP_I32(), addr >> 2) != val) {
|
return -6;
|
}
|
var tNow = performance.now();
|
var tEnd = tNow + timeout;
|
assert(__emscripten_main_thread_futex > 0);
|
var lastAddr = Atomics.exchange(GROWABLE_HEAP_I32(), __emscripten_main_thread_futex >> 2, addr);
|
assert(lastAddr == 0);
|
while (1) {
|
tNow = performance.now();
|
if (tNow > tEnd) {
|
lastAddr = Atomics.exchange(GROWABLE_HEAP_I32(), __emscripten_main_thread_futex >> 2, 0);
|
assert(lastAddr == addr || lastAddr == 0);
|
return -73;
|
}
|
lastAddr = Atomics.exchange(GROWABLE_HEAP_I32(), __emscripten_main_thread_futex >> 2, 0);
|
assert(lastAddr == addr || lastAddr == 0);
|
if (lastAddr == 0) {
|
break;
|
}
|
_emscripten_main_thread_process_queued_calls();
|
if (Atomics.load(GROWABLE_HEAP_I32(), addr >> 2) != val) {
|
return -6;
|
}
|
lastAddr = Atomics.exchange(GROWABLE_HEAP_I32(), __emscripten_main_thread_futex >> 2, addr);
|
assert(lastAddr == 0);
|
}
|
return 0;
|
}
|
}
|
|
var JSEvents = {
|
inEventHandler: 0,
|
removeAllEventListeners: function() {
|
for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) {
|
JSEvents._removeHandler(i);
|
}
|
JSEvents.eventHandlers = [];
|
JSEvents.deferredCalls = [];
|
},
|
registerRemoveEventListeners: function() {
|
if (!JSEvents.removeEventListenersRegistered) {
|
__ATEXIT__.push(JSEvents.removeAllEventListeners);
|
JSEvents.removeEventListenersRegistered = true;
|
}
|
},
|
deferredCalls: [],
|
deferCall: function(targetFunction, precedence, argsList) {
|
function arraysHaveEqualContent(arrA, arrB) {
|
if (arrA.length != arrB.length) return false;
|
for (var i in arrA) {
|
if (arrA[i] != arrB[i]) return false;
|
}
|
return true;
|
}
|
for (var i in JSEvents.deferredCalls) {
|
var call = JSEvents.deferredCalls[i];
|
if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
|
return;
|
}
|
}
|
JSEvents.deferredCalls.push({
|
targetFunction: targetFunction,
|
precedence: precedence,
|
argsList: argsList
|
});
|
JSEvents.deferredCalls.sort(function(x, y) {
|
return x.precedence < y.precedence;
|
});
|
},
|
removeDeferredCalls: function(targetFunction) {
|
for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
|
if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
|
JSEvents.deferredCalls.splice(i, 1);
|
--i;
|
}
|
}
|
},
|
canPerformEventHandlerRequests: function() {
|
return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
|
},
|
runDeferredCalls: function() {
|
if (!JSEvents.canPerformEventHandlerRequests()) {
|
return;
|
}
|
for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
|
var call = JSEvents.deferredCalls[i];
|
JSEvents.deferredCalls.splice(i, 1);
|
--i;
|
call.targetFunction.apply(null, call.argsList);
|
}
|
},
|
eventHandlers: [],
|
removeAllHandlersOnTarget: function(target, eventTypeString) {
|
for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
|
if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
|
JSEvents._removeHandler(i--);
|
}
|
}
|
},
|
_removeHandler: function(i) {
|
var h = JSEvents.eventHandlers[i];
|
h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
|
JSEvents.eventHandlers.splice(i, 1);
|
},
|
registerOrRemoveHandler: function(eventHandler) {
|
var jsEventHandler = function jsEventHandler(event) {
|
++JSEvents.inEventHandler;
|
JSEvents.currentEventHandler = eventHandler;
|
JSEvents.runDeferredCalls();
|
eventHandler.handlerFunc(event);
|
JSEvents.runDeferredCalls();
|
--JSEvents.inEventHandler;
|
};
|
if (eventHandler.callbackfunc) {
|
eventHandler.eventListenerFunc = jsEventHandler;
|
eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
|
JSEvents.eventHandlers.push(eventHandler);
|
JSEvents.registerRemoveEventListeners();
|
} else {
|
for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
|
if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
|
JSEvents._removeHandler(i--);
|
}
|
}
|
}
|
},
|
queueEventHandlerOnThread_iiii: function(targetThread, eventHandlerFunc, eventTypeId, eventData, userData) {
|
var stackTop = stackSave();
|
var varargs = stackAlloc(12);
|
GROWABLE_HEAP_I32()[varargs >> 2] = eventTypeId;
|
GROWABLE_HEAP_I32()[varargs + 4 >> 2] = eventData;
|
GROWABLE_HEAP_I32()[varargs + 8 >> 2] = userData;
|
__emscripten_call_on_thread(0, targetThread, 637534208, eventHandlerFunc, eventData, varargs);
|
stackRestore(stackTop);
|
},
|
getTargetThreadForEventCallback: function(targetThread) {
|
switch (targetThread) {
|
case 1:
|
return 0;
|
|
case 2:
|
return PThread.currentProxiedOperationCallerThread;
|
|
default:
|
return targetThread;
|
}
|
},
|
getNodeNameForTarget: function(target) {
|
if (!target) return "";
|
if (target == window) return "#window";
|
if (target == screen) return "#screen";
|
return target && target.nodeName ? target.nodeName : "";
|
},
|
fullscreenEnabled: function() {
|
return document.fullscreenEnabled || document.webkitFullscreenEnabled;
|
}
|
};
|
|
function __webgl_enable_ANGLE_instanced_arrays(ctx) {
|
var ext = ctx.getExtension("ANGLE_instanced_arrays");
|
if (ext) {
|
ctx["vertexAttribDivisor"] = function(index, divisor) {
|
ext["vertexAttribDivisorANGLE"](index, divisor);
|
};
|
ctx["drawArraysInstanced"] = function(mode, first, count, primcount) {
|
ext["drawArraysInstancedANGLE"](mode, first, count, primcount);
|
};
|
ctx["drawElementsInstanced"] = function(mode, count, type, indices, primcount) {
|
ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount);
|
};
|
return 1;
|
}
|
}
|
|
function __webgl_enable_OES_vertex_array_object(ctx) {
|
var ext = ctx.getExtension("OES_vertex_array_object");
|
if (ext) {
|
ctx["createVertexArray"] = function() {
|
return ext["createVertexArrayOES"]();
|
};
|
ctx["deleteVertexArray"] = function(vao) {
|
ext["deleteVertexArrayOES"](vao);
|
};
|
ctx["bindVertexArray"] = function(vao) {
|
ext["bindVertexArrayOES"](vao);
|
};
|
ctx["isVertexArray"] = function(vao) {
|
return ext["isVertexArrayOES"](vao);
|
};
|
return 1;
|
}
|
}
|
|
function __webgl_enable_WEBGL_draw_buffers(ctx) {
|
var ext = ctx.getExtension("WEBGL_draw_buffers");
|
if (ext) {
|
ctx["drawBuffers"] = function(n, bufs) {
|
ext["drawBuffersWEBGL"](n, bufs);
|
};
|
return 1;
|
}
|
}
|
|
function __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) {
|
return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));
|
}
|
|
function __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) {
|
return !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));
|
}
|
|
function __webgl_enable_WEBGL_multi_draw(ctx) {
|
return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"));
|
}
|
|
var GL = {
|
counter: 1,
|
buffers: [],
|
programs: [],
|
framebuffers: [],
|
renderbuffers: [],
|
textures: [],
|
shaders: [],
|
vaos: [],
|
contexts: {},
|
offscreenCanvases: {},
|
queries: [],
|
samplers: [],
|
transformFeedbacks: [],
|
syncs: [],
|
stringCache: {},
|
stringiCache: {},
|
unpackAlignment: 4,
|
recordError: function recordError(errorCode) {
|
if (!GL.lastError) {
|
GL.lastError = errorCode;
|
}
|
},
|
getNewId: function(table) {
|
var ret = GL.counter++;
|
for (var i = table.length; i < ret; i++) {
|
table[i] = null;
|
}
|
return ret;
|
},
|
getSource: function(shader, count, string, length) {
|
var source = "";
|
for (var i = 0; i < count; ++i) {
|
var len = length ? GROWABLE_HEAP_I32()[length + i * 4 >> 2] : -1;
|
source += UTF8ToString(GROWABLE_HEAP_I32()[string + i * 4 >> 2], len < 0 ? undefined : len);
|
}
|
return source;
|
},
|
createContext: function(canvas, webGLContextAttributes) {
|
if (!canvas.getContextSafariWebGL2Fixed) {
|
canvas.getContextSafariWebGL2Fixed = canvas.getContext;
|
canvas.getContext = function(ver, attrs) {
|
var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
|
return ver == "webgl" == gl instanceof WebGLRenderingContext ? gl : null;
|
};
|
}
|
if (Module["preinitializedWebGLContext"]) {
|
var ctx = Module["preinitializedWebGLContext"];
|
webGLContextAttributes.majorVersion = typeof WebGL2RenderingContext !== "undefined" && ctx instanceof WebGL2RenderingContext ? 2 : 1;
|
} else {
|
var ctx = webGLContextAttributes.majorVersion > 1 ? canvas.getContext("webgl2", webGLContextAttributes) : canvas.getContext("webgl", webGLContextAttributes);
|
}
|
if (!ctx) return 0;
|
var handle = GL.registerContext(ctx, webGLContextAttributes);
|
return handle;
|
},
|
registerContext: function(ctx, webGLContextAttributes) {
|
var handle = _malloc(8);
|
GROWABLE_HEAP_I32()[handle + 4 >> 2] = _pthread_self();
|
var context = {
|
handle: handle,
|
attributes: webGLContextAttributes,
|
version: webGLContextAttributes.majorVersion,
|
GLctx: ctx
|
};
|
if (ctx.canvas) ctx.canvas.GLctxObject = context;
|
GL.contexts[handle] = context;
|
if (typeof webGLContextAttributes.enableExtensionsByDefault === "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
|
GL.initExtensions(context);
|
}
|
return handle;
|
},
|
makeContextCurrent: function(contextHandle) {
|
GL.currentContext = GL.contexts[contextHandle];
|
Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx;
|
return !(contextHandle && !GLctx);
|
},
|
getContext: function(contextHandle) {
|
return GL.contexts[contextHandle];
|
},
|
deleteContext: function(contextHandle) {
|
if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null;
|
if (typeof JSEvents === "object") JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
|
if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
|
_free(GL.contexts[contextHandle].handle);
|
GL.contexts[contextHandle] = null;
|
},
|
initExtensions: function(context) {
|
if (!context) context = GL.currentContext;
|
if (context.initExtensionsDone) return;
|
context.initExtensionsDone = true;
|
var GLctx = context.GLctx;
|
__webgl_enable_ANGLE_instanced_arrays(GLctx);
|
__webgl_enable_OES_vertex_array_object(GLctx);
|
__webgl_enable_WEBGL_draw_buffers(GLctx);
|
__webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);
|
__webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);
|
if (context.version >= 2) {
|
GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2");
|
}
|
if (context.version < 2 || !GLctx.disjointTimerQueryExt) {
|
GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
|
}
|
__webgl_enable_WEBGL_multi_draw(GLctx);
|
var exts = GLctx.getSupportedExtensions() || [];
|
exts.forEach(function(ext) {
|
if (ext.indexOf("lose_context") < 0 && ext.indexOf("debug") < 0) {
|
GLctx.getExtension(ext);
|
}
|
});
|
}
|
};
|
|
function maybeCStringToJsString(cString) {
|
return cString > 2 ? UTF8ToString(cString) : cString;
|
}
|
|
function findCanvasEventTarget(target) {
|
target = maybeCStringToJsString(target);
|
return GL.offscreenCanvases[target.substr(1)] || target == "canvas" && Object.keys(GL.offscreenCanvases)[0] || typeof document !== "undefined" && document.querySelector(target);
|
}
|
|
function _emscripten_get_canvas_element_size_calling_thread(target, width, height) {
|
var canvas = findCanvasEventTarget(target);
|
if (!canvas) return -4;
|
if (canvas.canvasSharedPtr) {
|
var w = GROWABLE_HEAP_I32()[canvas.canvasSharedPtr >> 2];
|
var h = GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 4 >> 2];
|
GROWABLE_HEAP_I32()[width >> 2] = w;
|
GROWABLE_HEAP_I32()[height >> 2] = h;
|
} else if (canvas.offscreenCanvas) {
|
GROWABLE_HEAP_I32()[width >> 2] = canvas.offscreenCanvas.width;
|
GROWABLE_HEAP_I32()[height >> 2] = canvas.offscreenCanvas.height;
|
} else if (!canvas.controlTransferredOffscreen) {
|
GROWABLE_HEAP_I32()[width >> 2] = canvas.width;
|
GROWABLE_HEAP_I32()[height >> 2] = canvas.height;
|
} else {
|
return -4;
|
}
|
return 0;
|
}
|
|
function _emscripten_get_canvas_element_size_main_thread(target, width, height) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(29, 1, target, width, height);
|
return _emscripten_get_canvas_element_size_calling_thread(target, width, height);
|
}
|
|
function _emscripten_get_canvas_element_size(target, width, height) {
|
var canvas = findCanvasEventTarget(target);
|
if (canvas) {
|
return _emscripten_get_canvas_element_size_calling_thread(target, width, height);
|
} else {
|
return _emscripten_get_canvas_element_size_main_thread(target, width, height);
|
}
|
}
|
|
function _longjmp(env, value) {
|
_setThrew(env, value || 1);
|
throw "longjmp";
|
}
|
|
function _emscripten_longjmp(a0, a1) {
|
return _longjmp(a0, a1);
|
}
|
|
function _emscripten_memcpy_big(dest, src, num) {
|
GROWABLE_HEAP_U8().copyWithin(dest, src, src + num);
|
}
|
|
function _emscripten_proxy_to_main_thread_js(index, sync) {
|
var numCallArgs = arguments.length - 2;
|
if (numCallArgs > 20 - 1) throw "emscripten_proxy_to_main_thread_js: Too many arguments " + numCallArgs + " to proxied function idx=" + index + ", maximum supported is " + (20 - 1) + "!";
|
var stack = stackSave();
|
var serializedNumCallArgs = numCallArgs;
|
var args = stackAlloc(serializedNumCallArgs * 8);
|
var b = args >> 3;
|
for (var i = 0; i < numCallArgs; i++) {
|
var arg = arguments[2 + i];
|
GROWABLE_HEAP_F64()[b + i] = arg;
|
}
|
var ret = _emscripten_run_in_main_runtime_thread_js(index, serializedNumCallArgs, args, sync);
|
stackRestore(stack);
|
return ret;
|
}
|
|
var _emscripten_receive_on_main_thread_js_callArgs = [];
|
|
function _emscripten_receive_on_main_thread_js(index, numCallArgs, args) {
|
_emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
|
var b = args >> 3;
|
for (var i = 0; i < numCallArgs; i++) {
|
_emscripten_receive_on_main_thread_js_callArgs[i] = GROWABLE_HEAP_F64()[b + i];
|
}
|
var isEmAsmConst = index < 0;
|
var func = !isEmAsmConst ? proxiedFunctionTable[index] : ASM_CONSTS[-index - 1];
|
assert(func.length == numCallArgs, "Call args mismatch in emscripten_receive_on_main_thread_js");
|
return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
|
}
|
|
function emscripten_realloc_buffer(size) {
|
try {
|
wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
|
updateGlobalBufferAndViews(wasmMemory.buffer);
|
return 1;
|
} catch (e) {
|
console.error("emscripten_realloc_buffer: Attempted to grow heap from " + buffer.byteLength + " bytes to " + size + " bytes, but got error: " + e);
|
}
|
}
|
|
function _emscripten_resize_heap(requestedSize) {
|
var oldSize = GROWABLE_HEAP_U8().length;
|
requestedSize = requestedSize >>> 0;
|
if (requestedSize <= oldSize) {
|
return false;
|
}
|
var maxHeapSize = 1048576e3;
|
if (requestedSize > maxHeapSize) {
|
err("Cannot enlarge memory, asked to go up to " + requestedSize + " bytes, but the limit is " + maxHeapSize + " bytes!");
|
return false;
|
}
|
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
|
var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
|
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
|
var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
|
var replacement = emscripten_realloc_buffer(newSize);
|
if (replacement) {
|
return true;
|
}
|
}
|
err("Failed to grow the heap from " + oldSize + " bytes to " + newSize + " bytes, not enough memory!");
|
return false;
|
}
|
|
function stringToNewUTF8(jsString) {
|
var length = lengthBytesUTF8(jsString) + 1;
|
var cString = _malloc(length);
|
stringToUTF8(jsString, cString, length);
|
return cString;
|
}
|
|
function _emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height) {
|
var stackTop = stackSave();
|
var varargs = stackAlloc(12);
|
var targetCanvasPtr = 0;
|
if (targetCanvas) {
|
targetCanvasPtr = stringToNewUTF8(targetCanvas);
|
}
|
GROWABLE_HEAP_I32()[varargs >> 2] = targetCanvasPtr;
|
GROWABLE_HEAP_I32()[varargs + 4 >> 2] = width;
|
GROWABLE_HEAP_I32()[varargs + 8 >> 2] = height;
|
__emscripten_call_on_thread(0, targetThread, 657457152, 0, targetCanvasPtr, varargs);
|
stackRestore(stackTop);
|
}
|
|
function _emscripten_set_offscreencanvas_size_on_target_thread(targetThread, targetCanvas, width, height) {
|
targetCanvas = targetCanvas ? UTF8ToString(targetCanvas) : "";
|
_emscripten_set_offscreencanvas_size_on_target_thread_js(targetThread, targetCanvas, width, height);
|
}
|
|
function _emscripten_set_canvas_element_size_calling_thread(target, width, height) {
|
var canvas = findCanvasEventTarget(target);
|
if (!canvas) return -4;
|
if (canvas.canvasSharedPtr) {
|
GROWABLE_HEAP_I32()[canvas.canvasSharedPtr >> 2] = width;
|
GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 4 >> 2] = height;
|
}
|
if (canvas.offscreenCanvas || !canvas.controlTransferredOffscreen) {
|
if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas;
|
var autoResizeViewport = false;
|
if (canvas.GLctxObject && canvas.GLctxObject.GLctx) {
|
var prevViewport = canvas.GLctxObject.GLctx.getParameter(2978);
|
autoResizeViewport = prevViewport[0] === 0 && prevViewport[1] === 0 && prevViewport[2] === canvas.width && prevViewport[3] === canvas.height;
|
}
|
canvas.width = width;
|
canvas.height = height;
|
if (autoResizeViewport) {
|
canvas.GLctxObject.GLctx.viewport(0, 0, width, height);
|
}
|
} else if (canvas.canvasSharedPtr) {
|
var targetThread = GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 8 >> 2];
|
_emscripten_set_offscreencanvas_size_on_target_thread(targetThread, target, width, height);
|
return 1;
|
} else {
|
return -4;
|
}
|
return 0;
|
}
|
|
function _emscripten_set_canvas_element_size_main_thread(target, width, height) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(30, 1, target, width, height);
|
return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
|
}
|
|
function _emscripten_set_canvas_element_size(target, width, height) {
|
var canvas = findCanvasEventTarget(target);
|
if (canvas) {
|
return _emscripten_set_canvas_element_size_calling_thread(target, width, height);
|
} else {
|
return _emscripten_set_canvas_element_size_main_thread(target, width, height);
|
}
|
}
|
|
function _emscripten_set_current_thread_status_js(newStatus) {}
|
|
function _emscripten_set_current_thread_status(newStatus) {}
|
|
function _emscripten_set_main_loop_arg(func, arg, fps, simulateInfiniteLoop) {
|
var browserIterationFunc = function() {
|
wasmTable.get(func)(arg);
|
};
|
setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop, arg);
|
}
|
|
function _emscripten_set_thread_name(threadId, name) {}
|
|
function _emscripten_supports_offscreencanvas() {
|
return typeof OffscreenCanvas !== "undefined";
|
}
|
|
function _emscripten_webgl_do_commit_frame() {
|
if (!GL.currentContext || !GL.currentContext.GLctx) {
|
return -3;
|
}
|
if (!GL.currentContext.attributes.explicitSwapControl) {
|
return -3;
|
}
|
return 0;
|
}
|
|
function _emscripten_webgl_commit_frame() {
|
return _emscripten_webgl_do_commit_frame();
|
}
|
|
var __emscripten_webgl_power_preferences = [ "default", "low-power", "high-performance" ];
|
|
var specialHTMLTargets = [ 0, typeof document !== "undefined" ? document : 0, typeof window !== "undefined" ? window : 0 ];
|
|
function findEventTarget(target) {
|
target = maybeCStringToJsString(target);
|
var domElement = specialHTMLTargets[target] || (typeof document !== "undefined" ? document.querySelector(target) : undefined);
|
return domElement;
|
}
|
|
function _emscripten_webgl_do_create_context(target, attributes) {
|
assert(attributes);
|
var a = attributes >> 2;
|
var powerPreference = GROWABLE_HEAP_I32()[a + (24 >> 2)];
|
var contextAttributes = {
|
"alpha": !!GROWABLE_HEAP_I32()[a + (0 >> 2)],
|
"depth": !!GROWABLE_HEAP_I32()[a + (4 >> 2)],
|
"stencil": !!GROWABLE_HEAP_I32()[a + (8 >> 2)],
|
"antialias": !!GROWABLE_HEAP_I32()[a + (12 >> 2)],
|
"premultipliedAlpha": !!GROWABLE_HEAP_I32()[a + (16 >> 2)],
|
"preserveDrawingBuffer": !!GROWABLE_HEAP_I32()[a + (20 >> 2)],
|
"powerPreference": __emscripten_webgl_power_preferences[powerPreference],
|
"failIfMajorPerformanceCaveat": !!GROWABLE_HEAP_I32()[a + (28 >> 2)],
|
majorVersion: GROWABLE_HEAP_I32()[a + (32 >> 2)],
|
minorVersion: GROWABLE_HEAP_I32()[a + (36 >> 2)],
|
enableExtensionsByDefault: GROWABLE_HEAP_I32()[a + (40 >> 2)],
|
explicitSwapControl: GROWABLE_HEAP_I32()[a + (44 >> 2)],
|
proxyContextToMainThread: GROWABLE_HEAP_I32()[a + (48 >> 2)],
|
renderViaOffscreenBackBuffer: GROWABLE_HEAP_I32()[a + (52 >> 2)]
|
};
|
var canvas = findCanvasEventTarget(target);
|
if (!canvas) {
|
return 0;
|
}
|
if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas;
|
if (contextAttributes.explicitSwapControl) {
|
var supportsOffscreenCanvas = canvas.transferControlToOffscreen || typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas;
|
if (!supportsOffscreenCanvas) {
|
return 0;
|
}
|
if (canvas.transferControlToOffscreen) {
|
if (!canvas.controlTransferredOffscreen) {
|
GL.offscreenCanvases[canvas.id] = {
|
canvas: canvas.transferControlToOffscreen(),
|
canvasSharedPtr: _malloc(12),
|
id: canvas.id
|
};
|
canvas.controlTransferredOffscreen = true;
|
} else if (!GL.offscreenCanvases[canvas.id]) {
|
return 0;
|
}
|
canvas = GL.offscreenCanvases[canvas.id];
|
}
|
}
|
var contextHandle = GL.createContext(canvas, contextAttributes);
|
return contextHandle;
|
}
|
|
function _emscripten_webgl_create_context(a0, a1) {
|
return _emscripten_webgl_do_create_context(a0, a1);
|
}
|
|
function _emscripten_webgl_do_get_current_context() {
|
return GL.currentContext ? GL.currentContext.handle : 0;
|
}
|
|
function _emscripten_webgl_get_current_context() {
|
return _emscripten_webgl_do_get_current_context();
|
}
|
|
Module["_emscripten_webgl_get_current_context"] = _emscripten_webgl_get_current_context;
|
|
function _emscripten_webgl_make_context_current(contextHandle) {
|
var success = GL.makeContextCurrent(contextHandle);
|
return success ? 0 : -5;
|
}
|
|
Module["_emscripten_webgl_make_context_current"] = _emscripten_webgl_make_context_current;
|
|
function _emscripten_webgl_destroy_context_calling_thread(contextHandle) {
|
if (GL.currentContext == contextHandle) GL.currentContext = 0;
|
GL.deleteContext(contextHandle);
|
}
|
|
function _emscripten_webgl_destroy_context_main_thread(a0) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(31, 1, a0);
|
return _emscripten_webgl_destroy_context_calling_thread(a0);
|
}
|
|
function _emscripten_webgl_destroy_context_before_on_calling_thread(contextHandle) {
|
if (_emscripten_webgl_get_current_context() == contextHandle) _emscripten_webgl_make_context_current(0);
|
}
|
|
function _emscripten_webgl_destroy_context(p0) {
|
_emscripten_webgl_destroy_context_before_on_calling_thread(p0);
|
GL.contexts[p0] ? _emscripten_webgl_destroy_context_calling_thread(p0) : _emscripten_webgl_destroy_context_main_thread(p0);
|
}
|
|
function _emscripten_webgl_init_context_attributes(attributes) {
|
assert(attributes);
|
var a = attributes >> 2;
|
for (var i = 0; i < 56 >> 2; ++i) {
|
GROWABLE_HEAP_I32()[a + i] = 0;
|
}
|
GROWABLE_HEAP_I32()[a + (0 >> 2)] = GROWABLE_HEAP_I32()[a + (4 >> 2)] = GROWABLE_HEAP_I32()[a + (12 >> 2)] = GROWABLE_HEAP_I32()[a + (16 >> 2)] = GROWABLE_HEAP_I32()[a + (32 >> 2)] = GROWABLE_HEAP_I32()[a + (40 >> 2)] = 1;
|
if (ENVIRONMENT_IS_WORKER) GROWABLE_HEAP_I32()[attributes + 48 >> 2] = 1;
|
}
|
|
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) {
|
env[x] = ENV[x];
|
}
|
var strings = [];
|
for (var x in env) {
|
strings.push(x + "=" + env[x]);
|
}
|
getEnvStrings.strings = strings;
|
}
|
return getEnvStrings.strings;
|
}
|
|
function _environ_get(__environ, environ_buf) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(32, 1, __environ, environ_buf);
|
try {
|
var bufSize = 0;
|
getEnvStrings().forEach(function(string, i) {
|
var ptr = environ_buf + bufSize;
|
GROWABLE_HEAP_I32()[__environ + i * 4 >> 2] = ptr;
|
writeAsciiToMemory(string, ptr);
|
bufSize += string.length + 1;
|
});
|
return 0;
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return e.errno;
|
}
|
}
|
|
function _environ_sizes_get(penviron_count, penviron_buf_size) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(33, 1, penviron_count, penviron_buf_size);
|
try {
|
var strings = getEnvStrings();
|
GROWABLE_HEAP_I32()[penviron_count >> 2] = strings.length;
|
var bufSize = 0;
|
strings.forEach(function(string) {
|
bufSize += string.length + 1;
|
});
|
GROWABLE_HEAP_I32()[penviron_buf_size >> 2] = bufSize;
|
return 0;
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return e.errno;
|
}
|
}
|
|
function _fd_close(fd) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(34, 1, fd);
|
try {
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
FS.close(stream);
|
return 0;
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return e.errno;
|
}
|
}
|
|
function _fd_read(fd, iov, iovcnt, pnum) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(35, 1, fd, iov, iovcnt, pnum);
|
try {
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
var num = SYSCALLS.doReadv(stream, iov, iovcnt);
|
GROWABLE_HEAP_I32()[pnum >> 2] = num;
|
return 0;
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return e.errno;
|
}
|
}
|
|
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(36, 1, fd, offset_low, offset_high, whence, newOffset);
|
try {
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
var HIGH_OFFSET = 4294967296;
|
var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);
|
var DOUBLE_LIMIT = 9007199254740992;
|
if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
|
return -61;
|
}
|
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) ],
|
GROWABLE_HEAP_I32()[newOffset >> 2] = tempI64[0], GROWABLE_HEAP_I32()[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)) abort(e);
|
return e.errno;
|
}
|
}
|
|
function _fd_write(fd, iov, iovcnt, pnum) {
|
if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(37, 1, fd, iov, iovcnt, pnum);
|
try {
|
var stream = SYSCALLS.getStreamFromFD(fd);
|
var num = SYSCALLS.doWritev(stream, iov, iovcnt);
|
GROWABLE_HEAP_I32()[pnum >> 2] = num;
|
return 0;
|
} catch (e) {
|
if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
|
return e.errno;
|
}
|
}
|
|
function _getTempRet0() {
|
return getTempRet0() | 0;
|
}
|
|
function _gettimeofday(ptr) {
|
var now = Date.now();
|
GROWABLE_HEAP_I32()[ptr >> 2] = now / 1e3 | 0;
|
GROWABLE_HEAP_I32()[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0;
|
return 0;
|
}
|
|
function _glActiveTexture(x0) {
|
GLctx["activeTexture"](x0);
|
}
|
|
function _glAttachShader(program, shader) {
|
GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
|
}
|
|
function _glBindBuffer(target, buffer) {
|
if (target == 35051) {
|
GLctx.currentPixelPackBufferBinding = buffer;
|
} else if (target == 35052) {
|
GLctx.currentPixelUnpackBufferBinding = buffer;
|
}
|
GLctx.bindBuffer(target, GL.buffers[buffer]);
|
}
|
|
function _glBindFramebuffer(target, framebuffer) {
|
GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
|
}
|
|
function _glBindTexture(target, texture) {
|
GLctx.bindTexture(target, GL.textures[texture]);
|
}
|
|
function _glBlendFunc(x0, x1) {
|
GLctx["blendFunc"](x0, x1);
|
}
|
|
function _glBufferData(target, size, data, usage) {
|
if (GL.currentContext.version >= 2) {
|
if (data) {
|
GLctx.bufferData(target, GROWABLE_HEAP_U8(), usage, data, size);
|
} else {
|
GLctx.bufferData(target, size, usage);
|
}
|
} else {
|
GLctx.bufferData(target, data ? GROWABLE_HEAP_U8().subarray(data, data + size) : size, usage);
|
}
|
}
|
|
function _glClear(x0) {
|
GLctx["clear"](x0);
|
}
|
|
function _glCompileShader(shader) {
|
GLctx.compileShader(GL.shaders[shader]);
|
}
|
|
function _glCreateProgram() {
|
var id = GL.getNewId(GL.programs);
|
var program = GLctx.createProgram();
|
program.name = id;
|
program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
|
program.uniformIdCounter = 1;
|
GL.programs[id] = program;
|
return id;
|
}
|
|
function _glCreateShader(shaderType) {
|
var id = GL.getNewId(GL.shaders);
|
GL.shaders[id] = GLctx.createShader(shaderType);
|
return id;
|
}
|
|
function _glDeleteBuffers(n, buffers) {
|
for (var i = 0; i < n; i++) {
|
var id = GROWABLE_HEAP_I32()[buffers + i * 4 >> 2];
|
var buffer = GL.buffers[id];
|
if (!buffer) continue;
|
GLctx.deleteBuffer(buffer);
|
buffer.name = 0;
|
GL.buffers[id] = null;
|
if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
|
if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
|
}
|
}
|
|
function _glDeleteFramebuffers(n, framebuffers) {
|
for (var i = 0; i < n; ++i) {
|
var id = GROWABLE_HEAP_I32()[framebuffers + i * 4 >> 2];
|
var framebuffer = GL.framebuffers[id];
|
if (!framebuffer) continue;
|
GLctx.deleteFramebuffer(framebuffer);
|
framebuffer.name = 0;
|
GL.framebuffers[id] = null;
|
}
|
}
|
|
function _glDeleteProgram(id) {
|
if (!id) return;
|
var program = GL.programs[id];
|
if (!program) {
|
GL.recordError(1281);
|
return;
|
}
|
GLctx.deleteProgram(program);
|
program.name = 0;
|
GL.programs[id] = null;
|
}
|
|
function _glDeleteRenderbuffers(n, renderbuffers) {
|
for (var i = 0; i < n; i++) {
|
var id = GROWABLE_HEAP_I32()[renderbuffers + i * 4 >> 2];
|
var renderbuffer = GL.renderbuffers[id];
|
if (!renderbuffer) continue;
|
GLctx.deleteRenderbuffer(renderbuffer);
|
renderbuffer.name = 0;
|
GL.renderbuffers[id] = null;
|
}
|
}
|
|
function _glDeleteShader(id) {
|
if (!id) return;
|
var shader = GL.shaders[id];
|
if (!shader) {
|
GL.recordError(1281);
|
return;
|
}
|
GLctx.deleteShader(shader);
|
GL.shaders[id] = null;
|
}
|
|
function _glDeleteTextures(n, textures) {
|
for (var i = 0; i < n; i++) {
|
var id = GROWABLE_HEAP_I32()[textures + i * 4 >> 2];
|
var texture = GL.textures[id];
|
if (!texture) continue;
|
GLctx.deleteTexture(texture);
|
texture.name = 0;
|
GL.textures[id] = null;
|
}
|
}
|
|
function _glDepthFunc(x0) {
|
GLctx["depthFunc"](x0);
|
}
|
|
function _glDepthMask(flag) {
|
GLctx.depthMask(!!flag);
|
}
|
|
function _glDetachShader(program, shader) {
|
GLctx.detachShader(GL.programs[program], GL.shaders[shader]);
|
}
|
|
function _glDisable(x0) {
|
GLctx["disable"](x0);
|
}
|
|
function _glDrawArrays(mode, first, count) {
|
GLctx.drawArrays(mode, first, count);
|
}
|
|
function _glEnable(x0) {
|
GLctx["enable"](x0);
|
}
|
|
function _glEnableVertexAttribArray(index) {
|
GLctx.enableVertexAttribArray(index);
|
}
|
|
function _glFramebufferTexture2D(target, attachment, textarget, texture, level) {
|
GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level);
|
}
|
|
function __glGenObject(n, buffers, createFunction, objectTable) {
|
for (var i = 0; i < n; i++) {
|
var buffer = GLctx[createFunction]();
|
var id = buffer && GL.getNewId(objectTable);
|
if (buffer) {
|
buffer.name = id;
|
objectTable[id] = buffer;
|
} else {
|
GL.recordError(1282);
|
}
|
GROWABLE_HEAP_I32()[buffers + i * 4 >> 2] = id;
|
}
|
}
|
|
function _glGenBuffers(n, buffers) {
|
__glGenObject(n, buffers, "createBuffer", GL.buffers);
|
}
|
|
function _glGenFramebuffers(n, ids) {
|
__glGenObject(n, ids, "createFramebuffer", GL.framebuffers);
|
}
|
|
function _glGenTextures(n, textures) {
|
__glGenObject(n, textures, "createTexture", GL.textures);
|
}
|
|
function _glGenerateMipmap(x0) {
|
GLctx["generateMipmap"](x0);
|
}
|
|
function _glGetAttribLocation(program, name) {
|
return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
|
}
|
|
function readI53FromI64(ptr) {
|
return GROWABLE_HEAP_U32()[ptr >> 2] + GROWABLE_HEAP_I32()[ptr + 4 >> 2] * 4294967296;
|
}
|
|
function readI53FromU64(ptr) {
|
return GROWABLE_HEAP_U32()[ptr >> 2] + GROWABLE_HEAP_U32()[ptr + 4 >> 2] * 4294967296;
|
}
|
|
function writeI53ToI64(ptr, num) {
|
GROWABLE_HEAP_U32()[ptr >> 2] = num;
|
GROWABLE_HEAP_U32()[ptr + 4 >> 2] = (num - GROWABLE_HEAP_U32()[ptr >> 2]) / 4294967296;
|
var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr);
|
if (deserialized != num) warnOnce("writeI53ToI64() out of range: serialized JS Number " + num + " to Wasm heap as bytes lo=0x" + GROWABLE_HEAP_U32()[ptr >> 2].toString(16) + ", hi=0x" + GROWABLE_HEAP_U32()[ptr + 4 >> 2].toString(16) + ", which deserializes back to " + deserialized + " instead!");
|
}
|
|
function emscriptenWebGLGet(name_, p, type) {
|
if (!p) {
|
GL.recordError(1281);
|
return;
|
}
|
var ret = undefined;
|
switch (name_) {
|
case 36346:
|
ret = 1;
|
break;
|
|
case 36344:
|
if (type != 0 && type != 1) {
|
GL.recordError(1280);
|
}
|
return;
|
|
case 34814:
|
case 36345:
|
ret = 0;
|
break;
|
|
case 34466:
|
var formats = GLctx.getParameter(34467);
|
ret = formats ? formats.length : 0;
|
break;
|
|
case 33309:
|
if (GL.currentContext.version < 2) {
|
GL.recordError(1282);
|
return;
|
}
|
var exts = GLctx.getSupportedExtensions() || [];
|
ret = 2 * exts.length;
|
break;
|
|
case 33307:
|
case 33308:
|
if (GL.currentContext.version < 2) {
|
GL.recordError(1280);
|
return;
|
}
|
ret = name_ == 33307 ? 3 : 0;
|
break;
|
}
|
if (ret === undefined) {
|
var result = GLctx.getParameter(name_);
|
switch (typeof result) {
|
case "number":
|
ret = result;
|
break;
|
|
case "boolean":
|
ret = result ? 1 : 0;
|
break;
|
|
case "string":
|
GL.recordError(1280);
|
return;
|
|
case "object":
|
if (result === null) {
|
switch (name_) {
|
case 34964:
|
case 35725:
|
case 34965:
|
case 36006:
|
case 36007:
|
case 32873:
|
case 34229:
|
case 36662:
|
case 36663:
|
case 35053:
|
case 35055:
|
case 36010:
|
case 35097:
|
case 35869:
|
case 32874:
|
case 36389:
|
case 35983:
|
case 35368:
|
case 34068:
|
{
|
ret = 0;
|
break;
|
}
|
|
default:
|
{
|
GL.recordError(1280);
|
return;
|
}
|
}
|
} else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) {
|
for (var i = 0; i < result.length; ++i) {
|
switch (type) {
|
case 0:
|
GROWABLE_HEAP_I32()[p + i * 4 >> 2] = result[i];
|
break;
|
|
case 2:
|
GROWABLE_HEAP_F32()[p + i * 4 >> 2] = result[i];
|
break;
|
|
case 4:
|
GROWABLE_HEAP_I8()[p + i >> 0] = result[i] ? 1 : 0;
|
break;
|
}
|
}
|
return;
|
} else {
|
try {
|
ret = result.name | 0;
|
} catch (e) {
|
GL.recordError(1280);
|
err("GL_INVALID_ENUM in glGet" + type + "v: Unknown object returned from WebGL getParameter(" + name_ + ")! (error: " + e + ")");
|
return;
|
}
|
}
|
break;
|
|
default:
|
GL.recordError(1280);
|
err("GL_INVALID_ENUM in glGet" + type + "v: Native code calling glGet" + type + "v(" + name_ + ") and it returns " + result + " of type " + typeof result + "!");
|
return;
|
}
|
}
|
switch (type) {
|
case 1:
|
writeI53ToI64(p, ret);
|
break;
|
|
case 0:
|
GROWABLE_HEAP_I32()[p >> 2] = ret;
|
break;
|
|
case 2:
|
GROWABLE_HEAP_F32()[p >> 2] = ret;
|
break;
|
|
case 4:
|
GROWABLE_HEAP_I8()[p >> 0] = ret ? 1 : 0;
|
break;
|
}
|
}
|
|
function _glGetIntegerv(name_, p) {
|
emscriptenWebGLGet(name_, p, 0);
|
}
|
|
function _glGetProgramiv(program, pname, p) {
|
if (!p) {
|
GL.recordError(1281);
|
return;
|
}
|
if (program >= GL.counter) {
|
GL.recordError(1281);
|
return;
|
}
|
program = GL.programs[program];
|
if (pname == 35716) {
|
var log = GLctx.getProgramInfoLog(program);
|
if (log === null) log = "(unknown error)";
|
GROWABLE_HEAP_I32()[p >> 2] = log.length + 1;
|
} else if (pname == 35719) {
|
if (!program.maxUniformLength) {
|
for (var i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) {
|
program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length + 1);
|
}
|
}
|
GROWABLE_HEAP_I32()[p >> 2] = program.maxUniformLength;
|
} else if (pname == 35722) {
|
if (!program.maxAttributeLength) {
|
for (var i = 0; i < GLctx.getProgramParameter(program, 35721); ++i) {
|
program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length + 1);
|
}
|
}
|
GROWABLE_HEAP_I32()[p >> 2] = program.maxAttributeLength;
|
} else if (pname == 35381) {
|
if (!program.maxUniformBlockNameLength) {
|
for (var i = 0; i < GLctx.getProgramParameter(program, 35382); ++i) {
|
program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length + 1);
|
}
|
}
|
GROWABLE_HEAP_I32()[p >> 2] = program.maxUniformBlockNameLength;
|
} else {
|
GROWABLE_HEAP_I32()[p >> 2] = GLctx.getProgramParameter(program, pname);
|
}
|
}
|
|
function _glGetShaderInfoLog(shader, maxLength, length, infoLog) {
|
var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
|
if (log === null) log = "(unknown error)";
|
var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
|
if (length) GROWABLE_HEAP_I32()[length >> 2] = numBytesWrittenExclNull;
|
}
|
|
function _glGetShaderiv(shader, pname, p) {
|
if (!p) {
|
GL.recordError(1281);
|
return;
|
}
|
if (pname == 35716) {
|
var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
|
if (log === null) log = "(unknown error)";
|
var logLength = log ? log.length + 1 : 0;
|
GROWABLE_HEAP_I32()[p >> 2] = logLength;
|
} else if (pname == 35720) {
|
var source = GLctx.getShaderSource(GL.shaders[shader]);
|
var sourceLength = source ? source.length + 1 : 0;
|
GROWABLE_HEAP_I32()[p >> 2] = sourceLength;
|
} else {
|
GROWABLE_HEAP_I32()[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
|
}
|
}
|
|
function jstoi_q(str) {
|
return parseInt(str);
|
}
|
|
function _glGetUniformLocation(program, name) {
|
function getLeftBracePos(name) {
|
return name.slice(-1) == "]" && name.lastIndexOf("[");
|
}
|
name = UTF8ToString(name);
|
program = GL.programs[program];
|
var uniformLocsById = program.uniformLocsById;
|
var uniformSizeAndIdsByName = program.uniformSizeAndIdsByName;
|
var i, j;
|
var arrayIndex = 0;
|
var uniformBaseName = name;
|
var leftBrace = getLeftBracePos(name);
|
if (!uniformLocsById) {
|
program.uniformLocsById = uniformLocsById = {};
|
program.uniformArrayNamesById = {};
|
for (i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) {
|
var u = GLctx.getActiveUniform(program, i);
|
var nm = u.name;
|
var sz = u.size;
|
var lb = getLeftBracePos(nm);
|
var arrayName = lb > 0 ? nm.slice(0, lb) : nm;
|
var id = program.uniformIdCounter;
|
program.uniformIdCounter += sz;
|
uniformSizeAndIdsByName[arrayName] = [ sz, id ];
|
for (j = 0; j < sz; ++j) {
|
uniformLocsById[id] = j;
|
program.uniformArrayNamesById[id++] = arrayName;
|
}
|
}
|
}
|
if (leftBrace > 0) {
|
arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0;
|
uniformBaseName = name.slice(0, leftBrace);
|
}
|
var sizeAndId = uniformSizeAndIdsByName[uniformBaseName];
|
if (sizeAndId && arrayIndex < sizeAndId[0]) {
|
arrayIndex += sizeAndId[1];
|
if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) {
|
return arrayIndex;
|
}
|
}
|
return -1;
|
}
|
|
function _glLinkProgram(program) {
|
program = GL.programs[program];
|
GLctx.linkProgram(program);
|
program.uniformLocsById = 0;
|
program.uniformSizeAndIdsByName = {};
|
}
|
|
function _glScissor(x0, x1, x2, x3) {
|
GLctx["scissor"](x0, x1, x2, x3);
|
}
|
|
function _glShaderSource(shader, count, string, length) {
|
var source = GL.getSource(shader, count, string, length);
|
GLctx.shaderSource(GL.shaders[shader], source);
|
}
|
|
function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) {
|
function roundedToNextMultipleOf(x, y) {
|
return x + y - 1 & -y;
|
}
|
var plainRowSize = width * sizePerPixel;
|
var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment);
|
return height * alignedRowSize;
|
}
|
|
function __colorChannelsInGlTextureFormat(format) {
|
var colorChannels = {
|
5: 3,
|
6: 4,
|
8: 2,
|
29502: 3,
|
29504: 4,
|
26917: 2,
|
26918: 2,
|
29846: 3,
|
29847: 4
|
};
|
return colorChannels[format - 6402] || 1;
|
}
|
|
function heapObjectForWebGLType(type) {
|
type -= 5120;
|
if (type == 0) return GROWABLE_HEAP_I8();
|
if (type == 1) return GROWABLE_HEAP_U8();
|
if (type == 2) return GROWABLE_HEAP_I16();
|
if (type == 4) return GROWABLE_HEAP_I32();
|
if (type == 6) return GROWABLE_HEAP_F32();
|
if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return GROWABLE_HEAP_U32();
|
return GROWABLE_HEAP_U16();
|
}
|
|
function heapAccessShiftForWebGLHeap(heap) {
|
return 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
|
}
|
|
function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) {
|
var heap = heapObjectForWebGLType(type);
|
var shift = heapAccessShiftForWebGLHeap(heap);
|
var byteSize = 1 << shift;
|
var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize;
|
var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment);
|
return heap.subarray(pixels >> shift, pixels + bytes >> shift);
|
}
|
|
function _glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) {
|
if (GL.currentContext.version >= 2) {
|
if (GLctx.currentPixelUnpackBufferBinding) {
|
GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
|
} else if (pixels) {
|
var heap = heapObjectForWebGLType(type);
|
GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap));
|
} else {
|
GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, null);
|
}
|
return;
|
}
|
GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null);
|
}
|
|
function _glTexParameteri(x0, x1, x2) {
|
GLctx["texParameteri"](x0, x1, x2);
|
}
|
|
function webglGetUniformLocation(location) {
|
var p = GLctx.currentProgram;
|
var webglLoc = p.uniformLocsById[location];
|
if (webglLoc >= 0) {
|
p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? "[" + webglLoc + "]" : ""));
|
}
|
return webglLoc;
|
}
|
|
function _glUniform1f(location, v0) {
|
GLctx.uniform1f(webglGetUniformLocation(location), v0);
|
}
|
|
function _glUniform1i(location, v0) {
|
GLctx.uniform1i(webglGetUniformLocation(location), v0);
|
}
|
|
function _glUniform4f(location, v0, v1, v2, v3) {
|
GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
|
}
|
|
var miniTempWebGLFloatBuffers = [];
|
|
function _glUniformMatrix4fv(location, count, transpose, value) {
|
if (GL.currentContext.version >= 2) {
|
GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, GROWABLE_HEAP_F32(), value >> 2, count * 16);
|
return;
|
}
|
if (count <= 18) {
|
var view = miniTempWebGLFloatBuffers[16 * count - 1];
|
var heap = GROWABLE_HEAP_F32();
|
value >>= 2;
|
for (var i = 0; i < 16 * count; i += 16) {
|
var dst = value + i;
|
view[i] = heap[dst];
|
view[i + 1] = heap[dst + 1];
|
view[i + 2] = heap[dst + 2];
|
view[i + 3] = heap[dst + 3];
|
view[i + 4] = heap[dst + 4];
|
view[i + 5] = heap[dst + 5];
|
view[i + 6] = heap[dst + 6];
|
view[i + 7] = heap[dst + 7];
|
view[i + 8] = heap[dst + 8];
|
view[i + 9] = heap[dst + 9];
|
view[i + 10] = heap[dst + 10];
|
view[i + 11] = heap[dst + 11];
|
view[i + 12] = heap[dst + 12];
|
view[i + 13] = heap[dst + 13];
|
view[i + 14] = heap[dst + 14];
|
view[i + 15] = heap[dst + 15];
|
}
|
} else {
|
var view = GROWABLE_HEAP_F32().subarray(value >> 2, value + count * 64 >> 2);
|
}
|
GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
|
}
|
|
function _glUseProgram(program) {
|
program = GL.programs[program];
|
GLctx.useProgram(program);
|
GLctx.currentProgram = program;
|
}
|
|
function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) {
|
GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
|
}
|
|
function _glViewport(x0, x1, x2, x3) {
|
GLctx["viewport"](x0, x1, x2, x3);
|
}
|
|
function spawnThread(threadParams) {
|
if (ENVIRONMENT_IS_PTHREAD) throw "Internal Error! spawnThread() can only ever be called from main application thread!";
|
var worker = PThread.getNewWorker();
|
if (!worker) {
|
return 6;
|
}
|
if (worker.pthread !== undefined) throw "Internal error!";
|
if (!threadParams.pthread_ptr) throw "Internal error, no pthread ptr!";
|
PThread.runningWorkers.push(worker);
|
var tlsMemory = _malloc(128 * 4);
|
for (var i = 0; i < 128; ++i) {
|
GROWABLE_HEAP_I32()[tlsMemory + i * 4 >> 2] = 0;
|
}
|
var stackHigh = threadParams.stackBase + threadParams.stackSize;
|
var pthread = PThread.pthreads[threadParams.pthread_ptr] = {
|
worker: worker,
|
stackBase: threadParams.stackBase,
|
stackSize: threadParams.stackSize,
|
allocatedOwnStack: threadParams.allocatedOwnStack,
|
threadInfoStruct: threadParams.pthread_ptr
|
};
|
var tis = pthread.threadInfoStruct >> 2;
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (64 >> 2), threadParams.detached);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (100 >> 2), tlsMemory);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (40 >> 2), pthread.threadInfoStruct);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (80 >> 2), threadParams.stackSize);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (76 >> 2), stackHigh);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (104 >> 2), threadParams.stackSize);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (104 + 8 >> 2), stackHigh);
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (104 + 12 >> 2), threadParams.detached);
|
var global_libc = _emscripten_get_global_libc();
|
var global_locale = global_libc + 40;
|
Atomics.store(GROWABLE_HEAP_U32(), tis + (172 >> 2), global_locale);
|
worker.pthread = pthread;
|
var msg = {
|
"cmd": "run",
|
"start_routine": threadParams.startRoutine,
|
"arg": threadParams.arg,
|
"threadInfoStruct": threadParams.pthread_ptr,
|
"stackBase": threadParams.stackBase,
|
"stackSize": threadParams.stackSize
|
};
|
msg.moduleCanvasId = threadParams.moduleCanvasId;
|
msg.offscreenCanvases = threadParams.offscreenCanvases;
|
worker.runPthread = function() {
|
msg.time = performance.now();
|
worker.postMessage(msg, threadParams.transferList);
|
};
|
if (worker.loaded) {
|
worker.runPthread();
|
delete worker.runPthread;
|
}
|
return 0;
|
}
|
|
function _pthread_create(pthread_ptr, attr, start_routine, arg) {
|
if (typeof SharedArrayBuffer === "undefined") {
|
err("Current environment does not support SharedArrayBuffer, pthreads are not available!");
|
return 6;
|
}
|
if (!pthread_ptr) {
|
err("pthread_create called with a null thread pointer!");
|
return 28;
|
}
|
var transferList = [];
|
var error = 0;
|
var transferredCanvasNames = attr ? GROWABLE_HEAP_I32()[attr + 36 >> 2] : 0;
|
if (transferredCanvasNames == -1) transferredCanvasNames = "#canvas"; else if (transferredCanvasNames) transferredCanvasNames = UTF8ToString(transferredCanvasNames).trim();
|
if (transferredCanvasNames) transferredCanvasNames = transferredCanvasNames.split(",");
|
var offscreenCanvases = {};
|
var moduleCanvasId = Module["canvas"] ? Module["canvas"].id : "";
|
//for (var i in transferredCanvasNames) {
|
for (var i = 0; i < transferredCanvasNames.length; i++) {
|
var name = transferredCanvasNames[i].trim();
|
var offscreenCanvasInfo;
|
try {
|
if (name == "#canvas") {
|
if (!Module["canvas"]) {
|
err('pthread_create: could not find canvas with ID "' + name + '" to transfer to thread!');
|
error = 28;
|
break;
|
}
|
name = Module["canvas"].id;
|
}
|
assert(typeof GL === "object", "OFFSCREENCANVAS_SUPPORT assumes GL is in use (you can force-include it with -s 'DEFAULT_LIBRARY_FUNCS_TO_INCLUDE=[\"$GL\"]')");
|
if (GL.offscreenCanvases[name]) {
|
offscreenCanvasInfo = GL.offscreenCanvases[name];
|
GL.offscreenCanvases[name] = null;
|
if (Module["canvas"] instanceof OffscreenCanvas && name === Module["canvas"].id) Module["canvas"] = null;
|
} else if (!ENVIRONMENT_IS_PTHREAD) {
|
var canvas = Module["canvas"] && Module["canvas"].id === name ? Module["canvas"] : document.querySelector(name);
|
if (!canvas) {
|
err('pthread_create: could not find canvas with ID "' + name + '" to transfer to thread!');
|
error = 28;
|
break;
|
}
|
if (canvas.controlTransferredOffscreen) {
|
err('pthread_create: cannot transfer canvas with ID "' + name + '" to thread, since the current thread does not have control over it!');
|
error = 63;
|
break;
|
}
|
if (canvas.transferControlToOffscreen) {
|
if (!canvas.canvasSharedPtr) {
|
canvas.canvasSharedPtr = _malloc(12);
|
GROWABLE_HEAP_I32()[canvas.canvasSharedPtr >> 2] = canvas.width;
|
GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 4 >> 2] = canvas.height;
|
GROWABLE_HEAP_I32()[canvas.canvasSharedPtr + 8 >> 2] = 0;
|
}
|
offscreenCanvasInfo = {
|
offscreenCanvas: canvas.transferControlToOffscreen(),
|
canvasSharedPtr: canvas.canvasSharedPtr,
|
id: canvas.id
|
};
|
canvas.controlTransferredOffscreen = true;
|
} else {
|
err('pthread_create: cannot transfer control of canvas "' + name + '" to pthread, because current browser does not support OffscreenCanvas!');
|
err("pthread_create: Build with -s OFFSCREEN_FRAMEBUFFER=1 to enable fallback proxying of GL commands from pthread to main thread.");
|
return 52;
|
}
|
}
|
if (offscreenCanvasInfo) {
|
transferList.push(offscreenCanvasInfo.offscreenCanvas);
|
offscreenCanvases[offscreenCanvasInfo.id] = offscreenCanvasInfo;
|
}
|
} catch (e) {
|
err('pthread_create: failed to transfer control of canvas "' + name + '" to OffscreenCanvas! Error: ' + e);
|
return 28;
|
}
|
}
|
if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
|
return _emscripten_sync_run_in_main_thread_4(687865856, pthread_ptr, attr, start_routine, arg);
|
}
|
if (error) return error;
|
var stackSize = 0;
|
var stackBase = 0;
|
var detached = 0;
|
if (attr && attr != -1) {
|
stackSize = GROWABLE_HEAP_I32()[attr >> 2];
|
stackSize += 81920;
|
stackBase = GROWABLE_HEAP_I32()[attr + 8 >> 2];
|
detached = GROWABLE_HEAP_I32()[attr + 12 >> 2] !== 0;
|
} else {
|
stackSize = 2097152;
|
}
|
var allocatedOwnStack = stackBase == 0;
|
if (allocatedOwnStack) {
|
stackBase = _memalign(16, stackSize);
|
} else {
|
stackBase -= stackSize;
|
assert(stackBase > 0);
|
}
|
var threadInfoStruct = _malloc(228);
|
for (var i = 0; i < 228 >> 2; ++i) GROWABLE_HEAP_U32()[(threadInfoStruct >> 2) + i] = 0;
|
GROWABLE_HEAP_I32()[pthread_ptr >> 2] = threadInfoStruct;
|
GROWABLE_HEAP_I32()[threadInfoStruct + 12 >> 2] = threadInfoStruct;
|
var headPtr = threadInfoStruct + 152;
|
GROWABLE_HEAP_I32()[headPtr >> 2] = headPtr;
|
for (var i in offscreenCanvases) {
|
GROWABLE_HEAP_I32()[offscreenCanvases[i].canvasSharedPtr + 8 >> 2] = threadInfoStruct;
|
}
|
var threadParams = {
|
stackBase: stackBase,
|
stackSize: stackSize,
|
allocatedOwnStack: allocatedOwnStack,
|
detached: detached,
|
startRoutine: start_routine,
|
pthread_ptr: threadInfoStruct,
|
arg: arg,
|
moduleCanvasId: moduleCanvasId,
|
offscreenCanvases: offscreenCanvases,
|
transferList: transferList
|
};
|
if (ENVIRONMENT_IS_PTHREAD) {
|
threadParams.cmd = "spawnThread";
|
postMessage(threadParams, transferList);
|
return 0;
|
}
|
return spawnThread(threadParams);
|
}
|
|
function _pthread_detach(thread) {
|
if (!thread) {
|
err("pthread_detach attempted on a null thread pointer!");
|
return ERRNO_CODES.ESRCH;
|
}
|
var self = GROWABLE_HEAP_I32()[thread + 12 >> 2];
|
if (self !== thread) {
|
err("pthread_detach attempted on thread " + thread + ", which does not point to a valid thread, or does not exist anymore!");
|
return ERRNO_CODES.ESRCH;
|
}
|
var wasDetached = Atomics.compareExchange(GROWABLE_HEAP_U32(), thread + 64 >> 2, 0, 2);
|
return wasDetached ? ERRNO_CODES.EINVAL : 0;
|
}
|
|
function __pthread_testcancel_js() {
|
if (!ENVIRONMENT_IS_PTHREAD) return;
|
var tb = _pthread_self();
|
if (!tb) return;
|
var cancelDisabled = Atomics.load(GROWABLE_HEAP_U32(), tb + 56 >> 2);
|
if (cancelDisabled) return;
|
var canceled = Atomics.load(GROWABLE_HEAP_U32(), tb + 0 >> 2);
|
if (canceled == 2) throw "Canceled!";
|
}
|
|
function __emscripten_do_pthread_join(thread, status, block) {
|
if (!thread) {
|
err("pthread_join attempted on a null thread pointer!");
|
return ERRNO_CODES.ESRCH;
|
}
|
if (ENVIRONMENT_IS_PTHREAD && _pthread_self() == thread) {
|
err("PThread " + thread + " is attempting to join to itself!");
|
return ERRNO_CODES.EDEADLK;
|
} else if (!ENVIRONMENT_IS_PTHREAD && _emscripten_main_browser_thread_id() == thread) {
|
err("Main thread " + thread + " is attempting to join to itself!");
|
return ERRNO_CODES.EDEADLK;
|
}
|
var self = GROWABLE_HEAP_I32()[thread + 12 >> 2];
|
if (self !== thread) {
|
err("pthread_join attempted on thread " + thread + ", which does not point to a valid thread, or does not exist anymore!");
|
return ERRNO_CODES.ESRCH;
|
}
|
var detached = Atomics.load(GROWABLE_HEAP_U32(), thread + 64 >> 2);
|
if (detached) {
|
err("Attempted to join thread " + thread + ", which was already detached!");
|
return ERRNO_CODES.EINVAL;
|
}
|
if (block) {
|
_emscripten_check_blocking_allowed();
|
}
|
for (;;) {
|
var threadStatus = Atomics.load(GROWABLE_HEAP_U32(), thread + 0 >> 2);
|
if (threadStatus == 1) {
|
var threadExitCode = Atomics.load(GROWABLE_HEAP_U32(), thread + 4 >> 2);
|
if (status) GROWABLE_HEAP_I32()[status >> 2] = threadExitCode;
|
Atomics.store(GROWABLE_HEAP_U32(), thread + 64 >> 2, 1);
|
if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread); else postMessage({
|
"cmd": "cleanupThread",
|
"thread": thread
|
});
|
return 0;
|
}
|
if (!block) {
|
return ERRNO_CODES.EBUSY;
|
}
|
__pthread_testcancel_js();
|
if (!ENVIRONMENT_IS_PTHREAD) _emscripten_main_thread_process_queued_calls();
|
_emscripten_futex_wait(thread + 0, threadStatus, ENVIRONMENT_IS_PTHREAD ? 100 : 1);
|
}
|
}
|
|
function _pthread_join(thread, status) {
|
return __emscripten_do_pthread_join(thread, status, true);
|
}
|
|
function _setTempRet0($i) {
|
setTempRet0($i | 0);
|
}
|
|
if (!ENVIRONMENT_IS_PTHREAD) PThread.initMainThreadBlock();
|
|
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_emval();
|
|
Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) {
|
Browser.requestFullscreen(lockPointer, resizeCanvas);
|
};
|
|
Module["requestFullScreen"] = function Module_requestFullScreen() {
|
Browser.requestFullScreen();
|
};
|
|
Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) {
|
Browser.requestAnimationFrame(func);
|
};
|
|
Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) {
|
Browser.setCanvasSize(width, height, noUpdates);
|
};
|
|
Module["pauseMainLoop"] = function Module_pauseMainLoop() {
|
Browser.mainLoop.pause();
|
};
|
|
Module["resumeMainLoop"] = function Module_resumeMainLoop() {
|
Browser.mainLoop.resume();
|
};
|
|
Module["getUserMedia"] = function Module_getUserMedia() {
|
Browser.getUserMedia();
|
};
|
|
Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) {
|
return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes);
|
};
|
|
var GLctx;
|
|
var miniTempWebGLFloatBuffersStorage = new Float32Array(288);
|
|
for (var i = 0; i < 288; ++i) {
|
miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i + 1);
|
}
|
|
var proxiedFunctionTable = [ null, _DecCB, _YUVDisplayCB, _atexit, _tzset, ___sys_fcntl64, ___sys_ioctl, ___sys_open, _alBufferData, _alDeleteBuffers, _alSourcei, _alDeleteSources, _alGenBuffers, _alGenSources, _alGetError, _alGetSourcef, _alGetSourcei, _alListenerfv, _alSourcePlay, _alSourceQueueBuffers, _alSourceStop, _alSourceUnqueueBuffers, _alSourcef, _alSourcefv, _alcCreateContext, _alcGetCurrentContext, _alcGetString, _alcMakeContextCurrent, _alcOpenDevice, _emscripten_get_canvas_element_size_main_thread, _emscripten_set_canvas_element_size_main_thread, _emscripten_webgl_destroy_context_main_thread, _environ_get, _environ_sizes_get, _fd_close, _fd_read, _fd_seek, _fd_write ];
|
|
var ASSERTIONS = true;
|
|
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;
|
}
|
|
function intArrayToString(array) {
|
var ret = [];
|
for (var i = 0; i < array.length; i++) {
|
var chr = array[i];
|
if (chr > 255) {
|
if (ASSERTIONS) {
|
assert(false, "Character code " + chr + " (" + String.fromCharCode(chr) + ") at offset " + i + " not in 0x00-0xFF.");
|
}
|
chr &= 255;
|
}
|
ret.push(String.fromCharCode(chr));
|
}
|
return ret.join("");
|
}
|
|
var asmLibraryArg = {
|
"DecCB": _DecCB,
|
"YUVDisplayCB": _YUVDisplayCB,
|
"__assert_fail": ___assert_fail,
|
"__call_main": ___call_main,
|
"__clock_gettime": ___clock_gettime,
|
"__cxa_allocate_exception": ___cxa_allocate_exception,
|
"__cxa_atexit": ___cxa_atexit,
|
"__cxa_thread_atexit": ___cxa_thread_atexit,
|
"__cxa_throw": ___cxa_throw,
|
"__localtime_r": ___localtime_r,
|
"__sys_fcntl64": ___sys_fcntl64,
|
"__sys_ioctl": ___sys_ioctl,
|
"__sys_open": ___sys_open,
|
"_embind_register_bool": __embind_register_bool,
|
"_embind_register_emval": __embind_register_emval,
|
"_embind_register_float": __embind_register_float,
|
"_embind_register_integer": __embind_register_integer,
|
"_embind_register_memory_view": __embind_register_memory_view,
|
"_embind_register_std_string": __embind_register_std_string,
|
"_embind_register_std_wstring": __embind_register_std_wstring,
|
"_embind_register_void": __embind_register_void,
|
"_emscripten_notify_thread_queue": __emscripten_notify_thread_queue,
|
"abort": _abort,
|
"alBufferData": _alBufferData,
|
"alDeleteBuffers": _alDeleteBuffers,
|
"alDeleteSources": _alDeleteSources,
|
"alGenBuffers": _alGenBuffers,
|
"alGenSources": _alGenSources,
|
"alGetError": _alGetError,
|
"alGetSourcef": _alGetSourcef,
|
"alGetSourcei": _alGetSourcei,
|
"alListenerfv": _alListenerfv,
|
"alSourcePlay": _alSourcePlay,
|
"alSourceQueueBuffers": _alSourceQueueBuffers,
|
"alSourceStop": _alSourceStop,
|
"alSourceUnqueueBuffers": _alSourceUnqueueBuffers,
|
"alSourcef": _alSourcef,
|
"alSourcefv": _alSourcefv,
|
"alSourcei": _alSourcei,
|
"alcCreateContext": _alcCreateContext,
|
"alcGetCurrentContext": _alcGetCurrentContext,
|
"alcGetString": _alcGetString,
|
"alcMakeContextCurrent": _alcMakeContextCurrent,
|
"alcOpenDevice": _alcOpenDevice,
|
"clock_gettime": _clock_gettime,
|
"emscripten_asm_const_int": _emscripten_asm_const_int,
|
"emscripten_cancel_main_loop": _emscripten_cancel_main_loop,
|
"emscripten_check_blocking_allowed": _emscripten_check_blocking_allowed,
|
"emscripten_conditional_set_current_thread_status": _emscripten_conditional_set_current_thread_status,
|
"emscripten_futex_wait": _emscripten_futex_wait,
|
"emscripten_futex_wake": _emscripten_futex_wake,
|
"emscripten_get_canvas_element_size": _emscripten_get_canvas_element_size,
|
"emscripten_get_now": _emscripten_get_now,
|
"emscripten_longjmp": _emscripten_longjmp,
|
"emscripten_memcpy_big": _emscripten_memcpy_big,
|
"emscripten_receive_on_main_thread_js": _emscripten_receive_on_main_thread_js,
|
"emscripten_resize_heap": _emscripten_resize_heap,
|
"emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size,
|
"emscripten_set_current_thread_status": _emscripten_set_current_thread_status,
|
"emscripten_set_main_loop_arg": _emscripten_set_main_loop_arg,
|
"emscripten_set_thread_name": _emscripten_set_thread_name,
|
"emscripten_supports_offscreencanvas": _emscripten_supports_offscreencanvas,
|
"emscripten_webgl_commit_frame": _emscripten_webgl_commit_frame,
|
"emscripten_webgl_create_context": _emscripten_webgl_create_context,
|
"emscripten_webgl_destroy_context": _emscripten_webgl_destroy_context,
|
"emscripten_webgl_get_current_context": _emscripten_webgl_get_current_context,
|
"emscripten_webgl_init_context_attributes": _emscripten_webgl_init_context_attributes,
|
"emscripten_webgl_make_context_current": _emscripten_webgl_make_context_current,
|
"environ_get": _environ_get,
|
"environ_sizes_get": _environ_sizes_get,
|
"fd_close": _fd_close,
|
"fd_read": _fd_read,
|
"fd_seek": _fd_seek,
|
"fd_write": _fd_write,
|
"getTempRet0": _getTempRet0,
|
"gettimeofday": _gettimeofday,
|
"glActiveTexture": _glActiveTexture,
|
"glAttachShader": _glAttachShader,
|
"glBindBuffer": _glBindBuffer,
|
"glBindFramebuffer": _glBindFramebuffer,
|
"glBindTexture": _glBindTexture,
|
"glBlendFunc": _glBlendFunc,
|
"glBufferData": _glBufferData,
|
"glClear": _glClear,
|
"glCompileShader": _glCompileShader,
|
"glCreateProgram": _glCreateProgram,
|
"glCreateShader": _glCreateShader,
|
"glDeleteBuffers": _glDeleteBuffers,
|
"glDeleteFramebuffers": _glDeleteFramebuffers,
|
"glDeleteProgram": _glDeleteProgram,
|
"glDeleteRenderbuffers": _glDeleteRenderbuffers,
|
"glDeleteShader": _glDeleteShader,
|
"glDeleteTextures": _glDeleteTextures,
|
"glDepthFunc": _glDepthFunc,
|
"glDepthMask": _glDepthMask,
|
"glDetachShader": _glDetachShader,
|
"glDisable": _glDisable,
|
"glDrawArrays": _glDrawArrays,
|
"glEnable": _glEnable,
|
"glEnableVertexAttribArray": _glEnableVertexAttribArray,
|
"glFramebufferTexture2D": _glFramebufferTexture2D,
|
"glGenBuffers": _glGenBuffers,
|
"glGenFramebuffers": _glGenFramebuffers,
|
"glGenTextures": _glGenTextures,
|
"glGenerateMipmap": _glGenerateMipmap,
|
"glGetAttribLocation": _glGetAttribLocation,
|
"glGetIntegerv": _glGetIntegerv,
|
"glGetProgramiv": _glGetProgramiv,
|
"glGetShaderInfoLog": _glGetShaderInfoLog,
|
"glGetShaderiv": _glGetShaderiv,
|
"glGetUniformLocation": _glGetUniformLocation,
|
"glLinkProgram": _glLinkProgram,
|
"glScissor": _glScissor,
|
"glShaderSource": _glShaderSource,
|
"glTexImage2D": _glTexImage2D,
|
"glTexParameteri": _glTexParameteri,
|
"glUniform1f": _glUniform1f,
|
"glUniform1i": _glUniform1i,
|
"glUniform4f": _glUniform4f,
|
"glUniformMatrix4fv": _glUniformMatrix4fv,
|
"glUseProgram": _glUseProgram,
|
"glVertexAttribPointer": _glVertexAttribPointer,
|
"glViewport": _glViewport,
|
"initPthreadsJS": initPthreadsJS,
|
"invoke_iii": invoke_iii,
|
"invoke_iiii": invoke_iiii,
|
"invoke_iiiii": invoke_iiiii,
|
"invoke_vi": invoke_vi,
|
"invoke_viiii": invoke_viiii,
|
"memory": wasmMemory || Module["wasmMemory"],
|
"pthread_create": _pthread_create,
|
"pthread_detach": _pthread_detach,
|
"pthread_join": _pthread_join,
|
"setTempRet0": _setTempRet0
|
};
|
|
var asm = createWasm();
|
|
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors");
|
|
var _DecCallBack = Module["_DecCallBack"] = createExportWrapper("DecCallBack");
|
|
var _DisplayCallBack = Module["_DisplayCallBack"] = createExportWrapper("DisplayCallBack");
|
|
var _FrameInfoCallBack = Module["_FrameInfoCallBack"] = createExportWrapper("FrameInfoCallBack");
|
|
var _JSPlayM4_GetFrameInfo = Module["_JSPlayM4_GetFrameInfo"] = createExportWrapper("JSPlayM4_GetFrameInfo");
|
|
var _JSPlayM4_GetPort = Module["_JSPlayM4_GetPort"] = createExportWrapper("JSPlayM4_GetPort");
|
|
var _JSPlayM4_SetStreamOpenMode = Module["_JSPlayM4_SetStreamOpenMode"] = createExportWrapper("JSPlayM4_SetStreamOpenMode");
|
|
var _JSPlayM4_OpenStream = Module["_JSPlayM4_OpenStream"] = createExportWrapper("JSPlayM4_OpenStream");
|
|
var _JSPlayM4_SetDecCallBack = Module["_JSPlayM4_SetDecCallBack"] = createExportWrapper("JSPlayM4_SetDecCallBack");
|
|
var _JSPlayM4_SetDisplayCallBack = Module["_JSPlayM4_SetDisplayCallBack"] = createExportWrapper("JSPlayM4_SetDisplayCallBack");
|
|
var _JSPlayM4_SetFrameInfoCallBack = Module["_JSPlayM4_SetFrameInfoCallBack"] = createExportWrapper("JSPlayM4_SetFrameInfoCallBack");
|
|
var _JSPlayM4_SetDecCBStream = Module["_JSPlayM4_SetDecCBStream"] = createExportWrapper("JSPlayM4_SetDecCBStream");
|
|
var _JSPlayM4_Play = Module["_JSPlayM4_Play"] = createExportWrapper("JSPlayM4_Play");
|
|
var _JSPlayM4_InputData = Module["_JSPlayM4_InputData"] = createExportWrapper("JSPlayM4_InputData");
|
|
var _JSPlayM4_Stop = Module["_JSPlayM4_Stop"] = createExportWrapper("JSPlayM4_Stop");
|
|
var _JSPlayM4_CloseStream = Module["_JSPlayM4_CloseStream"] = createExportWrapper("JSPlayM4_CloseStream");
|
|
var _JSPlayM4_FreePort = Module["_JSPlayM4_FreePort"] = createExportWrapper("JSPlayM4_FreePort");
|
|
var _JSPlayM4_SetDecodeFrameType = Module["_JSPlayM4_SetDecodeFrameType"] = createExportWrapper("JSPlayM4_SetDecodeFrameType");
|
|
var _JSPlayM4_PlaySound = Module["_JSPlayM4_PlaySound"] = createExportWrapper("JSPlayM4_PlaySound");
|
|
var _JSPlayM4_SetSecretKey = Module["_JSPlayM4_SetSecretKey"] = createExportWrapper("JSPlayM4_SetSecretKey");
|
|
var _JSPlayM4_GetJPEG = Module["_JSPlayM4_GetJPEG"] = createExportWrapper("JSPlayM4_GetJPEG");
|
|
var _JSPlayM4_GetBMP = Module["_JSPlayM4_GetBMP"] = createExportWrapper("JSPlayM4_GetBMP");
|
|
var _JSPlayM4_StopSound = Module["_JSPlayM4_StopSound"] = createExportWrapper("JSPlayM4_StopSound");
|
|
var _JSPlayM4_GetSDKVersion = Module["_JSPlayM4_GetSDKVersion"] = createExportWrapper("JSPlayM4_GetSDKVersion");
|
|
var _JSPlayM4_GetBuildDate = Module["_JSPlayM4_GetBuildDate"] = createExportWrapper("JSPlayM4_GetBuildDate");
|
|
var _JSPlayM4_GetLastError = Module["_JSPlayM4_GetLastError"] = createExportWrapper("JSPlayM4_GetLastError");
|
|
var _JSPlayM4_Fast = Module["_JSPlayM4_Fast"] = createExportWrapper("JSPlayM4_Fast");
|
|
var _JSPlayM4_Slow = Module["_JSPlayM4_Slow"] = createExportWrapper("JSPlayM4_Slow");
|
|
var _JSPlayM4_SetIFrameDecInterval = Module["_JSPlayM4_SetIFrameDecInterval"] = createExportWrapper("JSPlayM4_SetIFrameDecInterval");
|
|
var _JSPlayM4_SetDecodeThread = Module["_JSPlayM4_SetDecodeThread"] = createExportWrapper("JSPlayM4_SetDecodeThread");
|
|
var _JSPlayM4_Pause = Module["_JSPlayM4_Pause"] = createExportWrapper("JSPlayM4_Pause");
|
|
var _JSPlayM4_OneByOne = Module["_JSPlayM4_OneByOne"] = createExportWrapper("JSPlayM4_OneByOne");
|
|
var _JSPlayM4_SetVolume = Module["_JSPlayM4_SetVolume"] = createExportWrapper("JSPlayM4_SetVolume");
|
|
var _JSPlayM4_GetVolume = Module["_JSPlayM4_GetVolume"] = createExportWrapper("JSPlayM4_GetVolume");
|
|
var _JSPlayM4_SetDisplayRegion = Module["_JSPlayM4_SetDisplayRegion"] = createExportWrapper("JSPlayM4_SetDisplayRegion");
|
|
var _JSPlayM4_SetPrintLogFlag = Module["_JSPlayM4_SetPrintLogFlag"] = createExportWrapper("JSPlayM4_SetPrintLogFlag");
|
|
var _JSPlayM4_RenderPrivateData = Module["_JSPlayM4_RenderPrivateData"] = createExportWrapper("JSPlayM4_RenderPrivateData");
|
|
var _JSPlayM4_RenderPrivateDataEx = Module["_JSPlayM4_RenderPrivateDataEx"] = createExportWrapper("JSPlayM4_RenderPrivateDataEx");
|
|
var _JSPlayM4_SetCanvasSize = Module["_JSPlayM4_SetCanvasSize"] = createExportWrapper("JSPlayM4_SetCanvasSize");
|
|
var _JSPlayM4_SetDisplayBuf = Module["_JSPlayM4_SetDisplayBuf"] = createExportWrapper("JSPlayM4_SetDisplayBuf");
|
|
var _JSPlayM4_GetSourceBufferRemain = Module["_JSPlayM4_GetSourceBufferRemain"] = createExportWrapper("JSPlayM4_GetSourceBufferRemain");
|
|
var _JSPlayM4_GetBufferValue = Module["_JSPlayM4_GetBufferValue"] = createExportWrapper("JSPlayM4_GetBufferValue");
|
|
var _JSPlayM4_ReversePlay = Module["_JSPlayM4_ReversePlay"] = createExportWrapper("JSPlayM4_ReversePlay");
|
|
var _JSPlayM4_SetDecodeThreadNum = Module["_JSPlayM4_SetDecodeThreadNum"] = createExportWrapper("JSPlayM4_SetDecodeThreadNum");
|
|
var _JSPlayM4_GetCanvasSize = Module["_JSPlayM4_GetCanvasSize"] = createExportWrapper("JSPlayM4_GetCanvasSize");
|
|
var _JSPlayM4_DisplayLostFrames = Module["_JSPlayM4_DisplayLostFrames"] = createExportWrapper("JSPlayM4_DisplayLostFrames");
|
|
var _JSPlayM4_SetANRParam = Module["_JSPlayM4_SetANRParam"] = createExportWrapper("JSPlayM4_SetANRParam");
|
|
var _JSPlayM4_SetResampleValue = Module["_JSPlayM4_SetResampleValue"] = createExportWrapper("JSPlayM4_SetResampleValue");
|
|
var _JSPlayM4_SetAntialias = Module["_JSPlayM4_SetAntialias"] = createExportWrapper("JSPlayM4_SetAntialias");
|
|
var _JSPlayM4_SyncToAudio = Module["_JSPlayM4_SyncToAudio"] = createExportWrapper("JSPlayM4_SyncToAudio");
|
|
var _JSPlayM4_SetAudioThreadModel = Module["_JSPlayM4_SetAudioThreadModel"] = createExportWrapper("JSPlayM4_SetAudioThreadModel");
|
|
var _emscripten_tls_init = Module["_emscripten_tls_init"] = createExportWrapper("emscripten_tls_init");
|
|
var ___getTypeName = Module["___getTypeName"] = createExportWrapper("__getTypeName");
|
|
var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = createExportWrapper("__embind_register_native_and_builtin_types");
|
|
var _emscripten_get_global_libc = Module["_emscripten_get_global_libc"] = createExportWrapper("emscripten_get_global_libc");
|
|
var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location");
|
|
var _malloc = Module["_malloc"] = createExportWrapper("malloc");
|
|
var _fflush = Module["_fflush"] = createExportWrapper("fflush");
|
|
var __get_tzname = Module["__get_tzname"] = createExportWrapper("_get_tzname");
|
|
var __get_daylight = Module["__get_daylight"] = createExportWrapper("_get_daylight");
|
|
var __get_timezone = Module["__get_timezone"] = createExportWrapper("_get_timezone");
|
|
var ___emscripten_pthread_data_constructor = Module["___emscripten_pthread_data_constructor"] = createExportWrapper("__emscripten_pthread_data_constructor");
|
|
var _pthread_self = Module["_pthread_self"] = createExportWrapper("pthread_self");
|
|
var ___pthread_tsd_run_dtors = Module["___pthread_tsd_run_dtors"] = createExportWrapper("__pthread_tsd_run_dtors");
|
|
var _emscripten_current_thread_process_queued_calls = Module["_emscripten_current_thread_process_queued_calls"] = createExportWrapper("emscripten_current_thread_process_queued_calls");
|
|
var _emscripten_register_main_browser_thread_id = Module["_emscripten_register_main_browser_thread_id"] = createExportWrapper("emscripten_register_main_browser_thread_id");
|
|
var _emscripten_main_browser_thread_id = Module["_emscripten_main_browser_thread_id"] = createExportWrapper("emscripten_main_browser_thread_id");
|
|
var __emscripten_do_dispatch_to_thread = Module["__emscripten_do_dispatch_to_thread"] = createExportWrapper("_emscripten_do_dispatch_to_thread");
|
|
var _emscripten_sync_run_in_main_thread_2 = Module["_emscripten_sync_run_in_main_thread_2"] = createExportWrapper("emscripten_sync_run_in_main_thread_2");
|
|
var _emscripten_sync_run_in_main_thread_4 = Module["_emscripten_sync_run_in_main_thread_4"] = createExportWrapper("emscripten_sync_run_in_main_thread_4");
|
|
var _emscripten_main_thread_process_queued_calls = Module["_emscripten_main_thread_process_queued_calls"] = createExportWrapper("emscripten_main_thread_process_queued_calls");
|
|
var _emscripten_run_in_main_runtime_thread_js = Module["_emscripten_run_in_main_runtime_thread_js"] = createExportWrapper("emscripten_run_in_main_runtime_thread_js");
|
|
var __emscripten_call_on_thread = Module["__emscripten_call_on_thread"] = createExportWrapper("_emscripten_call_on_thread");
|
|
var _emscripten_proxy_main = Module["_emscripten_proxy_main"] = createExportWrapper("emscripten_proxy_main");
|
|
var __emscripten_thread_init = Module["__emscripten_thread_init"] = createExportWrapper("_emscripten_thread_init");
|
|
var stackSave = Module["stackSave"] = createExportWrapper("stackSave");
|
|
var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore");
|
|
var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc");
|
|
var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() {
|
return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
|
};
|
|
var _emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = function() {
|
return (_emscripten_stack_set_limits = Module["_emscripten_stack_set_limits"] = Module["asm"]["emscripten_stack_set_limits"]).apply(null, arguments);
|
};
|
|
var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() {
|
return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
|
};
|
|
var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() {
|
return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
|
};
|
|
var _setThrew = Module["_setThrew"] = createExportWrapper("setThrew");
|
|
var _free = Module["_free"] = createExportWrapper("free");
|
|
var _memalign = Module["_memalign"] = createExportWrapper("memalign");
|
|
var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");
|
|
var __emscripten_allow_main_runtime_queued_calls = Module["__emscripten_allow_main_runtime_queued_calls"] = 576560;
|
|
var __emscripten_main_thread_futex = Module["__emscripten_main_thread_futex"] = 626784;
|
|
function invoke_viiii(index, a1, a2, a3, a4) {
|
var sp = stackSave();
|
try {
|
wasmTable.get(index)(a1, a2, a3, a4);
|
} catch (e) {
|
stackRestore(sp);
|
if (e !== e + 0 && e !== "longjmp") throw e;
|
_setThrew(1, 0);
|
}
|
}
|
|
function invoke_iii(index, a1, a2) {
|
var sp = stackSave();
|
try {
|
return wasmTable.get(index)(a1, a2);
|
} catch (e) {
|
stackRestore(sp);
|
if (e !== e + 0 && e !== "longjmp") throw e;
|
_setThrew(1, 0);
|
}
|
}
|
|
function invoke_iiiii(index, a1, a2, a3, a4) {
|
var sp = stackSave();
|
try {
|
return wasmTable.get(index)(a1, a2, a3, a4);
|
} catch (e) {
|
stackRestore(sp);
|
if (e !== e + 0 && e !== "longjmp") throw e;
|
_setThrew(1, 0);
|
}
|
}
|
|
function invoke_iiii(index, a1, a2, a3) {
|
var sp = stackSave();
|
try {
|
return wasmTable.get(index)(a1, a2, a3);
|
} catch (e) {
|
stackRestore(sp);
|
if (e !== e + 0 && e !== "longjmp") throw e;
|
_setThrew(1, 0);
|
}
|
}
|
|
function invoke_vi(index, a1) {
|
var sp = stackSave();
|
try {
|
wasmTable.get(index)(a1);
|
} catch (e) {
|
stackRestore(sp);
|
if (e !== e + 0 && e !== "longjmp") throw e;
|
_setThrew(1, 0);
|
}
|
}
|
|
if (!Object.getOwnPropertyDescriptor(Module, "intArrayFromString")) Module["intArrayFromString"] = function() {
|
abort("'intArrayFromString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "intArrayToString")) Module["intArrayToString"] = function() {
|
abort("'intArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["ccall"] = ccall;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "cwrap")) Module["cwrap"] = function() {
|
abort("'cwrap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setValue")) Module["setValue"] = function() {
|
abort("'setValue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["getValue"] = getValue;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "allocate")) Module["allocate"] = function() {
|
abort("'allocate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "UTF8ArrayToString")) Module["UTF8ArrayToString"] = function() {
|
abort("'UTF8ArrayToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["UTF8ToString"] = UTF8ToString;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8Array")) Module["stringToUTF8Array"] = function() {
|
abort("'stringToUTF8Array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF8")) Module["stringToUTF8"] = function() {
|
abort("'stringToUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF8")) Module["lengthBytesUTF8"] = function() {
|
abort("'lengthBytesUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() {
|
abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreRun")) Module["addOnPreRun"] = function() {
|
abort("'addOnPreRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addOnInit")) Module["addOnInit"] = function() {
|
abort("'addOnInit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addOnPreMain")) Module["addOnPreMain"] = function() {
|
abort("'addOnPreMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addOnExit")) Module["addOnExit"] = function() {
|
abort("'addOnExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addOnPostRun")) Module["addOnPostRun"] = function() {
|
abort("'addOnPostRun' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeStringToMemory")) Module["writeStringToMemory"] = function() {
|
abort("'writeStringToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["writeArrayToMemory"] = writeArrayToMemory;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeAsciiToMemory")) Module["writeAsciiToMemory"] = function() {
|
abort("'writeAsciiToMemory' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addRunDependency")) Module["addRunDependency"] = function() {
|
abort("'addRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "removeRunDependency")) Module["removeRunDependency"] = function() {
|
abort("'removeRunDependency' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createFolder")) Module["FS_createFolder"] = function() {
|
abort("'FS_createFolder' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPath")) Module["FS_createPath"] = function() {
|
abort("'FS_createPath' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDataFile")) Module["FS_createDataFile"] = function() {
|
abort("'FS_createDataFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createPreloadedFile")) Module["FS_createPreloadedFile"] = function() {
|
abort("'FS_createPreloadedFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createLazyFile")) Module["FS_createLazyFile"] = function() {
|
abort("'FS_createLazyFile' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createLink")) Module["FS_createLink"] = function() {
|
abort("'FS_createLink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_createDevice")) Module["FS_createDevice"] = function() {
|
abort("'FS_createDevice' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS_unlink")) Module["FS_unlink"] = function() {
|
abort("'FS_unlink' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ). Alternatively, forcing filesystem support (-s FORCE_FILESYSTEM=1) can export this for you");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getLEB")) Module["getLEB"] = function() {
|
abort("'getLEB' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getFunctionTables")) Module["getFunctionTables"] = function() {
|
abort("'getFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "alignFunctionTables")) Module["alignFunctionTables"] = function() {
|
abort("'alignFunctionTables' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerFunctions")) Module["registerFunctions"] = function() {
|
abort("'registerFunctions' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "addFunction")) Module["addFunction"] = function() {
|
abort("'addFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "removeFunction")) Module["removeFunction"] = function() {
|
abort("'removeFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = function() {
|
abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "prettyPrint")) Module["prettyPrint"] = function() {
|
abort("'prettyPrint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "makeBigInt")) Module["makeBigInt"] = function() {
|
abort("'makeBigInt' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = function() {
|
abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getCompilerSetting")) Module["getCompilerSetting"] = function() {
|
abort("'getCompilerSetting' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["print"] = out;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "printErr")) Module["printErr"] = function() {
|
abort("'printErr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getTempRet0")) Module["getTempRet0"] = function() {
|
abort("'getTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setTempRet0")) Module["setTempRet0"] = function() {
|
abort("'setTempRet0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "callMain")) Module["callMain"] = function() {
|
abort("'callMain' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "abort")) Module["abort"] = function() {
|
abort("'abort' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stringToNewUTF8")) Module["stringToNewUTF8"] = function() {
|
abort("'stringToNewUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setFileTime")) Module["setFileTime"] = function() {
|
abort("'setFileTime' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emscripten_realloc_buffer")) Module["emscripten_realloc_buffer"] = function() {
|
abort("'emscripten_realloc_buffer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ENV")) Module["ENV"] = function() {
|
abort("'ENV' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_CODES")) Module["ERRNO_CODES"] = function() {
|
abort("'ERRNO_CODES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ERRNO_MESSAGES")) Module["ERRNO_MESSAGES"] = function() {
|
abort("'ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setErrNo")) Module["setErrNo"] = function() {
|
abort("'setErrNo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "inetPton4")) Module["inetPton4"] = function() {
|
abort("'inetPton4' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "inetNtop4")) Module["inetNtop4"] = function() {
|
abort("'inetNtop4' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "inetPton6")) Module["inetPton6"] = function() {
|
abort("'inetPton6' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "inetNtop6")) Module["inetNtop6"] = function() {
|
abort("'inetNtop6' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readSockaddr")) Module["readSockaddr"] = function() {
|
abort("'readSockaddr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeSockaddr")) Module["writeSockaddr"] = function() {
|
abort("'writeSockaddr' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "DNS")) Module["DNS"] = function() {
|
abort("'DNS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getHostByName")) Module["getHostByName"] = function() {
|
abort("'getHostByName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "GAI_ERRNO_MESSAGES")) Module["GAI_ERRNO_MESSAGES"] = function() {
|
abort("'GAI_ERRNO_MESSAGES' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "Protocols")) Module["Protocols"] = function() {
|
abort("'Protocols' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "Sockets")) Module["Sockets"] = function() {
|
abort("'Sockets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getRandomDevice")) Module["getRandomDevice"] = function() {
|
abort("'getRandomDevice' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "traverseStack")) Module["traverseStack"] = function() {
|
abort("'traverseStack' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "UNWIND_CACHE")) Module["UNWIND_CACHE"] = function() {
|
abort("'UNWIND_CACHE' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "withBuiltinMalloc")) Module["withBuiltinMalloc"] = function() {
|
abort("'withBuiltinMalloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgsArray")) Module["readAsmConstArgsArray"] = function() {
|
abort("'readAsmConstArgsArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readAsmConstArgs")) Module["readAsmConstArgs"] = function() {
|
abort("'readAsmConstArgs' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "mainThreadEM_ASM")) Module["mainThreadEM_ASM"] = function() {
|
abort("'mainThreadEM_ASM' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_q")) Module["jstoi_q"] = function() {
|
abort("'jstoi_q' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "jstoi_s")) Module["jstoi_s"] = function() {
|
abort("'jstoi_s' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getExecutableName")) Module["getExecutableName"] = function() {
|
abort("'getExecutableName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "listenOnce")) Module["listenOnce"] = function() {
|
abort("'listenOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "autoResumeAudioContext")) Module["autoResumeAudioContext"] = function() {
|
abort("'autoResumeAudioContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "dynCallLegacy")) Module["dynCallLegacy"] = function() {
|
abort("'dynCallLegacy' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getDynCaller")) Module["getDynCaller"] = function() {
|
abort("'getDynCaller' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "dynCall")) Module["dynCall"] = function() {
|
abort("'dynCall' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "callRuntimeCallbacks")) Module["callRuntimeCallbacks"] = function() {
|
abort("'callRuntimeCallbacks' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepaliveCounter")) Module["runtimeKeepaliveCounter"] = function() {
|
abort("'runtimeKeepaliveCounter' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "keepRuntimeAlive")) Module["keepRuntimeAlive"] = function() {
|
abort("'keepRuntimeAlive' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePush")) Module["runtimeKeepalivePush"] = function() {
|
abort("'runtimeKeepalivePush' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "runtimeKeepalivePop")) Module["runtimeKeepalivePop"] = function() {
|
abort("'runtimeKeepalivePop' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "callUserCallback")) Module["callUserCallback"] = function() {
|
abort("'callUserCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "maybeExit")) Module["maybeExit"] = function() {
|
abort("'maybeExit' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "reallyNegative")) Module["reallyNegative"] = function() {
|
abort("'reallyNegative' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "unSign")) Module["unSign"] = function() {
|
abort("'unSign' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "reSign")) Module["reSign"] = function() {
|
abort("'reSign' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "formatString")) Module["formatString"] = function() {
|
abort("'formatString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "PATH")) Module["PATH"] = function() {
|
abort("'PATH' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "PATH_FS")) Module["PATH_FS"] = function() {
|
abort("'PATH_FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SYSCALLS")) Module["SYSCALLS"] = function() {
|
abort("'SYSCALLS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "syscallMmap2")) Module["syscallMmap2"] = function() {
|
abort("'syscallMmap2' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "syscallMunmap")) Module["syscallMunmap"] = function() {
|
abort("'syscallMunmap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getSocketFromFD")) Module["getSocketFromFD"] = function() {
|
abort("'getSocketFromFD' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getSocketAddress")) Module["getSocketAddress"] = function() {
|
abort("'getSocketAddress' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "JSEvents")) Module["JSEvents"] = function() {
|
abort("'JSEvents' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerKeyEventCallback")) Module["registerKeyEventCallback"] = function() {
|
abort("'registerKeyEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "specialHTMLTargets")) Module["specialHTMLTargets"] = function() {
|
abort("'specialHTMLTargets' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "maybeCStringToJsString")) Module["maybeCStringToJsString"] = function() {
|
abort("'maybeCStringToJsString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "findEventTarget")) Module["findEventTarget"] = function() {
|
abort("'findEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "findCanvasEventTarget")) Module["findCanvasEventTarget"] = function() {
|
abort("'findCanvasEventTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getBoundingClientRect")) Module["getBoundingClientRect"] = function() {
|
abort("'getBoundingClientRect' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillMouseEventData")) Module["fillMouseEventData"] = function() {
|
abort("'fillMouseEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerMouseEventCallback")) Module["registerMouseEventCallback"] = function() {
|
abort("'registerMouseEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerWheelEventCallback")) Module["registerWheelEventCallback"] = function() {
|
abort("'registerWheelEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerUiEventCallback")) Module["registerUiEventCallback"] = function() {
|
abort("'registerUiEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerFocusEventCallback")) Module["registerFocusEventCallback"] = function() {
|
abort("'registerFocusEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceOrientationEventData")) Module["fillDeviceOrientationEventData"] = function() {
|
abort("'fillDeviceOrientationEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceOrientationEventCallback")) Module["registerDeviceOrientationEventCallback"] = function() {
|
abort("'registerDeviceOrientationEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillDeviceMotionEventData")) Module["fillDeviceMotionEventData"] = function() {
|
abort("'fillDeviceMotionEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerDeviceMotionEventCallback")) Module["registerDeviceMotionEventCallback"] = function() {
|
abort("'registerDeviceMotionEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "screenOrientation")) Module["screenOrientation"] = function() {
|
abort("'screenOrientation' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillOrientationChangeEventData")) Module["fillOrientationChangeEventData"] = function() {
|
abort("'fillOrientationChangeEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerOrientationChangeEventCallback")) Module["registerOrientationChangeEventCallback"] = function() {
|
abort("'registerOrientationChangeEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillFullscreenChangeEventData")) Module["fillFullscreenChangeEventData"] = function() {
|
abort("'fillFullscreenChangeEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerFullscreenChangeEventCallback")) Module["registerFullscreenChangeEventCallback"] = function() {
|
abort("'registerFullscreenChangeEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerRestoreOldStyle")) Module["registerRestoreOldStyle"] = function() {
|
abort("'registerRestoreOldStyle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "hideEverythingExceptGivenElement")) Module["hideEverythingExceptGivenElement"] = function() {
|
abort("'hideEverythingExceptGivenElement' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "restoreHiddenElements")) Module["restoreHiddenElements"] = function() {
|
abort("'restoreHiddenElements' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setLetterbox")) Module["setLetterbox"] = function() {
|
abort("'setLetterbox' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "currentFullscreenStrategy")) Module["currentFullscreenStrategy"] = function() {
|
abort("'currentFullscreenStrategy' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "restoreOldWindowedStyle")) Module["restoreOldWindowedStyle"] = function() {
|
abort("'restoreOldWindowedStyle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "softFullscreenResizeWebGLRenderTarget")) Module["softFullscreenResizeWebGLRenderTarget"] = function() {
|
abort("'softFullscreenResizeWebGLRenderTarget' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "doRequestFullscreen")) Module["doRequestFullscreen"] = function() {
|
abort("'doRequestFullscreen' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillPointerlockChangeEventData")) Module["fillPointerlockChangeEventData"] = function() {
|
abort("'fillPointerlockChangeEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockChangeEventCallback")) Module["registerPointerlockChangeEventCallback"] = function() {
|
abort("'registerPointerlockChangeEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerPointerlockErrorEventCallback")) Module["registerPointerlockErrorEventCallback"] = function() {
|
abort("'registerPointerlockErrorEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "requestPointerLock")) Module["requestPointerLock"] = function() {
|
abort("'requestPointerLock' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillVisibilityChangeEventData")) Module["fillVisibilityChangeEventData"] = function() {
|
abort("'fillVisibilityChangeEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerVisibilityChangeEventCallback")) Module["registerVisibilityChangeEventCallback"] = function() {
|
abort("'registerVisibilityChangeEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerTouchEventCallback")) Module["registerTouchEventCallback"] = function() {
|
abort("'registerTouchEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillGamepadEventData")) Module["fillGamepadEventData"] = function() {
|
abort("'fillGamepadEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerGamepadEventCallback")) Module["registerGamepadEventCallback"] = function() {
|
abort("'registerGamepadEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerBeforeUnloadEventCallback")) Module["registerBeforeUnloadEventCallback"] = function() {
|
abort("'registerBeforeUnloadEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "fillBatteryEventData")) Module["fillBatteryEventData"] = function() {
|
abort("'fillBatteryEventData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "battery")) Module["battery"] = function() {
|
abort("'battery' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerBatteryEventCallback")) Module["registerBatteryEventCallback"] = function() {
|
abort("'registerBatteryEventCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setCanvasElementSize")) Module["setCanvasElementSize"] = function() {
|
abort("'setCanvasElementSize' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getCanvasElementSize")) Module["getCanvasElementSize"] = function() {
|
abort("'getCanvasElementSize' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "polyfillSetImmediate")) Module["polyfillSetImmediate"] = function() {
|
abort("'polyfillSetImmediate' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "demangle")) Module["demangle"] = function() {
|
abort("'demangle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "demangleAll")) Module["demangleAll"] = function() {
|
abort("'demangleAll' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "jsStackTrace")) Module["jsStackTrace"] = function() {
|
abort("'jsStackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stackTrace")) Module["stackTrace"] = function() {
|
abort("'stackTrace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getEnvStrings")) Module["getEnvStrings"] = function() {
|
abort("'getEnvStrings' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "checkWasiClock")) Module["checkWasiClock"] = function() {
|
abort("'checkWasiClock' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64")) Module["writeI53ToI64"] = function() {
|
abort("'writeI53ToI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Clamped")) Module["writeI53ToI64Clamped"] = function() {
|
abort("'writeI53ToI64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToI64Signaling")) Module["writeI53ToI64Signaling"] = function() {
|
abort("'writeI53ToI64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Clamped")) Module["writeI53ToU64Clamped"] = function() {
|
abort("'writeI53ToU64Clamped' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeI53ToU64Signaling")) Module["writeI53ToU64Signaling"] = function() {
|
abort("'writeI53ToU64Signaling' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromI64")) Module["readI53FromI64"] = function() {
|
abort("'readI53FromI64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readI53FromU64")) Module["readI53FromU64"] = function() {
|
abort("'readI53FromU64' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "convertI32PairToI53")) Module["convertI32PairToI53"] = function() {
|
abort("'convertI32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "convertU32PairToI53")) Module["convertU32PairToI53"] = function() {
|
abort("'convertU32PairToI53' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "uncaughtExceptionCount")) Module["uncaughtExceptionCount"] = function() {
|
abort("'uncaughtExceptionCount' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "exceptionLast")) Module["exceptionLast"] = function() {
|
abort("'exceptionLast' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "exceptionCaught")) Module["exceptionCaught"] = function() {
|
abort("'exceptionCaught' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfoAttrs")) Module["ExceptionInfoAttrs"] = function() {
|
abort("'ExceptionInfoAttrs' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ExceptionInfo")) Module["ExceptionInfo"] = function() {
|
abort("'ExceptionInfo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "CatchInfo")) Module["CatchInfo"] = function() {
|
abort("'CatchInfo' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "exception_addRef")) Module["exception_addRef"] = function() {
|
abort("'exception_addRef' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "exception_decRef")) Module["exception_decRef"] = function() {
|
abort("'exception_decRef' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "Browser")) Module["Browser"] = function() {
|
abort("'Browser' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "funcWrappers")) Module["funcWrappers"] = function() {
|
abort("'funcWrappers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getFuncWrapper")) Module["getFuncWrapper"] = function() {
|
abort("'getFuncWrapper' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setMainLoop")) Module["setMainLoop"] = function() {
|
abort("'setMainLoop' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "tempFixedLengthArray")) Module["tempFixedLengthArray"] = function() {
|
abort("'tempFixedLengthArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "miniTempWebGLFloatBuffers")) Module["miniTempWebGLFloatBuffers"] = function() {
|
abort("'miniTempWebGLFloatBuffers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "heapObjectForWebGLType")) Module["heapObjectForWebGLType"] = function() {
|
abort("'heapObjectForWebGLType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "heapAccessShiftForWebGLHeap")) Module["heapAccessShiftForWebGLHeap"] = function() {
|
abort("'heapAccessShiftForWebGLHeap' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "GL")) Module["GL"] = function() {
|
abort("'GL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGet")) Module["emscriptenWebGLGet"] = function() {
|
abort("'emscriptenWebGLGet' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "computeUnpackAlignedImageSize")) Module["computeUnpackAlignedImageSize"] = function() {
|
abort("'computeUnpackAlignedImageSize' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetTexPixelData")) Module["emscriptenWebGLGetTexPixelData"] = function() {
|
abort("'emscriptenWebGLGetTexPixelData' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetUniform")) Module["emscriptenWebGLGetUniform"] = function() {
|
abort("'emscriptenWebGLGetUniform' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "webglGetUniformLocation")) Module["webglGetUniformLocation"] = function() {
|
abort("'webglGetUniformLocation' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetVertexAttrib")) Module["emscriptenWebGLGetVertexAttrib"] = function() {
|
abort("'emscriptenWebGLGetVertexAttrib' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "writeGLArray")) Module["writeGLArray"] = function() {
|
abort("'writeGLArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "FS")) Module["FS"] = function() {
|
abort("'FS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "mmapAlloc")) Module["mmapAlloc"] = function() {
|
abort("'mmapAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "MEMFS")) Module["MEMFS"] = function() {
|
abort("'MEMFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "TTY")) Module["TTY"] = function() {
|
abort("'TTY' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "PIPEFS")) Module["PIPEFS"] = function() {
|
abort("'PIPEFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SOCKFS")) Module["SOCKFS"] = function() {
|
abort("'SOCKFS' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "_setNetworkCallback")) Module["_setNetworkCallback"] = function() {
|
abort("'_setNetworkCallback' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "AL")) Module["AL"] = function() {
|
abort("'AL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SDL_unicode")) Module["SDL_unicode"] = function() {
|
abort("'SDL_unicode' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SDL_ttfContext")) Module["SDL_ttfContext"] = function() {
|
abort("'SDL_ttfContext' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SDL_audio")) Module["SDL_audio"] = function() {
|
abort("'SDL_audio' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SDL")) Module["SDL"] = function() {
|
abort("'SDL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "SDL_gfx")) Module["SDL_gfx"] = function() {
|
abort("'SDL_gfx' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "GLUT")) Module["GLUT"] = function() {
|
abort("'GLUT' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "EGL")) Module["EGL"] = function() {
|
abort("'EGL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "GLFW_Window")) Module["GLFW_Window"] = function() {
|
abort("'GLFW_Window' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "GLFW")) Module["GLFW"] = function() {
|
abort("'GLFW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "GLEW")) Module["GLEW"] = function() {
|
abort("'GLEW' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "IDBStore")) Module["IDBStore"] = function() {
|
abort("'IDBStore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "runAndAbortIfError")) Module["runAndAbortIfError"] = function() {
|
abort("'runAndAbortIfError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emval_handle_array")) Module["emval_handle_array"] = function() {
|
abort("'emval_handle_array' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emval_free_list")) Module["emval_free_list"] = function() {
|
abort("'emval_free_list' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emval_symbols")) Module["emval_symbols"] = function() {
|
abort("'emval_symbols' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "init_emval")) Module["init_emval"] = function() {
|
abort("'init_emval' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "count_emval_handles")) Module["count_emval_handles"] = function() {
|
abort("'count_emval_handles' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "get_first_emval")) Module["get_first_emval"] = function() {
|
abort("'get_first_emval' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getStringOrSymbol")) Module["getStringOrSymbol"] = function() {
|
abort("'getStringOrSymbol' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "requireHandle")) Module["requireHandle"] = function() {
|
abort("'requireHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emval_newers")) Module["emval_newers"] = function() {
|
abort("'emval_newers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "craftEmvalAllocator")) Module["craftEmvalAllocator"] = function() {
|
abort("'craftEmvalAllocator' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emval_get_global")) Module["emval_get_global"] = function() {
|
abort("'emval_get_global' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emval_methodCallers")) Module["emval_methodCallers"] = function() {
|
abort("'emval_methodCallers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "InternalError")) Module["InternalError"] = function() {
|
abort("'InternalError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "BindingError")) Module["BindingError"] = function() {
|
abort("'BindingError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "UnboundTypeError")) Module["UnboundTypeError"] = function() {
|
abort("'UnboundTypeError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "PureVirtualError")) Module["PureVirtualError"] = function() {
|
abort("'PureVirtualError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "init_embind")) Module["init_embind"] = function() {
|
abort("'init_embind' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "throwInternalError")) Module["throwInternalError"] = function() {
|
abort("'throwInternalError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "throwBindingError")) Module["throwBindingError"] = function() {
|
abort("'throwBindingError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "throwUnboundTypeError")) Module["throwUnboundTypeError"] = function() {
|
abort("'throwUnboundTypeError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ensureOverloadTable")) Module["ensureOverloadTable"] = function() {
|
abort("'ensureOverloadTable' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "exposePublicSymbol")) Module["exposePublicSymbol"] = function() {
|
abort("'exposePublicSymbol' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "replacePublicSymbol")) Module["replacePublicSymbol"] = function() {
|
abort("'replacePublicSymbol' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "extendError")) Module["extendError"] = function() {
|
abort("'extendError' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "createNamedFunction")) Module["createNamedFunction"] = function() {
|
abort("'createNamedFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registeredInstances")) Module["registeredInstances"] = function() {
|
abort("'registeredInstances' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getBasestPointer")) Module["getBasestPointer"] = function() {
|
abort("'getBasestPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerInheritedInstance")) Module["registerInheritedInstance"] = function() {
|
abort("'registerInheritedInstance' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "unregisterInheritedInstance")) Module["unregisterInheritedInstance"] = function() {
|
abort("'unregisterInheritedInstance' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getInheritedInstance")) Module["getInheritedInstance"] = function() {
|
abort("'getInheritedInstance' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getInheritedInstanceCount")) Module["getInheritedInstanceCount"] = function() {
|
abort("'getInheritedInstanceCount' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getLiveInheritedInstances")) Module["getLiveInheritedInstances"] = function() {
|
abort("'getLiveInheritedInstances' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registeredTypes")) Module["registeredTypes"] = function() {
|
abort("'registeredTypes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "awaitingDependencies")) Module["awaitingDependencies"] = function() {
|
abort("'awaitingDependencies' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "typeDependencies")) Module["typeDependencies"] = function() {
|
abort("'typeDependencies' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registeredPointers")) Module["registeredPointers"] = function() {
|
abort("'registeredPointers' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "registerType")) Module["registerType"] = function() {
|
abort("'registerType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "whenDependentTypesAreResolved")) Module["whenDependentTypesAreResolved"] = function() {
|
abort("'whenDependentTypesAreResolved' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "embind_charCodes")) Module["embind_charCodes"] = function() {
|
abort("'embind_charCodes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "embind_init_charCodes")) Module["embind_init_charCodes"] = function() {
|
abort("'embind_init_charCodes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "readLatin1String")) Module["readLatin1String"] = function() {
|
abort("'readLatin1String' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getTypeName")) Module["getTypeName"] = function() {
|
abort("'getTypeName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "heap32VectorToArray")) Module["heap32VectorToArray"] = function() {
|
abort("'heap32VectorToArray' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "requireRegisteredType")) Module["requireRegisteredType"] = function() {
|
abort("'requireRegisteredType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "getShiftFromSize")) Module["getShiftFromSize"] = function() {
|
abort("'getShiftFromSize' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "integerReadValueFromPointer")) Module["integerReadValueFromPointer"] = function() {
|
abort("'integerReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "enumReadValueFromPointer")) Module["enumReadValueFromPointer"] = function() {
|
abort("'enumReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "floatReadValueFromPointer")) Module["floatReadValueFromPointer"] = function() {
|
abort("'floatReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "simpleReadValueFromPointer")) Module["simpleReadValueFromPointer"] = function() {
|
abort("'simpleReadValueFromPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "runDestructors")) Module["runDestructors"] = function() {
|
abort("'runDestructors' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "new_")) Module["new_"] = function() {
|
abort("'new_' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "craftInvokerFunction")) Module["craftInvokerFunction"] = function() {
|
abort("'craftInvokerFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "embind__requireFunction")) Module["embind__requireFunction"] = function() {
|
abort("'embind__requireFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "tupleRegistrations")) Module["tupleRegistrations"] = function() {
|
abort("'tupleRegistrations' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "structRegistrations")) Module["structRegistrations"] = function() {
|
abort("'structRegistrations' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "genericPointerToWireType")) Module["genericPointerToWireType"] = function() {
|
abort("'genericPointerToWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "constNoSmartPtrRawPointerToWireType")) Module["constNoSmartPtrRawPointerToWireType"] = function() {
|
abort("'constNoSmartPtrRawPointerToWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "nonConstNoSmartPtrRawPointerToWireType")) Module["nonConstNoSmartPtrRawPointerToWireType"] = function() {
|
abort("'nonConstNoSmartPtrRawPointerToWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "init_RegisteredPointer")) Module["init_RegisteredPointer"] = function() {
|
abort("'init_RegisteredPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer")) Module["RegisteredPointer"] = function() {
|
abort("'RegisteredPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_getPointee")) Module["RegisteredPointer_getPointee"] = function() {
|
abort("'RegisteredPointer_getPointee' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_destructor")) Module["RegisteredPointer_destructor"] = function() {
|
abort("'RegisteredPointer_destructor' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_deleteObject")) Module["RegisteredPointer_deleteObject"] = function() {
|
abort("'RegisteredPointer_deleteObject' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "RegisteredPointer_fromWireType")) Module["RegisteredPointer_fromWireType"] = function() {
|
abort("'RegisteredPointer_fromWireType' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "runDestructor")) Module["runDestructor"] = function() {
|
abort("'runDestructor' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "releaseClassHandle")) Module["releaseClassHandle"] = function() {
|
abort("'releaseClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "finalizationGroup")) Module["finalizationGroup"] = function() {
|
abort("'finalizationGroup' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "detachFinalizer_deps")) Module["detachFinalizer_deps"] = function() {
|
abort("'detachFinalizer_deps' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "detachFinalizer")) Module["detachFinalizer"] = function() {
|
abort("'detachFinalizer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "attachFinalizer")) Module["attachFinalizer"] = function() {
|
abort("'attachFinalizer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "makeClassHandle")) Module["makeClassHandle"] = function() {
|
abort("'makeClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "init_ClassHandle")) Module["init_ClassHandle"] = function() {
|
abort("'init_ClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle")) Module["ClassHandle"] = function() {
|
abort("'ClassHandle' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_isAliasOf")) Module["ClassHandle_isAliasOf"] = function() {
|
abort("'ClassHandle_isAliasOf' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "throwInstanceAlreadyDeleted")) Module["throwInstanceAlreadyDeleted"] = function() {
|
abort("'throwInstanceAlreadyDeleted' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_clone")) Module["ClassHandle_clone"] = function() {
|
abort("'ClassHandle_clone' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_delete")) Module["ClassHandle_delete"] = function() {
|
abort("'ClassHandle_delete' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "deletionQueue")) Module["deletionQueue"] = function() {
|
abort("'deletionQueue' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_isDeleted")) Module["ClassHandle_isDeleted"] = function() {
|
abort("'ClassHandle_isDeleted' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ClassHandle_deleteLater")) Module["ClassHandle_deleteLater"] = function() {
|
abort("'ClassHandle_deleteLater' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "flushPendingDeletes")) Module["flushPendingDeletes"] = function() {
|
abort("'flushPendingDeletes' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "delayFunction")) Module["delayFunction"] = function() {
|
abort("'delayFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "setDelayFunction")) Module["setDelayFunction"] = function() {
|
abort("'setDelayFunction' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "RegisteredClass")) Module["RegisteredClass"] = function() {
|
abort("'RegisteredClass' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "shallowCopyInternalPointer")) Module["shallowCopyInternalPointer"] = function() {
|
abort("'shallowCopyInternalPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "downcastPointer")) Module["downcastPointer"] = function() {
|
abort("'downcastPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "upcastPointer")) Module["upcastPointer"] = function() {
|
abort("'upcastPointer' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "validateThis")) Module["validateThis"] = function() {
|
abort("'validateThis' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "char_0")) Module["char_0"] = function() {
|
abort("'char_0' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "char_9")) Module["char_9"] = function() {
|
abort("'char_9' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "makeLegalFunctionName")) Module["makeLegalFunctionName"] = function() {
|
abort("'makeLegalFunctionName' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["PThread"] = PThread;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "killThread")) Module["killThread"] = function() {
|
abort("'killThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "cleanupThread")) Module["cleanupThread"] = function() {
|
abort("'cleanupThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "cancelThread")) Module["cancelThread"] = function() {
|
abort("'cancelThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "spawnThread")) Module["spawnThread"] = function() {
|
abort("'spawnThread' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "establishStackSpace")) Module["establishStackSpace"] = function() {
|
abort("'establishStackSpace' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "invokeEntryPoint")) Module["invokeEntryPoint"] = function() {
|
abort("'invokeEntryPoint' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "emscriptenWebGLGetIndexed")) Module["emscriptenWebGLGetIndexed"] = function() {
|
abort("'emscriptenWebGLGetIndexed' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "warnOnce")) Module["warnOnce"] = function() {
|
abort("'warnOnce' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stackSave")) Module["stackSave"] = function() {
|
abort("'stackSave' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stackRestore")) Module["stackRestore"] = function() {
|
abort("'stackRestore' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stackAlloc")) Module["stackAlloc"] = function() {
|
abort("'stackAlloc' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "AsciiToString")) Module["AsciiToString"] = function() {
|
abort("'AsciiToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stringToAscii")) Module["stringToAscii"] = function() {
|
abort("'stringToAscii' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "UTF16ToString")) Module["UTF16ToString"] = function() {
|
abort("'UTF16ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF16")) Module["stringToUTF16"] = function() {
|
abort("'stringToUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF16")) Module["lengthBytesUTF16"] = function() {
|
abort("'lengthBytesUTF16' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "UTF32ToString")) Module["UTF32ToString"] = function() {
|
abort("'UTF32ToString' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "stringToUTF32")) Module["stringToUTF32"] = function() {
|
abort("'stringToUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "lengthBytesUTF32")) Module["lengthBytesUTF32"] = function() {
|
abort("'lengthBytesUTF32' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8")) Module["allocateUTF8"] = function() {
|
abort("'allocateUTF8' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
if (!Object.getOwnPropertyDescriptor(Module, "allocateUTF8OnStack")) Module["allocateUTF8OnStack"] = function() {
|
abort("'allocateUTF8OnStack' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
};
|
|
Module["writeStackCookie"] = writeStackCookie;
|
|
Module["checkStackCookie"] = checkStackCookie;
|
|
Module["PThread"] = PThread;
|
|
Module["wasmMemory"] = wasmMemory;
|
|
Module["ExitStatus"] = ExitStatus;
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_NORMAL")) Object.defineProperty(Module, "ALLOC_NORMAL", {
|
configurable: true,
|
get: function() {
|
abort("'ALLOC_NORMAL' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
}
|
});
|
|
if (!Object.getOwnPropertyDescriptor(Module, "ALLOC_STACK")) Object.defineProperty(Module, "ALLOC_STACK", {
|
configurable: true,
|
get: function() {
|
abort("'ALLOC_STACK' was not exported. add it to EXTRA_EXPORTED_RUNTIME_METHODS (see the FAQ)");
|
}
|
});
|
|
var calledRun;
|
|
function ExitStatus(status) {
|
this.name = "ExitStatus";
|
this.message = "Program terminated with exit(" + status + ")";
|
this.status = status;
|
}
|
|
var calledMain = false;
|
|
dependenciesFulfilled = function runCaller() {
|
if (!calledRun) run();
|
if (!calledRun) dependenciesFulfilled = runCaller;
|
};
|
|
function stackCheckInit() {
|
_emscripten_stack_init();
|
writeStackCookie();
|
}
|
|
function run(args) {
|
args = args || arguments_;
|
if (runDependencies > 0) {
|
return;
|
}
|
stackCheckInit();
|
if (ENVIRONMENT_IS_PTHREAD) {
|
readyPromiseResolve(Module);
|
initRuntime();
|
postMessage({
|
"cmd": "loaded"
|
});
|
return;
|
}
|
preRun();
|
if (runDependencies > 0) {
|
return;
|
}
|
function doRun() {
|
if (calledRun) return;
|
calledRun = true;
|
Module["calledRun"] = true;
|
if (ABORT) return;
|
initRuntime();
|
preMain();
|
readyPromiseResolve(Module);
|
if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
|
assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
|
postRun();
|
}
|
if (Module["setStatus"]) {
|
Module["setStatus"]("Running...");
|
setTimeout(function() {
|
setTimeout(function() {
|
Module["setStatus"]("");
|
}, 1);
|
doRun();
|
}, 1);
|
} else {
|
doRun();
|
}
|
checkStackCookie();
|
}
|
|
Module["run"] = run;
|
|
function checkUnflushedContent() {
|
var oldOut = out;
|
var oldErr = err;
|
var has = false;
|
out = err = function(x) {
|
has = true;
|
};
|
try {
|
var flush = Module["_fflush"];
|
if (flush) flush(0);
|
[ "stdout", "stderr" ].forEach(function(name) {
|
var info = FS.analyzePath("/dev/" + name);
|
if (!info) return;
|
var stream = info.object;
|
var rdev = stream.rdev;
|
var tty = TTY.ttys[rdev];
|
if (tty && tty.output && tty.output.length) {
|
has = true;
|
}
|
});
|
} catch (e) {}
|
out = oldOut;
|
err = oldErr;
|
if (has) {
|
warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.");
|
}
|
}
|
|
function exit(status, implicit) {
|
EXITSTATUS = status;
|
checkUnflushedContent();
|
if (implicit && keepRuntimeAlive() && status === 0) {
|
return;
|
}
|
if (!implicit) {
|
if (ENVIRONMENT_IS_PTHREAD) {
|
err("Pthread 0x" + _pthread_self().toString(16) + " called exit(), posting exitProcess.");
|
postMessage({
|
"cmd": "exitProcess",
|
"returnCode": status
|
});
|
throw new ExitStatus(status);
|
} else {
|
err("main thread called exit: keepRuntimeAlive=" + keepRuntimeAlive() + " (counter=" + runtimeKeepaliveCounter + ")");
|
}
|
}
|
if (keepRuntimeAlive()) {
|
if (!implicit) {
|
var msg = "program exited (with status: " + status + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)";
|
readyPromiseReject(msg);
|
err(msg);
|
}
|
} else {
|
PThread.terminateAllThreads();
|
exitRuntime();
|
if (Module["onExit"]) Module["onExit"](status);
|
ABORT = true;
|
}
|
quit_(status, new ExitStatus(status));
|
}
|
|
if (Module["preInit"]) {
|
if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
|
while (Module["preInit"].length > 0) {
|
Module["preInit"].pop()();
|
}
|
}
|
|
if (ENVIRONMENT_IS_PTHREAD) {
|
noExitRuntime = false;
|
PThread.initWorker();
|
}
|
|
run();
|
|
|
return JSPlayerModule.ready
|
}
|
);
|
})();
|
if (typeof exports === 'object' && typeof module === 'object')
|
module.exports = JSPlayerModule;
|
else if (typeof define === 'function' && define['amd'])
|
define([], function() { return JSPlayerModule; });
|
else if (typeof exports === 'object')
|
exports["JSPlayerModule"] = JSPlayerModule;
|
