amr-recorder
Version:
amr 音频录制与播放（微信语音所用的格式）
1,356 lines (1,268 loc) • 1.08 MB
JavaScript
module.exports = function() {
var AMR = (function () {
var AMR = {
toWAV: (function (amr) {
var decoded = this._decode(amr);
if (!decoded) {
return null
}
var raw = new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength);
var out = new Uint8Array(raw.length + this.WAV_HEADER_SIZE);
var offset = 0;
var write_int16 = (function (value) {
var a = new Uint8Array(2);
(new Int16Array(a.buffer))[0] = value;
out.set(a, offset);
offset += 2
});
var write_int32 = (function (value) {
var a = new Uint8Array(4);
(new Int32Array(a.buffer))[0] = value;
out.set(a, offset);
offset += 4
});
var write_string = (function (value) {
var d = (new TextEncoder("utf-8")).encode(value);
out.set(d, offset);
offset += d.length
});
write_string("RIFF");
write_int32(4 + 8 + 16 + 8 + raw.length);
write_string("WAVEfmt ");
write_int32(16);
var bits_per_sample = 16;
var sample_rate = 8e3;
var channels = 1;
var bytes_per_frame = bits_per_sample / 8 * channels;
var bytes_per_sec = bytes_per_frame * sample_rate;
write_int16(1);
write_int16(1);
write_int32(sample_rate);
write_int32(bytes_per_sec);
write_int16(bytes_per_frame);
write_int16(bits_per_sample);
write_string("data");
write_int32(raw.length);
out.set(raw, offset);
return out
}),
decode: (function (amr) {
var raw = this._decode(amr);
if (!raw) {
return null
}
var out = new Float32Array(raw.length);
for (var i = 0; i < out.length; i++) {
out[i] = raw[i] / 32768
}
return out
}),
_decode: (function (amr) {
if (String.fromCharCode.apply(null, amr.subarray(0, this.AMR_HEADER.length)) !== this.AMR_HEADER) {
return null
}
var decoder = this.Decoder_Interface_init();
if (!decoder) {
return null
}
var out = new Int16Array(Math.floor(amr.length / 6 * this.PCM_BUFFER_COUNT));
var buf = Module._malloc(this.AMR_BUFFER_COUNT);
var decodeInBuffer = new Uint8Array(Module.HEAPU8.buffer, buf, this.AMR_BUFFER_COUNT);
buf = Module._malloc(this.PCM_BUFFER_COUNT * 2);
var decodeOutBuffer = new Int16Array(Module.HEAPU8.buffer, buf, this.PCM_BUFFER_COUNT);
var inOffset = 6;
var outOffset = 0;
while (inOffset + 1 < amr.length && outOffset + 1 < out.length) {
var size = this.SIZES[amr[inOffset] >> 3 & 15];
if (inOffset + size + 1 > amr.length) {
break
}
decodeInBuffer.set(amr.subarray(inOffset, inOffset + size + 1));
this.Decoder_Interface_Decode(decoder, decodeInBuffer.byteOffset, decodeOutBuffer.byteOffset, 0);
if (outOffset + this.PCM_BUFFER_COUNT > out.length) {
var newOut = new Int16Array(out.length * 2);
newOut.set(out.subarray(0, outOffset));
out = newOut
}
out.set(decodeOutBuffer, outOffset);
outOffset += this.PCM_BUFFER_COUNT;
inOffset += size + 1
}
Module._free(decodeInBuffer.byteOffset);
Module._free(decodeOutBuffer.byteOffset);
this.Decoder_Interface_exit(decoder);
return out.subarray(0, outOffset)
}),
encode: (function (pcm, pcmSampleRate, mode) {
if (pcmSampleRate < 8e3) {
console.error("pcmSampleRate should not be less than 8000.");
return null
}
if (typeof mode === "undefined") {
mode = this.Mode.MR795
}
var encoder = this.Encoder_Interface_init();
if (!encoder) {
return null
}
var buf = Module._malloc(this.PCM_BUFFER_COUNT * 2);
var encodeInBuffer = new Int16Array(Module.HEAPU8.buffer, buf, this.PCM_BUFFER_COUNT);
buf = Module._malloc(this.AMR_BUFFER_COUNT);
var encodeOutBuffer = new Uint8Array(Module.HEAPU8.buffer, buf, this.AMR_BUFFER_COUNT);
var ratio = pcmSampleRate / 8e3;
var inLength = Math.floor(pcm.length / ratio);
var inData = new Int16Array(inLength);
for (var i = 0; i < inLength; i++) {
inData[i] = pcm[Math.floor(i * ratio)] * (32768 - 1)
}
var blockSize = this.SIZES[mode] + 1;
var out = new Uint8Array(Math.ceil(inLength / this.PCM_BUFFER_COUNT * blockSize) + this.AMR_HEADER.length);
out.set((new TextEncoder("utf-8")).encode(this.AMR_HEADER));
var inOffset = 0;
var outOffset = this.AMR_HEADER.length;
while (inOffset + this.PCM_BUFFER_COUNT < inData.length && outOffset + blockSize < out.length) {
encodeInBuffer.set(inData.subarray(inOffset, inOffset + this.PCM_BUFFER_COUNT));
var n = this.Encoder_Interface_Encode(encoder, mode, encodeInBuffer.byteOffset, encodeOutBuffer.byteOffset, 0);
if (n != blockSize) {
console.error([n, blockSize]);
break
}
out.set(encodeOutBuffer.subarray(0, n), outOffset);
inOffset += this.PCM_BUFFER_COUNT;
outOffset += n
}
Module._free(encodeInBuffer.byteOffset);
Module._free(encodeOutBuffer.byteOffset);
this.Encoder_Interface_exit(encoder);
return out.subarray(0, outOffset)
}),
Decoder_Interface_init: (function () {
console.warn("Decoder_Interface_init not initialized.");
return 0
}),
Decoder_Interface_exit: (function (state) {
console.warn("Decoder_Interface_exit not initialized.")
}),
Decoder_Interface_Decode: (function (state, inBuffer, outBuffer, bfi) {
console.warn("Decoder_Interface_Decode not initialized.")
}),
Encoder_Interface_init: (function (dtx) {
console.warn("Encoder_Interface_init not initialized.");
return 0
}),
Encoder_Interface_exit: (function (state) {
console.warn("Encoder_Interface_exit not initialized.")
}),
Encoder_Interface_Encode: (function (state, mode, speech, out, forceSpeech) {
console.warn("Encoder_Interface_Encode not initialized.")
}),
Mode: {MR475: 0, MR515: 1, MR59: 2, MR67: 3, MR74: 4, MR795: 5, MR102: 6, MR122: 7, MRDTX: 8},
SIZES: [12, 13, 15, 17, 19, 20, 26, 31, 5, 6, 5, 5, 0, 0, 0, 0],
AMR_BUFFER_COUNT: 32,
PCM_BUFFER_COUNT: 160,
AMR_HEADER: "#!AMR\n",
WAV_HEADER_SIZE: 44
};
var Module = {
canvas: {}, print: (function (text) {
console.log(text)
}), _main: (function () {
AMR.Decoder_Interface_init = Module._Decoder_Interface_init;
AMR.Decoder_Interface_exit = Module._Decoder_Interface_exit;
AMR.Decoder_Interface_Decode = Module._Decoder_Interface_Decode;
AMR.Encoder_Interface_init = Module._Encoder_Interface_init;
AMR.Encoder_Interface_exit = Module._Encoder_Interface_exit;
AMR.Encoder_Interface_Encode = Module._Encoder_Interface_Encode;
return 0
})
};
var Module;
if (!Module) Module = (typeof Module !== "undefined" ? Module : null) || {};
var moduleOverrides = {};
for (var key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key]
}
}
var ENVIRONMENT_IS_WEB = typeof window === "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
var ENVIRONMENT_IS_NODE = false;/*typeof process === "object" && typeof require === "function" && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;*/
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
if (ENVIRONMENT_IS_SHELL) {
if (!Module["print"]) Module["print"] = print;
if (typeof printErr != "undefined") Module["printErr"] = printErr;
if (typeof read != "undefined") {
Module["read"] = read
} else {
Module["read"] = function read() {
throw"no read() available (jsc?)"
}
}
Module["readBinary"] = function readBinary(f) {
if (typeof readbuffer === "function") {
return new Uint8Array(readbuffer(f))
}
var data = read(f, "binary");
assert(typeof data === "object");
return data
};
if (typeof scriptArgs != "undefined") {
Module["arguments"] = scriptArgs
} else if (typeof arguments != "undefined") {
Module["arguments"] = arguments
}
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
Module["read"] = function read(url) {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText
};
if (typeof arguments != "undefined") {
Module["arguments"] = arguments
}
if (typeof console !== "undefined") {
if (!Module["print"]) Module["print"] = function print(x) {
console.log(x)
};
if (!Module["printErr"]) Module["printErr"] = function printErr(x) {
console.log(x)
}
} else {
var TRY_USE_DUMP = false;
if (!Module["print"]) Module["print"] = TRY_USE_DUMP && typeof dump !== "undefined" ? (function (x) {
dump(x)
}) : (function (x) {
})
}
if (ENVIRONMENT_IS_WORKER) {
Module["load"] = importScripts
}
if (typeof Module["setWindowTitle"] === "undefined") {
Module["setWindowTitle"] = (function (title) {
document.title = title
})
}
} else {
throw"Unknown runtime environment. Where are we?"
}
function globalEval(x) {
eval.call(null, x)
}
if (!Module["load"] && Module["read"]) {
Module["load"] = function load(f) {
globalEval(Module["read"](f))
}
}
if (!Module["print"]) {
Module["print"] = (function () {
})
}
if (!Module["printErr"]) {
Module["printErr"] = Module["print"]
}
if (!Module["arguments"]) {
Module["arguments"] = []
}
if (!Module["thisProgram"]) {
Module["thisProgram"] = "./this.program"
}
Module.print = Module["print"];
Module.printErr = Module["printErr"];
Module["preRun"] = [];
Module["postRun"] = [];
for (var key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key]
}
}
var Runtime = {
setTempRet0: (function (value) {
tempRet0 = value
}), getTempRet0: (function () {
return tempRet0
}), stackSave: (function () {
return STACKTOP
}), stackRestore: (function (stackTop) {
STACKTOP = stackTop
}), getNativeTypeSize: (function (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 Runtime.QUANTUM_SIZE
} else if (type[0] === "i") {
var bits = parseInt(type.substr(1));
assert(bits % 8 === 0);
return bits / 8
} else {
return 0
}
}
}
}), getNativeFieldSize: (function (type) {
return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE)
}), STACK_ALIGN: 16, prepVararg: (function (ptr, type) {
if (type === "double" || type === "i64") {
if (ptr & 7) {
assert((ptr & 7) === 4);
ptr += 4
}
} else {
assert((ptr & 3) === 0)
}
return ptr
}), getAlignSize: (function (type, size, vararg) {
if (!vararg && (type == "i64" || type == "double")) return 8;
if (!type) return Math.min(size, 8);
return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
}), dynCall: (function (sig, ptr, args) {
if (args && args.length) {
if (!args.splice) args = Array.prototype.slice.call(args);
args.splice(0, 0, ptr);
return Module["dynCall_" + sig].apply(null, args)
} else {
return Module["dynCall_" + sig].call(null, ptr)
}
}), functionPointers: [], addFunction: (function (func) {
for (var i = 0; i < Runtime.functionPointers.length; i++) {
if (!Runtime.functionPointers[i]) {
Runtime.functionPointers[i] = func;
return 2 * (1 + i)
}
}
throw"Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS."
}), removeFunction: (function (index) {
Runtime.functionPointers[(index - 2) / 2] = null
}), warnOnce: (function (text) {
if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
if (!Runtime.warnOnce.shown[text]) {
Runtime.warnOnce.shown[text] = 1;
Module.printErr(text)
}
}), funcWrappers: {}, getFuncWrapper: (function (func, sig) {
assert(sig);
if (!Runtime.funcWrappers[sig]) {
Runtime.funcWrappers[sig] = {}
}
var sigCache = Runtime.funcWrappers[sig];
if (!sigCache[func]) {
sigCache[func] = function dynCall_wrapper() {
return Runtime.dynCall(sig, func, arguments)
}
}
return sigCache[func]
}), getCompilerSetting: (function (name) {
throw"You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work"
}), stackAlloc: (function (size) {
var ret = STACKTOP;
STACKTOP = STACKTOP + size | 0;
STACKTOP = STACKTOP + 15 & -16;
return ret
}), staticAlloc: (function (size) {
var ret = STATICTOP;
STATICTOP = STATICTOP + size | 0;
STATICTOP = STATICTOP + 15 & -16;
return ret
}), dynamicAlloc: (function (size) {
var ret = DYNAMICTOP;
DYNAMICTOP = DYNAMICTOP + size | 0;
DYNAMICTOP = DYNAMICTOP + 15 & -16;
if (DYNAMICTOP >= TOTAL_MEMORY) {
var success = enlargeMemory();
if (!success) {
DYNAMICTOP = ret;
return 0
}
}
return ret
}), alignMemory: (function (size, quantum) {
var ret = size = Math.ceil(size / (quantum ? quantum : 16)) * (quantum ? quantum : 16);
return ret
}), makeBigInt: (function (low, high, unsigned) {
var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * +4294967296 : +(low >>> 0) + +(high | 0) * +4294967296;
return ret
}), GLOBAL_BASE: 8, QUANTUM_SIZE: 4, __dummy__: 0
};
Module["Runtime"] = Runtime;
var __THREW__ = 0;
var ABORT = false;
var EXITSTATUS = 0;
var undef = 0;
var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS,
tempBigIntP, tempBigIntD, tempDouble, tempFloat;
var tempI64, tempI64b;
var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed: " + text)
}
}
var globalScope = this;
function getCFunc(ident) {
var func = Module["_" + ident];
if (!func) {
try {
func = eval("_" + ident)
} catch (e) {
}
}
assert(func, "Cannot call unknown function " + ident + " (perhaps LLVM optimizations or closure removed it?)");
return func
}
var cwrap, ccall;
((function () {
var JSfuncs = {
"stackSave": (function () {
Runtime.stackSave()
}), "stackRestore": (function () {
Runtime.stackRestore()
}), "arrayToC": (function (arr) {
var ret = Runtime.stackAlloc(arr.length);
writeArrayToMemory(arr, ret);
return ret
}), "stringToC": (function (str) {
var ret = 0;
if (str !== null && str !== undefined && str !== 0) {
ret = Runtime.stackAlloc((str.length << 2) + 1);
writeStringToMemory(str, ret)
}
return ret
})
};
var toC = {"string": JSfuncs["stringToC"], "array": JSfuncs["arrayToC"]};
ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
var func = getCFunc(ident);
var cArgs = [];
var stack = 0;
if (args) {
for (var i = 0; i < args.length; i++) {
var converter = toC[argTypes[i]];
if (converter) {
if (stack === 0) stack = Runtime.stackSave();
cArgs[i] = converter(args[i])
} else {
cArgs[i] = args[i]
}
}
}
var ret = func.apply(null, cArgs);
if (returnType === "string") ret = Pointer_stringify(ret);
if (stack !== 0) {
if (opts && opts.async) {
EmterpreterAsync.asyncFinalizers.push((function () {
Runtime.stackRestore(stack)
}));
return
}
Runtime.stackRestore(stack)
}
return ret
};
var sourceRegex = /^function\s\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
function parseJSFunc(jsfunc) {
// Match the body and the return value of a javascript function source
var parsed = jsfunc.toString().match(sourceRegex);
if (!parsed) { return {}; }
parsed = parsed.slice(1);
return {arguments: parsed[0], body: parsed[1], returnValue: parsed[2]}
}
var JSsource = {};
for (var fun in JSfuncs) {
if (JSfuncs.hasOwnProperty(fun)) {
JSsource[fun] = parseJSFunc(JSfuncs[fun])
}
}
cwrap = function cwrap(ident, returnType, argTypes) {
argTypes = argTypes || [];
var cfunc = getCFunc(ident);
var numericArgs = argTypes.every((function (type) {
return type === "number"
}));
var numericRet = returnType !== "string";
if (numericRet && numericArgs) {
return cfunc
}
var argNames = argTypes.map((function (x, i) {
return "$" + i
}));
var funcstr = "(function(" + argNames.join(",") + ") {";
var nargs = argTypes.length;
if (!numericArgs) {
funcstr += "var stack = " + JSsource["stackSave"].body + ";";
for (var i = 0; i < nargs; i++) {
var arg = argNames[i], type = argTypes[i];
if (type === "number") continue;
var convertCode = JSsource[type + "ToC"];
funcstr += "var " + convertCode.arguments + " = " + arg + ";";
funcstr += convertCode.body + ";";
funcstr += arg + "=" + convertCode.returnValue + ";"
}
}
var cfuncname = parseJSFunc((function () {
return cfunc
})).returnValue;
funcstr += "var ret = " + cfuncname + "(" + argNames.join(",") + ");";
if (!numericRet) {
var strgfy = parseJSFunc((function () {
return Pointer_stringify
})).returnValue;
funcstr += "ret = " + strgfy + "(ret);"
}
if (!numericArgs) {
funcstr += JSsource["stackRestore"].body.replace("()", "(stack)") + ";"
}
funcstr += "return ret})";
return eval(funcstr)
}
}))();
Module["ccall"] = ccall;
Module["cwrap"] = cwrap;
function setValue(ptr, value, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
switch (type) {
case"i1":
HEAP8[ptr >> 0] = value;
break;
case"i8":
HEAP8[ptr >> 0] = value;
break;
case"i16":
HEAP16[ptr >> 1] = value;
break;
case"i32":
HEAP32[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)], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1];
break;
case"float":
HEAPF32[ptr >> 2] = value;
break;
case"double":
HEAPF64[ptr >> 3] = value;
break;
default:
abort("invalid type for setValue: " + type)
}
}
Module["setValue"] = setValue;
function getValue(ptr, type, noSafe) {
type = type || "i8";
if (type.charAt(type.length - 1) === "*") type = "i32";
switch (type) {
case"i1":
return HEAP8[ptr >> 0];
case"i8":
return HEAP8[ptr >> 0];
case"i16":
return HEAP16[ptr >> 1];
case"i32":
return HEAP32[ptr >> 2];
case"i64":
return HEAP32[ptr >> 2];
case"float":
return HEAPF32[ptr >> 2];
case"double":
return HEAPF64[ptr >> 3];
default:
abort("invalid type for setValue: " + type)
}
return null
}
Module["getValue"] = getValue;
var ALLOC_NORMAL = 0;
var ALLOC_STACK = 1;
var ALLOC_STATIC = 2;
var ALLOC_DYNAMIC = 3;
var ALLOC_NONE = 4;
Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
Module["ALLOC_STACK"] = ALLOC_STACK;
Module["ALLOC_STATIC"] = ALLOC_STATIC;
Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
Module["ALLOC_NONE"] = ALLOC_NONE;
function allocate(slab, types, allocator, ptr) {
var zeroinit, size;
if (typeof slab === "number") {
zeroinit = true;
size = slab
} else {
zeroinit = false;
size = slab.length
}
var singleType = typeof types === "string" ? types : null;
var ret;
if (allocator == ALLOC_NONE) {
ret = ptr
} else {
ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length))
}
if (zeroinit) {
var ptr = ret, stop;
assert((ret & 3) == 0);
stop = ret + (size & ~3);
for (; ptr < stop; ptr += 4) {
HEAP32[ptr >> 2] = 0
}
stop = ret + size;
while (ptr < stop) {
HEAP8[ptr++ >> 0] = 0
}
return ret
}
if (singleType === "i8") {
if (slab.subarray || slab.slice) {
HEAPU8.set(slab, ret)
} else {
HEAPU8.set(new Uint8Array(slab), ret)
}
return ret
}
var i = 0, type, typeSize, previousType;
while (i < size) {
var curr = slab[i];
if (typeof curr === "function") {
curr = Runtime.getFunctionIndex(curr)
}
type = singleType || types[i];
if (type === 0) {
i++;
continue
}
if (type == "i64") type = "i32";
setValue(ret + i, curr, type);
if (previousType !== type) {
typeSize = Runtime.getNativeTypeSize(type);
previousType = type
}
i += typeSize
}
return ret
}
Module["allocate"] = allocate;
function getMemory(size) {
if (!staticSealed) return Runtime.staticAlloc(size);
if (typeof _sbrk !== "undefined" && !_sbrk.called || !runtimeInitialized) return Runtime.dynamicAlloc(size);
return _malloc(size)
}
Module["getMemory"] = getMemory;
function Pointer_stringify(ptr, length) {
if (length === 0 || !ptr) return "";
var hasUtf = 0;
var t;
var i = 0;
while (1) {
t = HEAPU8[ptr + i >> 0];
hasUtf |= t;
if (t == 0 && !length) break;
i++;
if (length && i == length) break
}
if (!length) length = i;
var ret = "";
if (hasUtf < 128) {
var MAX_CHUNK = 1024;
var curr;
while (length > 0) {
curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
ret = ret ? ret + curr : curr;
ptr += MAX_CHUNK;
length -= MAX_CHUNK
}
return ret
}
return Module["UTF8ToString"](ptr)
}
Module["Pointer_stringify"] = Pointer_stringify;
function AsciiToString(ptr) {
var str = "";
while (1) {
var ch = HEAP8[ptr++ >> 0];
if (!ch) return str;
str += String.fromCharCode(ch)
}
}
Module["AsciiToString"] = AsciiToString;
function stringToAscii(str, outPtr) {
return writeAsciiToMemory(str, outPtr, false)
}
Module["stringToAscii"] = stringToAscii;
function UTF8ArrayToString(u8Array, idx) {
var u0, u1, u2, u3, u4, u5;
var str = "";
while (1) {
u0 = u8Array[idx++];
if (!u0) return str;
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue
}
u1 = u8Array[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue
}
u2 = u8Array[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2
} else {
u3 = u8Array[idx++] & 63;
if ((u0 & 248) == 240) {
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3
} else {
u4 = u8Array[idx++] & 63;
if ((u0 & 252) == 248) {
u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4
} else {
u5 = u8Array[idx++] & 63;
u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5
}
}
}
if (u0 < 65536) {
str += String.fromCharCode(u0)
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
}
}
}
Module["UTF8ArrayToString"] = UTF8ArrayToString;
function UTF8ToString(ptr) {
return UTF8ArrayToString(HEAPU8, ptr)
}
Module["UTF8ToString"] = UTF8ToString;
function stringToUTF8Array(str, outU8Array, 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) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
if (u <= 127) {
if (outIdx >= endIdx) break;
outU8Array[outIdx++] = u
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
outU8Array[outIdx++] = 192 | u >> 6;
outU8Array[outIdx++] = 128 | u & 63
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
outU8Array[outIdx++] = 224 | u >> 12;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63
} else if (u <= 2097151) {
if (outIdx + 3 >= endIdx) break;
outU8Array[outIdx++] = 240 | u >> 18;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63
} else if (u <= 67108863) {
if (outIdx + 4 >= endIdx) break;
outU8Array[outIdx++] = 248 | u >> 24;
outU8Array[outIdx++] = 128 | u >> 18 & 63;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63
} else {
if (outIdx + 5 >= endIdx) break;
outU8Array[outIdx++] = 252 | u >> 30;
outU8Array[outIdx++] = 128 | u >> 24 & 63;
outU8Array[outIdx++] = 128 | u >> 18 & 63;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63
}
}
outU8Array[outIdx] = 0;
return outIdx - startIdx
}
Module["stringToUTF8Array"] = stringToUTF8Array;
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
}
Module["stringToUTF8"] = stringToUTF8;
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 if (u <= 2097151) {
len += 4
} else if (u <= 67108863) {
len += 5
} else {
len += 6
}
}
return len
}
Module["lengthBytesUTF8"] = lengthBytesUTF8;
function UTF16ToString(ptr) {
var i = 0;
var str = "";
while (1) {
var codeUnit = HEAP16[ptr + i * 2 >> 1];
if (codeUnit == 0) return str;
++i;
str += String.fromCharCode(codeUnit)
}
}
Module["UTF16ToString"] = UTF16ToString;
function stringToUTF16(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647
}
if (maxBytesToWrite < 2) return 0;
maxBytesToWrite -= 2;
var startPtr = outPtr;
var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
var codeUnit = str.charCodeAt(i);
HEAP16[outPtr >> 1] = codeUnit;
outPtr += 2
}
HEAP16[outPtr >> 1] = 0;
return outPtr - startPtr
}
Module["stringToUTF16"] = stringToUTF16;
function lengthBytesUTF16(str) {
return str.length * 2
}
Module["lengthBytesUTF16"] = lengthBytesUTF16;
function UTF32ToString(ptr) {
var i = 0;
var str = "";
while (1) {
var utf32 = HEAP32[ptr + i * 4 >> 2];
if (utf32 == 0) return str;
++i;
if (utf32 >= 65536) {
var ch = utf32 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
} else {
str += String.fromCharCode(utf32)
}
}
}
Module["UTF32ToString"] = UTF32ToString;
function stringToUTF32(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647
}
if (maxBytesToWrite < 4) return 0;
var startPtr = outPtr;
var endPtr = startPtr + maxBytesToWrite - 4;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++i);
codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023
}
HEAP32[outPtr >> 2] = codeUnit;
outPtr += 4;
if (outPtr + 4 > endPtr) break
}
HEAP32[outPtr >> 2] = 0;
return outPtr - startPtr
}
Module["stringToUTF32"] = stringToUTF32;
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
}
Module["lengthBytesUTF32"] = lengthBytesUTF32;
function demangle(func) {
var hasLibcxxabi = !!Module["___cxa_demangle"];
if (hasLibcxxabi) {
try {
var buf = _malloc(func.length);
writeStringToMemory(func.substr(1), buf);
var status = _malloc(4);
var ret = Module["___cxa_demangle"](buf, 0, 0, status);
if (getValue(status, "i32") === 0 && ret) {
return Pointer_stringify(ret)
}
} catch (e) {
} finally {
if (buf) _free(buf);
if (status) _free(status);
if (ret) _free(ret)
}
}
var i = 3;
var basicTypes = {
"v": "void",
"b": "bool",
"c": "char",
"s": "short",
"i": "int",
"l": "long",
"f": "float",
"d": "double",
"w": "wchar_t",
"a": "signed char",
"h": "unsigned char",
"t": "unsigned short",
"j": "unsigned int",
"m": "unsigned long",
"x": "long long",
"y": "unsigned long long",
"z": "..."
};
var subs = [];
var first = true;
function dump(x) {
if (x) Module.print(x);
Module.print(func);
var pre = "";
for (var a = 0; a < i; a++) pre += " ";
Module.print(pre + "^")
}
function parseNested() {
i++;
if (func[i] === "K") i++;
var parts = [];
while (func[i] !== "E") {
if (func[i] === "S") {
i++;
var next = func.indexOf("_", i);
var num = func.substring(i, next) || 0;
parts.push(subs[num] || "?");
i = next + 1;
continue
}
if (func[i] === "C") {
parts.push(parts[parts.length - 1]);
i += 2;
continue
}
var size = parseInt(func.substr(i));
var pre = size.toString().length;
if (!size || !pre) {
i--;
break
}
var curr = func.substr(i + pre, size);
parts.push(curr);
subs.push(curr);
i += pre + size
}
i++;
return parts
}
function parse(rawList, limit, allowVoid) {
limit = limit || Infinity;
var ret = "", list = [];
function flushList() {
return "(" + list.join(", ") + ")"
}
var name;
if (func[i] === "N") {
name = parseNested().join("::");
limit--;
if (limit === 0) return rawList ? [name] : name
} else {
if (func[i] === "K" || first && func[i] === "L") i++;
var size = parseInt(func.substr(i));
if (size) {
var pre = size.toString().length;
name = func.substr(i + pre, size);
i += pre + size
}
}
first = false;
if (func[i] === "I") {
i++;
var iList = parse(true);
var iRet = parse(true, 1, true);
ret += iRet[0] + " " + name + "<" + iList.join(", ") + ">"
} else {
ret = name
}
paramLoop:while (i < func.length && limit-- > 0) {
var c = func[i++];
if (c in basicTypes) {
list.push(basicTypes[c])
} else {
switch (c) {
case"P":
list.push(parse(true, 1, true)[0] + "*");
break;
case"R":
list.push(parse(true, 1, true)[0] + "&");
break;
case"L": {
i++;
var end = func.indexOf("E", i);
var size = end - i;
list.push(func.substr(i, size));
i += size + 2;
break
}
;
case"A": {
var size = parseInt(func.substr(i));
i += size.toString().length;
if (func[i] !== "_") throw"?";
i++;
list.push(parse(true, 1, true)[0] + " [" + size + "]");
break
}
;
case"E":
break paramLoop;
default:
ret += "?" + c;
break paramLoop
}
}
}
if (!allowVoid && list.length === 1 && list[0] === "void") list = [];
if (rawList) {
if (ret) {
list.push(ret + "?")
}
return list
} else {
return ret + flushList()
}
}
var parsed = func;
try {
if (func == "Object._main" || func == "_main") {
return "main()"
}
if (typeof func === "number") func = Pointer_stringify(func);
if (func[0] !== "_") return func;
if (func[1] !== "_") return func;
if (func[2] !== "Z") return func;
switch (func[3]) {
case"n":
return "operator new()";
case"d":
return "operator delete()"
}
parsed = parse()
} catch (e) {
parsed += "?"
}
if (parsed.indexOf("?") >= 0 && !hasLibcxxabi) {
Runtime.warnOnce("warning: a problem occurred in builtin C++ name demangling; build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling")
}
return parsed
}
function demangleAll(text) {
return text.replace(/__Z[\w\d_]+/g, (function (x) {
var y = demangle(x);
return x === y ? x : x + " [" + y + "]"
}))
}
function jsStackTrace() {
var err = new Error;
if (!err.stack) {
try {
throw new Error(0)
} catch (e) {
err = e
}
if (!err.stack) {
return "(no stack trace available)"
}
}
return err.stack.toString()
}
function stackTrace() {
return demangleAll(jsStackTrace())
}
Module["stackTrace"] = stackTrace;
var PAGE_SIZE = 4096;
function alignMemoryPage(x) {
if (x % 4096 > 0) {
x += 4096 - x % 4096
}
return x
}
var HEAP;
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false;
var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0;
var DYNAMIC_BASE = 0, DYNAMICTOP = 0;
function enlargeMemory() {
abort("Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value " + TOTAL_MEMORY + ", (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.")
}
var TOTAL_STACK = Module["TOTAL_STACK"] || 65536;
var TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 524288;
var totalMemory = 64 * 1024;
while (totalMemory < TOTAL_MEMORY || totalMemory < 2 * TOTAL_STACK) {
if (totalMemory < 16 * 1024 * 1024) {
totalMemory *= 2
} else {
totalMemory += 16 * 1024 * 1024
}
}
if (totalMemory !== TOTAL_MEMORY) {
Module.printErr("increasing TOTAL_MEMORY to " + totalMemory + " to be compliant with the asm.js spec (and given that TOTAL_STACK=" + TOTAL_STACK + ")");
TOTAL_MEMORY = totalMemory
}
assert(typeof Int32Array !== "undefined" && typeof Float64Array !== "undefined" && !!(new Int32Array(1))["subarray"] && !!(new Int32Array(1))["set"], "JS engine does not provide full typed array support");
var buffer;
buffer = new ArrayBuffer(TOTAL_MEMORY);
HEAP8 = new Int8Array(buffer);
HEAP16 = new Int16Array(buffer);
HEAP32 = new Int32Array(buffer);
HEAPU8 = new Uint8Array(buffer);
HEAPU16 = new Uint16Array(buffer);
HEAPU32 = new Uint32Array(buffer);
HEAPF32 = new Float32Array(buffer);
HEAPF64 = new Float64Array(buffer);
HEAP32[0] = 255;
assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, "Typed arrays 2 must be run on a little-endian system");
Module["HEAP"] = HEAP;
Module["buffer"] = buffer;
Module["HEAP8"] = HEAP8;
Module["HEAP16"] = HEAP16;
Module["HEAP32"] = HEAP32;
Module["HEAPU8"] = HEAPU8;
Module["HEAPU16"] = HEAPU16;
Module["HEAPU32"] = HEAPU32;
Module["HEAPF32"] = HEAPF32;
Module["HEAPF64"] = HEAPF64;
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback();
continue
}
var func = callback.func;
if (typeof func === "number") {
if (callback.arg === undefined) {
Runtime.dynCall("v", func)
} else {
Runtime.dynCall("vi", func, [callback.arg])
}
} else {
func(callback.arg === undefined ? null : callback.arg)
}
}
}
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATEXIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
var runtimeExited = false;
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift())
}
}
callRuntimeCallbacks(__ATPRERUN__)
}
function ensureInitRuntime() {
if (runtimeInitialized) return;
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__)
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__)
}
function exitRuntime() {
callRuntimeCallbacks(__ATEXIT__);
runtimeExited = true
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift())
}
}
callRuntimeCallbacks(__ATPOSTRUN__)
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb)
}
Module["addOnPreRun"] = addOnPreRun;
function addOnInit(cb) {
__ATINIT__.unshift(cb)
}
Module["addOnInit"] = addOnInit;
function addOnPreMain(cb) {
__ATMAIN__.unshift(cb)
}
Module["addOnPreMain"] = addOnPreMain;
function addOnExit(cb) {
__ATEXIT__.unshift(cb)
}
Module["addOnExit"] = addOnExit;
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb)
}
Module["addOnPostRun"] = addOnPostRun;
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
}
Module["intArrayFromString"] = intArrayFromString;
function intArrayToString(array) {
var ret = [];
for (var i = 0; i < array.length; i++) {
var chr = array[i];
if (chr > 255) {
chr &= 255
}
ret.push(String.fromCharCode(chr))
}
return ret.join("")
}
Module["intArrayToString"] = intArrayToString;
function writeStringToMemory(string, buffer, dontAddNull) {
var array = intArrayFromString(string, dontAddNull);
var i = 0;
while (i < array.length) {
var chr = array[i];
HEAP8[buffer + i >> 0] = chr;
i = i + 1
}
}
Module["writeStringToMemory"] = writeStringToMemory;
function writeArrayToMemory(array, buffer) {
for (var i = 0; i < array.length; i++) {
HEAP8[buffer++ >> 0] = array[i]
}
}
Module["writeArrayToMemory"] = writeArrayToMemory;
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; ++i) {