· 4 years ago · Mar 15, 2021, 07:36 PM
1var Module = (function() {
2 var _scriptDir = import.meta.url;
3
4 return (
5function(Module) {
6 Module = Module || {};
7
8var Module = (function() {
9 var _scriptDir =
10 import.meta.url;
11
12 return (
13 function(Module) {
14 Module = Module || {};
15
16 var Module = typeof Module !== "undefined" ? Module : {};
17 Module["locateFile"] = function(filename) {
18 return ENVIRONMENT_IS_NODE ? __dirname + "/" + filename : filename
19 };
20 var moduleOverrides = {};
21 var key;
22 for (key in Module) {
23 if (Module.hasOwnProperty(key)) {
24 moduleOverrides[key] = Module[key]
25 }
26 }
27 var arguments_ = [];
28 var thisProgram = "./this.program";
29 var quit_ = function(status, toThrow) {
30 throw toThrow
31 };
32 var ENVIRONMENT_IS_WEB = false;
33 var ENVIRONMENT_IS_WORKER = false;
34 var ENVIRONMENT_IS_NODE = false;
35 var ENVIRONMENT_HAS_NODE = false;
36 var ENVIRONMENT_IS_SHELL = false;
37 ENVIRONMENT_IS_WEB = typeof window === "object";
38 ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
39 ENVIRONMENT_HAS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string";
40 ENVIRONMENT_IS_NODE = ENVIRONMENT_HAS_NODE && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;
41 ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
42 var scriptDirectory = "";
43
44 function locateFile(path) {
45 if (Module["locateFile"]) {
46 return Module["locateFile"](path, scriptDirectory)
47 }
48 return scriptDirectory + path
49 }
50 var read_, readAsync, readBinary, setWindowTitle;
51 var nodeFS;
52 var nodePath;
53 if (ENVIRONMENT_IS_NODE) {
54 scriptDirectory = __dirname + "/";
55 read_ = function shell_read(filename, binary) {
56 if (!nodeFS) nodeFS = require("fs");
57 if (!nodePath) nodePath = require("path");
58 filename = nodePath["normalize"](filename);
59 return nodeFS["readFileSync"](filename, binary ? null : "utf8")
60 };
61 readBinary = function readBinary(filename) {
62 var ret = read_(filename, true);
63 if (!ret.buffer) {
64 ret = new Uint8Array(ret)
65 }
66 assert(ret.buffer);
67 return ret
68 };
69 if (process["argv"].length > 1) {
70 thisProgram = process["argv"][1].replace(/\\/g, "/")
71 }
72 arguments_ = process["argv"].slice(2);
73 process["on"]("uncaughtException", function(ex) {
74 if (!(ex instanceof ExitStatus)) {
75 throw ex
76 }
77 });
78 process["on"]("unhandledRejection", abort);
79 quit_ = function(status) {
80 process["exit"](status)
81 };
82 Module["inspect"] = function() {
83 return "[Emscripten Module object]"
84 }
85 } else if (ENVIRONMENT_IS_SHELL) {
86 if (typeof read != "undefined") {
87 read_ = function shell_read(f) {
88 return read(f)
89 }
90 }
91 readBinary = function readBinary(f) {
92 var data;
93 if (typeof readbuffer === "function") {
94 return new Uint8Array(readbuffer(f))
95 }
96 data = read(f, "binary");
97 assert(typeof data === "object");
98 return data
99 };
100 if (typeof scriptArgs != "undefined") {
101 arguments_ = scriptArgs
102 } else if (typeof arguments != "undefined") {
103 arguments_ = arguments
104 }
105 if (typeof quit === "function") {
106 quit_ = function(status) {
107 quit(status)
108 }
109 }
110 if (typeof print !== "undefined") {
111 if (typeof console === "undefined") console = {};
112 console.log = print;
113 console.warn = console.error = typeof printErr !== "undefined" ? printErr : print
114 }
115 } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
116 if (ENVIRONMENT_IS_WORKER) {
117 scriptDirectory = self.location.href
118 } else if (document.currentScript) {
119 scriptDirectory = document.currentScript.src
120 }
121 if (_scriptDir) {
122 scriptDirectory = _scriptDir
123 }
124 if (scriptDirectory.indexOf("blob:") !== 0) {
125 scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1)
126 } else {
127 scriptDirectory = ""
128 } {
129 read_ = function shell_read(url) {
130 var xhr = new XMLHttpRequest;
131 xhr.open("GET", url, false);
132 xhr.send(null);
133 return xhr.responseText
134 };
135 if (ENVIRONMENT_IS_WORKER) {
136 readBinary = function readBinary(url) {
137 var xhr = new XMLHttpRequest;
138 xhr.open("GET", url, false);
139 xhr.responseType = "arraybuffer";
140 xhr.send(null);
141 return new Uint8Array(xhr.response)
142 }
143 }
144 readAsync = function readAsync(url, onload, onerror) {
145 var xhr = new XMLHttpRequest;
146 xhr.open("GET", url, true);
147 xhr.responseType = "arraybuffer";
148 xhr.onload = function xhr_onload() {
149 if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
150 onload(xhr.response);
151 return
152 }
153 onerror()
154 };
155 xhr.onerror = onerror;
156 xhr.send(null)
157 }
158 }
159 setWindowTitle = function(title) {
160 document.title = title
161 }
162 } else {}
163 var out = Module["print"] || console.log.bind(console);
164 var err = Module["printErr"] || console.warn.bind(console);
165 for (key in moduleOverrides) {
166 if (moduleOverrides.hasOwnProperty(key)) {
167 Module[key] = moduleOverrides[key]
168 }
169 }
170 moduleOverrides = null;
171 if (Module["arguments"]) arguments_ = Module["arguments"];
172 if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
173 if (Module["quit"]) quit_ = Module["quit"];
174 var wasmBinary;
175 if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
176 var noExitRuntime;
177 if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
178 if (typeof WebAssembly !== "object") {
179 err("no native wasm support detected")
180 }
181 var wasmMemory;
182 var wasmTable = new WebAssembly.Table({
183 "initial": 7,
184 "maximum": 7 + 0,
185 "element": "anyfunc"
186 });
187 var ABORT = false;
188 var EXITSTATUS = 0;
189
190 function assert(condition, text) {
191 if (!condition) {
192 abort("Assertion failed: " + text)
193 }
194 }
195
196 function getCFunc(ident) {
197 var func = Module["_" + ident];
198 assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
199 return func
200 }
201
202 function ccall(ident, returnType, argTypes, args, opts) {
203 var toC = {
204 "string": function(str) {
205 var ret = 0;
206 if (str !== null && str !== undefined && str !== 0) {
207 var len = (str.length << 2) + 1;
208 ret = stackAlloc(len);
209 stringToUTF8(str, ret, len)
210 }
211 return ret
212 },
213 "array": function(arr) {
214 var ret = stackAlloc(arr.length);
215 writeArrayToMemory(arr, ret);
216 return ret
217 }
218 };
219
220 function convertReturnValue(ret) {
221 if (returnType === "string") return UTF8ToString(ret);
222 if (returnType === "boolean") return Boolean(ret);
223 return ret
224 }
225 var func = getCFunc(ident);
226 var cArgs = [];
227 var stack = 0;
228 if (args) {
229 for (var i = 0; i < args.length; i++) {
230 var converter = toC[argTypes[i]];
231 if (converter) {
232 if (stack === 0) stack = stackSave();
233 cArgs[i] = converter(args[i])
234 } else {
235 cArgs[i] = args[i]
236 }
237 }
238 }
239 var ret = func.apply(null, cArgs);
240 ret = convertReturnValue(ret);
241 if (stack !== 0) stackRestore(stack);
242 return ret
243 }
244
245 function cwrap(ident, returnType, argTypes, opts) {
246 argTypes = argTypes || [];
247 var numericArgs = argTypes.every(function(type) {
248 return type === "number"
249 });
250 var numericRet = returnType !== "string";
251 if (numericRet && numericArgs && !opts) {
252 return getCFunc(ident)
253 }
254 return function() {
255 return ccall(ident, returnType, argTypes, arguments, opts)
256 }
257 }
258 var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
259
260 function UTF8ArrayToString(u8Array, idx, maxBytesToRead) {
261 var endIdx = idx + maxBytesToRead;
262 var endPtr = idx;
263 while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr;
264 if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
265 return UTF8Decoder.decode(u8Array.subarray(idx, endPtr))
266 } else {
267 var str = "";
268 while (idx < endPtr) {
269 var u0 = u8Array[idx++];
270 if (!(u0 & 128)) {
271 str += String.fromCharCode(u0);
272 continue
273 }
274 var u1 = u8Array[idx++] & 63;
275 if ((u0 & 224) == 192) {
276 str += String.fromCharCode((u0 & 31) << 6 | u1);
277 continue
278 }
279 var u2 = u8Array[idx++] & 63;
280 if ((u0 & 240) == 224) {
281 u0 = (u0 & 15) << 12 | u1 << 6 | u2
282 } else {
283 u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u8Array[idx++] & 63
284 }
285 if (u0 < 65536) {
286 str += String.fromCharCode(u0)
287 } else {
288 var ch = u0 - 65536;
289 str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
290 }
291 }
292 }
293 return str
294 }
295
296 function UTF8ToString(ptr, maxBytesToRead) {
297 return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
298 }
299
300 function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
301 if (!(maxBytesToWrite > 0)) return 0;
302 var startIdx = outIdx;
303 var endIdx = outIdx + maxBytesToWrite - 1;
304 for (var i = 0; i < str.length; ++i) {
305 var u = str.charCodeAt(i);
306 if (u >= 55296 && u <= 57343) {
307 var u1 = str.charCodeAt(++i);
308 u = 65536 + ((u & 1023) << 10) | u1 & 1023
309 }
310 if (u <= 127) {
311 if (outIdx >= endIdx) break;
312 outU8Array[outIdx++] = u
313 } else if (u <= 2047) {
314 if (outIdx + 1 >= endIdx) break;
315 outU8Array[outIdx++] = 192 | u >> 6;
316 outU8Array[outIdx++] = 128 | u & 63
317 } else if (u <= 65535) {
318 if (outIdx + 2 >= endIdx) break;
319 outU8Array[outIdx++] = 224 | u >> 12;
320 outU8Array[outIdx++] = 128 | u >> 6 & 63;
321 outU8Array[outIdx++] = 128 | u & 63
322 } else {
323 if (outIdx + 3 >= endIdx) break;
324 outU8Array[outIdx++] = 240 | u >> 18;
325 outU8Array[outIdx++] = 128 | u >> 12 & 63;
326 outU8Array[outIdx++] = 128 | u >> 6 & 63;
327 outU8Array[outIdx++] = 128 | u & 63
328 }
329 }
330 outU8Array[outIdx] = 0;
331 return outIdx - startIdx
332 }
333
334 function stringToUTF8(str, outPtr, maxBytesToWrite) {
335 return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
336 }
337 var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
338
339 function writeArrayToMemory(array, buffer) {
340 HEAP8.set(array, buffer)
341 }
342 var WASM_PAGE_SIZE = 65536;
343 var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
344
345 function updateGlobalBufferAndViews(buf) {
346 buffer = buf;
347 Module["HEAP8"] = HEAP8 = new Int8Array(buf);
348 Module["HEAP16"] = HEAP16 = new Int16Array(buf);
349 Module["HEAP32"] = HEAP32 = new Int32Array(buf);
350 Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
351 Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
352 Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
353 Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
354 Module["HEAPF64"] = HEAPF64 = new Float64Array(buf)
355 }
356 var DYNAMIC_BASE = 5284544,
357 DYNAMICTOP_PTR = 41504;
358 var INITIAL_TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 16777216;
359 if (Module["wasmMemory"]) {
360 wasmMemory = Module["wasmMemory"]
361 } else {
362 wasmMemory = new WebAssembly.Memory({
363 "initial": INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE,
364 "maximum": INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE
365 })
366 }
367 if (wasmMemory) {
368 buffer = wasmMemory.buffer
369 }
370 INITIAL_TOTAL_MEMORY = buffer.byteLength;
371 updateGlobalBufferAndViews(buffer);
372 HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
373
374 function callRuntimeCallbacks(callbacks) {
375 while (callbacks.length > 0) {
376 var callback = callbacks.shift();
377 if (typeof callback == "function") {
378 callback();
379 continue
380 }
381 var func = callback.func;
382 if (typeof func === "number") {
383 if (callback.arg === undefined) {
384 Module["dynCall_v"](func)
385 } else {
386 Module["dynCall_vi"](func, callback.arg)
387 }
388 } else {
389 func(callback.arg === undefined ? null : callback.arg)
390 }
391 }
392 }
393 var __ATPRERUN__ = [];
394 var __ATINIT__ = [];
395 var __ATMAIN__ = [];
396 var __ATPOSTRUN__ = [];
397 var runtimeInitialized = false;
398
399 function preRun() {
400 if (Module["preRun"]) {
401 if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
402 while (Module["preRun"].length) {
403 addOnPreRun(Module["preRun"].shift())
404 }
405 }
406 callRuntimeCallbacks(__ATPRERUN__)
407 }
408
409 function initRuntime() {
410 runtimeInitialized = true;
411 callRuntimeCallbacks(__ATINIT__)
412 }
413
414 function preMain() {
415 callRuntimeCallbacks(__ATMAIN__)
416 }
417
418 function postRun() {
419 if (Module["postRun"]) {
420 if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
421 while (Module["postRun"].length) {
422 addOnPostRun(Module["postRun"].shift())
423 }
424 }
425 callRuntimeCallbacks(__ATPOSTRUN__)
426 }
427
428 function addOnPreRun(cb) {
429 __ATPRERUN__.unshift(cb)
430 }
431
432 function addOnPreMain(cb) {
433 __ATMAIN__.unshift(cb)
434 }
435
436 function addOnPostRun(cb) {
437 __ATPOSTRUN__.unshift(cb)
438 }
439 var Math_abs = Math.abs;
440 var runDependencies = 0;
441 var runDependencyWatcher = null;
442 var dependenciesFulfilled = null;
443
444 function addRunDependency(id) {
445 runDependencies++;
446 if (Module["monitorRunDependencies"]) {
447 Module["monitorRunDependencies"](runDependencies)
448 }
449 }
450
451 function removeRunDependency(id) {
452 runDependencies--;
453 if (Module["monitorRunDependencies"]) {
454 Module["monitorRunDependencies"](runDependencies)
455 }
456 if (runDependencies == 0) {
457 if (runDependencyWatcher !== null) {
458 clearInterval(runDependencyWatcher);
459 runDependencyWatcher = null
460 }
461 if (dependenciesFulfilled) {
462 var callback = dependenciesFulfilled;
463 dependenciesFulfilled = null;
464 callback()
465 }
466 }
467 }
468 Module["preloadedImages"] = {};
469 Module["preloadedAudios"] = {};
470
471 function abort(what) {
472 if (Module["onAbort"]) {
473 Module["onAbort"](what)
474 }
475 what += "";
476 out(what);
477 err(what);
478 ABORT = true;
479 EXITSTATUS = 1;
480 what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
481 throw new WebAssembly.RuntimeError(what)
482 }
483 var dataURIPrefix = "data:application/octet-stream;base64,";
484
485 function isDataURI(filename) {
486 return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0
487 }
488 var wasmBinaryFile = "opus-stream-decoder.wasm";
489 if (!isDataURI(wasmBinaryFile)) {
490 wasmBinaryFile = locateFile(wasmBinaryFile)
491 }
492
493 function getBinary() {
494 try {
495 if (wasmBinary) {
496 return new Uint8Array(wasmBinary)
497 }
498 if (readBinary) {
499 return readBinary(wasmBinaryFile)
500 } else {
501 throw "both async and sync fetching of the wasm failed"
502 }
503 } catch (err) {
504 abort(err)
505 }
506 }
507
508 function getBinaryPromise() {
509 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function") {
510 return fetch(wasmBinaryFile, {
511 credentials: "same-origin"
512 }).then(function(response) {
513 if (!response["ok"]) {
514 throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
515 }
516 return response["arrayBuffer"]()
517 }).catch(function() {
518 return getBinary()
519 })
520 }
521 return new Promise(function(resolve, reject) {
522 resolve(getBinary())
523 })
524 }
525
526 function createWasm() {
527 var info = {
528 "env": asmLibraryArg,
529 "wasi_snapshot_preview1": asmLibraryArg
530 };
531
532 function receiveInstance(instance, module) {
533 var exports = instance.exports;
534 Module["asm"] = exports;
535 removeRunDependency("wasm-instantiate")
536 }
537 addRunDependency("wasm-instantiate");
538
539 function receiveInstantiatedSource(output) {
540 receiveInstance(output["instance"])
541 }
542
543 function instantiateArrayBuffer(receiver) {
544 return getBinaryPromise().then(function(binary) {
545 return WebAssembly.instantiate(binary, info)
546 }).then(receiver, function(reason) {
547 err("failed to asynchronously prepare wasm: " + reason);
548 abort(reason)
549 })
550 }
551
552 function instantiateAsync() {
553 if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
554 fetch(wasmBinaryFile, {
555 credentials: "same-origin"
556 }).then(function(response) {
557 var result = WebAssembly.instantiateStreaming(response, info);
558 return result.then(receiveInstantiatedSource, function(reason) {
559 err("wasm streaming compile failed: " + reason);
560 err("falling back to ArrayBuffer instantiation");
561 instantiateArrayBuffer(receiveInstantiatedSource)
562 })
563 })
564 } else {
565 return instantiateArrayBuffer(receiveInstantiatedSource)
566 }
567 }
568 if (Module["instantiateWasm"]) {
569 try {
570 var exports = Module["instantiateWasm"](info, receiveInstance);
571 return exports
572 } catch (e) {
573 err("Module.instantiateWasm callback failed with error: " + e);
574 return false
575 }
576 }
577 instantiateAsync();
578 return {}
579 }
580 __ATINIT__.push({
581 func: function() {
582 ___wasm_call_ctors()
583 }
584 });
585 var _abs = Math_abs;
586
587 function _emscripten_memcpy_big(dest, src, num) {
588 HEAPU8.set(HEAPU8.subarray(src, src + num), dest)
589 }
590
591 function abortOnCannotGrowMemory(requestedSize) {
592 abort("OOM")
593 }
594
595 function _emscripten_resize_heap(requestedSize) {
596 abortOnCannotGrowMemory(requestedSize)
597 }
598 var PATH = {
599 splitPath: function(filename) {
600 var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
601 return splitPathRe.exec(filename).slice(1)
602 },
603 normalizeArray: function(parts, allowAboveRoot) {
604 var up = 0;
605 for (var i = parts.length - 1; i >= 0; i--) {
606 var last = parts[i];
607 if (last === ".") {
608 parts.splice(i, 1)
609 } else if (last === "..") {
610 parts.splice(i, 1);
611 up++
612 } else if (up) {
613 parts.splice(i, 1);
614 up--
615 }
616 }
617 if (allowAboveRoot) {
618 for (; up; up--) {
619 parts.unshift("..")
620 }
621 }
622 return parts
623 },
624 normalize: function(path) {
625 var isAbsolute = path.charAt(0) === "/",
626 trailingSlash = path.substr(-1) === "/";
627 path = PATH.normalizeArray(path.split("/").filter(function(p) {
628 return !!p
629 }), !isAbsolute).join("/");
630 if (!path && !isAbsolute) {
631 path = "."
632 }
633 if (path && trailingSlash) {
634 path += "/"
635 }
636 return (isAbsolute ? "/" : "") + path
637 },
638 dirname: function(path) {
639 var result = PATH.splitPath(path),
640 root = result[0],
641 dir = result[1];
642 if (!root && !dir) {
643 return "."
644 }
645 if (dir) {
646 dir = dir.substr(0, dir.length - 1)
647 }
648 return root + dir
649 },
650 basename: function(path) {
651 if (path === "/") return "/";
652 var lastSlash = path.lastIndexOf("/");
653 if (lastSlash === -1) return path;
654 return path.substr(lastSlash + 1)
655 },
656 extname: function(path) {
657 return PATH.splitPath(path)[3]
658 },
659 join: function() {
660 var paths = Array.prototype.slice.call(arguments, 0);
661 return PATH.normalize(paths.join("/"))
662 },
663 join2: function(l, r) {
664 return PATH.normalize(l + "/" + r)
665 }
666 };
667 var SYSCALLS = {
668 buffers: [null, [],
669 []
670 ],
671 printChar: function(stream, curr) {
672 var buffer = SYSCALLS.buffers[stream];
673 if (curr === 0 || curr === 10) {
674 (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
675 buffer.length = 0
676 } else {
677 buffer.push(curr)
678 }
679 },
680 varargs: 0,
681 get: function(varargs) {
682 SYSCALLS.varargs += 4;
683 var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
684 return ret
685 },
686 getStr: function() {
687 var ret = UTF8ToString(SYSCALLS.get());
688 return ret
689 },
690 get64: function() {
691 var low = SYSCALLS.get(),
692 high = SYSCALLS.get();
693 return low
694 },
695 getZero: function() {
696 SYSCALLS.get()
697 }
698 };
699
700 function _fd_close(fd) {
701 try {
702 return 0
703 } catch (e) {
704 if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
705 return e.errno
706 }
707 }
708
709 function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
710 try {
711 return 0
712 } catch (e) {
713 if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
714 return e.errno
715 }
716 }
717
718 function _fd_write(fd, iov, iovcnt, pnum) {
719 try {
720 var num = 0;
721 for (var i = 0; i < iovcnt; i++) {
722 var ptr = HEAP32[iov + i * 8 >> 2];
723 var len = HEAP32[iov + (i * 8 + 4) >> 2];
724 for (var j = 0; j < len; j++) {
725 SYSCALLS.printChar(fd, HEAPU8[ptr + j])
726 }
727 num += len
728 }
729 HEAP32[pnum >> 2] = num;
730 return 0
731 } catch (e) {
732 if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
733 return e.errno
734 }
735 }
736 var asmLibraryArg = {
737 "a": _abs,
738 "c": _emscripten_memcpy_big,
739 "d": _emscripten_resize_heap,
740 "f": _fd_close,
741 "b": _fd_seek,
742 "e": _fd_write,
743 "memory": wasmMemory,
744 "table": wasmTable
745 };
746 var asm = createWasm();
747 Module["asm"] = asm;
748 var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
749 return Module["asm"]["g"].apply(null, arguments)
750 };
751 var _opus_chunkdecoder_version = Module["_opus_chunkdecoder_version"] = function() {
752 return Module["asm"]["h"].apply(null, arguments)
753 };
754 var _opus_chunkdecoder_enqueue = Module["_opus_chunkdecoder_enqueue"] = function() {
755 return Module["asm"]["i"].apply(null, arguments)
756 };
757 var _opus_chunkdecoder_decode_float_stereo_deinterleaved = Module["_opus_chunkdecoder_decode_float_stereo_deinterleaved"] = function() {
758 return Module["asm"]["j"].apply(null, arguments)
759 };
760 var _opus_chunkdecoder_create = Module["_opus_chunkdecoder_create"] = function() {
761 return Module["asm"]["k"].apply(null, arguments)
762 };
763 var _malloc = Module["_malloc"] = function() {
764 return Module["asm"]["l"].apply(null, arguments)
765 };
766 var _opus_chunkdecoder_free = Module["_opus_chunkdecoder_free"] = function() {
767 return Module["asm"]["m"].apply(null, arguments)
768 };
769 var _free = Module["_free"] = function() {
770 return Module["asm"]["n"].apply(null, arguments)
771 };
772 var _opus_get_version_string = Module["_opus_get_version_string"] = function() {
773 return Module["asm"]["o"].apply(null, arguments)
774 };
775 var stackSave = Module["stackSave"] = function() {
776 return Module["asm"]["p"].apply(null, arguments)
777 };
778 var stackAlloc = Module["stackAlloc"] = function() {
779 return Module["asm"]["q"].apply(null, arguments)
780 };
781 var stackRestore = Module["stackRestore"] = function() {
782 return Module["asm"]["r"].apply(null, arguments)
783 };
784 Module["asm"] = asm;
785 Module["cwrap"] = cwrap;
786 var calledRun;
787 Module["then"] = function(func) {
788 if (calledRun) {
789 func(Module)
790 } else {
791 var old = Module["onRuntimeInitialized"];
792 Module["onRuntimeInitialized"] = function() {
793 if (old) old();
794 func(Module)
795 }
796 }
797 return Module
798 };
799
800 function ExitStatus(status) {
801 this.name = "ExitStatus";
802 this.message = "Program terminated with exit(" + status + ")";
803 this.status = status
804 }
805 dependenciesFulfilled = function runCaller() {
806 if (!calledRun) run();
807 if (!calledRun) dependenciesFulfilled = runCaller
808 };
809
810 function run(args) {
811 args = args || arguments_;
812 if (runDependencies > 0) {
813 return
814 }
815 preRun();
816 if (runDependencies > 0) return;
817
818 function doRun() {
819 if (calledRun) return;
820 calledRun = true;
821 if (ABORT) return;
822 initRuntime();
823 preMain();
824 if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
825 postRun()
826 }
827 if (Module["setStatus"]) {
828 Module["setStatus"]("Running...");
829 setTimeout(function() {
830 setTimeout(function() {
831 Module["setStatus"]("")
832 }, 1);
833 doRun()
834 }, 1)
835 } else {
836 doRun()
837 }
838 }
839 Module["run"] = run;
840 if (Module["preInit"]) {
841 if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
842 while (Module["preInit"].length > 0) {
843 Module["preInit"].pop()()
844 }
845 }
846 noExitRuntime = true;
847 run();
848 Module["OpusStreamDecoder"] = OpusStreamDecoder;
849 if ("undefined" !== typeof global && exports) {
850 module.exports.OpusStreamDecoder = OpusStreamDecoder
851 }
852
853 function OpusStreamDecodedAudio(left, right, samplesDecoded) {
854 this.left = left;
855 this.right = right;
856 this.samplesDecoded = samplesDecoded;
857 this.sampleRate = 48e3
858 }
859
860 function OpusStreamDecoder(options) {
861 if ("function" !== typeof options.onDecode) throw Error("onDecode callback is required.");
862 Object.defineProperty(this, "onDecode", {
863 value: options.onDecode
864 })
865 }
866 OpusStreamDecoder.prototype.ready = new Promise(function(resolve, reject) {
867 addOnPreMain(function() {
868 var api = {
869 malloc: cwrap("malloc", "number", ["number"]),
870 free: cwrap("free", null, ["number"]),
871 HEAPU8: HEAPU8,
872 HEAPF32: HEAPF32,
873 libopusVersion: cwrap("opus_get_version_string", "string", []),
874 decoderVersion: cwrap("opus_chunkdecoder_version", "string", []),
875 createDecoder: cwrap("opus_chunkdecoder_create", null, []),
876 freeDecoder: cwrap("opus_chunkdecoder_free", null, ["number"]),
877 enqueue: cwrap("opus_chunkdecoder_enqueue", null, ["number", "number", "number"]),
878 decode: cwrap("opus_chunkdecoder_decode_float_stereo_deinterleaved", "number", ["number", "number", "number", "number"])
879 };
880 Object.freeze(api);
881 Object.defineProperty(OpusStreamDecoder.prototype, "api", {
882 value: api
883 });
884 resolve()
885 })
886 });
887 OpusStreamDecoder.prototype.decode = function(uint8array) {
888 if (!(uint8array instanceof Uint8Array)) throw Error("Data to decode must be Uint8Array");
889 if (!this._decoderPointer) {
890 this._decoderPointer = this.api.createDecoder()
891 }
892 var srcPointer, decodedInterleavedPtr, decodedInterleavedArry, decodedLeftPtr, decodedLeftArry, decodedRightPtr, decodedRightArry;
893 try {
894 var decodedPcmSize = 120 * 48 * 2;
895 [decodedInterleavedPtr, decodedInterleavedArry] = this.createOutputArray(decodedPcmSize);
896 [decodedLeftPtr, decodedLeftArry] = this.createOutputArray(decodedPcmSize / 2);
897 [decodedRightPtr, decodedRightArry] = this.createOutputArray(decodedPcmSize / 2);
898 var sendMax = 16 * 1024,
899 sendStart = 0,
900 sendSize;
901 var srcLen = uint8array.byteLength;
902 srcPointer = this.api.malloc(uint8array.BYTES_PER_ELEMENT * sendMax);
903 while (sendStart < srcLen) {
904 sendSize = Math.min(sendMax, srcLen - sendStart);
905 this.api.HEAPU8.set(uint8array.subarray(sendStart, sendStart + sendSize), srcPointer);
906 sendStart += sendSize;
907 if (!this.api.enqueue(this._decoderPointer, srcPointer, sendSize)) throw Error("Could not enqueue bytes for decoding. You may also have invalid Ogg Opus file.");
908 var samplesDecoded, totalSamplesDecoded = 0;
909 while (samplesDecoded = this.api.decode(this._decoderPointer, decodedInterleavedPtr, decodedPcmSize, decodedLeftPtr, decodedRightPtr)) {
910 totalSamplesDecoded += samplesDecoded;
911 this.onDecode(new OpusStreamDecodedAudio(decodedLeftArry.slice(0, samplesDecoded), decodedRightArry.slice(0, samplesDecoded), samplesDecoded))
912 }
913 }
914 } catch (e) {
915 throw e
916 } finally {
917 this.api.free(srcPointer);
918 this.api.free(decodedInterleavedPtr);
919 this.api.free(decodedLeftPtr);
920 this.api.free(decodedRightPtr)
921 }
922 };
923 OpusStreamDecoder.prototype.free = function() {
924 if (this._decoderPointer) {
925 this.api.freeDecoder(this._decoderPointer)
926 }
927 };
928 Object.defineProperty(OpusStreamDecoder.prototype, "createOutputArray", {
929 value: function(length) {
930 var pointer = this.api.malloc(Float32Array.BYTES_PER_ELEMENT * length);
931 var array = new Float32Array(this.api.HEAPF32.buffer, pointer, length);
932 return [pointer, array]
933 }
934 });
935
936
937 return Module
938 }
939 );
940})();
941export default Module;
942
943 return Module
944}
945);
946})();
947export default Module;