mirror of
https://github.com/parabirb/freeremote-client.git
synced 2026-02-19 06:23:53 -05:00
34699 lines
1.0 MiB
34699 lines
1.0 MiB
|
|
|
|
// The Module object: Our interface to the outside world. We import
|
|
// and export values on it. There are various ways Module can be used:
|
|
// 1. Not defined. We create it here
|
|
// 2. A function parameter, function(Module) { ..generated code.. }
|
|
// 3. pre-run appended it, var Module = {}; ..generated code..
|
|
// 4. External script tag defines var Module.
|
|
// We need to check if Module already exists (e.g. case 3 above).
|
|
// Substitution will be replaced with actual code on later stage of the build,
|
|
// this way Closure Compiler will not mangle it (e.g. case 4. above).
|
|
// Note that if you want to run closure, and also to use Module
|
|
// after the generated code, you will need to define var Module = {};
|
|
// before the code. Then that object will be used in the code, and you
|
|
// can continue to use Module afterwards as well.
|
|
var Module = typeof Module !== 'undefined' ? Module : {};
|
|
|
|
// --pre-jses are emitted after the Module integration code, so that they can
|
|
// refer to Module (if they choose; they can also define Module)
|
|
|
|
(function (root, factory, globalExport) {
|
|
|
|
var lib, env;
|
|
if (typeof define === 'function' && define.amd) {
|
|
// AMD. Register as an anonymous module.
|
|
define(['require'], function (req) {
|
|
lib = factory(root, req);
|
|
return lib;
|
|
});
|
|
} else if (typeof module === 'object' && module.exports) {
|
|
// Node. Does not work with strict CommonJS, but
|
|
// only CommonJS-like environments that support module.exports,
|
|
// like Node.
|
|
|
|
// use process.env (if available) for reading Opus environment settings:
|
|
env = typeof process !== 'undefined' && process && process.env? process.env : root;
|
|
lib = factory(env, module.require);
|
|
module.exports = lib;
|
|
} else {
|
|
// Browser globals
|
|
lib = factory(root);
|
|
root[globalExport] = lib;
|
|
}
|
|
|
|
}(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : this, function (global, require) {
|
|
'use strict';
|
|
|
|
var Module = {};
|
|
Module['isReady'] = false;
|
|
Module['onready'] = null;
|
|
Module['onRuntimeInitialized'] = function(){
|
|
Module['isReady'] = true;
|
|
if(Module['onready']) setTimeout(Module['onready'], 0);
|
|
};
|
|
|
|
if(global && global.OPUS_SCRIPT_LOCATION){
|
|
Module['locateFile'] = function(fileName){
|
|
var path = global.OPUS_SCRIPT_LOCATION || '';
|
|
if(path[fileName]) return path[fileName];
|
|
path += path && !/\/$/.test(path)? '/' : '';
|
|
return path + fileName;
|
|
};
|
|
}
|
|
|
|
|
|
|
|
// Sometimes an existing Module object exists with properties
|
|
// meant to overwrite the default module functionality. Here
|
|
// we collect those properties and reapply _after_ we configure
|
|
// the current environment's defaults to avoid having to be so
|
|
// defensive during initialization.
|
|
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;
|
|
};
|
|
|
|
// Determine the runtime environment we are in. You can customize this by
|
|
// setting the ENVIRONMENT setting at compile time (see settings.js).
|
|
|
|
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';
|
|
// N.b. Electron.js environment is simultaneously a NODE-environment, but
|
|
// also a web environment.
|
|
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;
|
|
|
|
// `/` should be present at the end if `scriptDirectory` is not empty
|
|
var scriptDirectory = '';
|
|
function locateFile(path) {
|
|
if (Module['locateFile']) {
|
|
return Module['locateFile'](path, scriptDirectory);
|
|
}
|
|
return scriptDirectory + path;
|
|
}
|
|
|
|
// Hooks that are implemented differently in different runtime environments.
|
|
var read_,
|
|
readAsync,
|
|
readBinary,
|
|
setWindowTitle;
|
|
|
|
var nodeFS;
|
|
var nodePath;
|
|
|
|
if (ENVIRONMENT_IS_NODE) {
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
scriptDirectory = require('path').dirname(scriptDirectory) + '/';
|
|
} else {
|
|
scriptDirectory = __dirname + '/';
|
|
}
|
|
|
|
// include: node_shell_read.js
|
|
|
|
|
|
read_ = function shell_read(filename, binary) {
|
|
var ret = tryParseAsDataURI(filename);
|
|
if (ret) {
|
|
return binary ? ret : ret.toString();
|
|
}
|
|
if (!nodeFS) nodeFS = require('fs');
|
|
if (!nodePath) nodePath = require('path');
|
|
filename = nodePath['normalize'](filename);
|
|
return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
|
|
};
|
|
|
|
readBinary = function readBinary(filename) {
|
|
var ret = read_(filename, true);
|
|
if (!ret.buffer) {
|
|
ret = new Uint8Array(ret);
|
|
}
|
|
assert(ret.buffer);
|
|
return ret;
|
|
};
|
|
|
|
// end include: node_shell_read.js
|
|
if (process['argv'].length > 1) {
|
|
thisProgram = process['argv'][1].replace(/\\/g, '/');
|
|
}
|
|
|
|
arguments_ = process['argv'].slice(2);
|
|
|
|
if (typeof module !== 'undefined') {
|
|
module['exports'] = Module;
|
|
}
|
|
|
|
process['on']('uncaughtException', function(ex) {
|
|
// suppress ExitStatus exceptions from showing an error
|
|
if (!(ex instanceof ExitStatus)) {
|
|
throw ex;
|
|
}
|
|
});
|
|
|
|
process['on']('unhandledRejection', abort);
|
|
|
|
quit_ = function(status) {
|
|
process['exit'](status);
|
|
};
|
|
|
|
Module['inspect'] = function () { return '[Emscripten Module object]'; };
|
|
|
|
} else
|
|
if (ENVIRONMENT_IS_SHELL) {
|
|
|
|
if (typeof read != 'undefined') {
|
|
read_ = function shell_read(f) {
|
|
var data = tryParseAsDataURI(f);
|
|
if (data) {
|
|
return intArrayToString(data);
|
|
}
|
|
return read(f);
|
|
};
|
|
}
|
|
|
|
readBinary = function readBinary(f) {
|
|
var data;
|
|
data = tryParseAsDataURI(f);
|
|
if (data) {
|
|
return data;
|
|
}
|
|
if (typeof readbuffer === 'function') {
|
|
return new Uint8Array(readbuffer(f));
|
|
}
|
|
data = read(f, 'binary');
|
|
assert(typeof data === 'object');
|
|
return data;
|
|
};
|
|
|
|
if (typeof scriptArgs != 'undefined') {
|
|
arguments_ = scriptArgs;
|
|
} else if (typeof arguments != 'undefined') {
|
|
arguments_ = arguments;
|
|
}
|
|
|
|
if (typeof quit === 'function') {
|
|
quit_ = function(status) {
|
|
quit(status);
|
|
};
|
|
}
|
|
|
|
if (typeof print !== 'undefined') {
|
|
// Prefer to use print/printErr where they exist, as they usually work better.
|
|
if (typeof console === 'undefined') console = /** @type{!Console} */({});
|
|
console.log = /** @type{!function(this:Console, ...*): undefined} */ (print);
|
|
console.warn = console.error = /** @type{!function(this:Console, ...*): undefined} */ (typeof printErr !== 'undefined' ? printErr : print);
|
|
}
|
|
|
|
} else
|
|
|
|
// Note that this includes Node.js workers when relevant (pthreads is enabled).
|
|
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
|
|
// ENVIRONMENT_IS_NODE.
|
|
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
|
|
if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled
|
|
scriptDirectory = self.location.href;
|
|
} else if (typeof document !== 'undefined' && document.currentScript) { // web
|
|
scriptDirectory = document.currentScript.src;
|
|
}
|
|
// blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
|
|
// otherwise, slice off the final part of the url to find the script directory.
|
|
// if scriptDirectory does not contain a slash, lastIndexOf will return -1,
|
|
// and scriptDirectory will correctly be replaced with an empty string.
|
|
if (scriptDirectory.indexOf('blob:') !== 0) {
|
|
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1);
|
|
} else {
|
|
scriptDirectory = '';
|
|
}
|
|
|
|
// Differentiate the Web Worker from the Node Worker case, as reading must
|
|
// be done differently.
|
|
{
|
|
|
|
// include: web_or_worker_shell_read.js
|
|
|
|
|
|
read_ = function(url) {
|
|
try {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, false);
|
|
xhr.send(null);
|
|
return xhr.responseText;
|
|
} catch (err) {
|
|
var data = tryParseAsDataURI(url);
|
|
if (data) {
|
|
return intArrayToString(data);
|
|
}
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
readBinary = function(url) {
|
|
try {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, false);
|
|
xhr.responseType = 'arraybuffer';
|
|
xhr.send(null);
|
|
return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));
|
|
} catch (err) {
|
|
var data = tryParseAsDataURI(url);
|
|
if (data) {
|
|
return data;
|
|
}
|
|
throw err;
|
|
}
|
|
};
|
|
}
|
|
|
|
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)) { // file URLs can return 0
|
|
onload(xhr.response);
|
|
return;
|
|
}
|
|
var data = tryParseAsDataURI(url);
|
|
if (data) {
|
|
onload(data.buffer);
|
|
return;
|
|
}
|
|
onerror();
|
|
};
|
|
xhr.onerror = onerror;
|
|
xhr.send(null);
|
|
};
|
|
|
|
// end include: web_or_worker_shell_read.js
|
|
}
|
|
|
|
setWindowTitle = function(title) { document.title = title };
|
|
} else
|
|
{
|
|
}
|
|
|
|
// Set up the out() and err() hooks, which are how we can print to stdout or
|
|
// stderr, respectively.
|
|
var out = Module['print'] || console.log.bind(console);
|
|
var err = Module['printErr'] || console.warn.bind(console);
|
|
|
|
// Merge back in the overrides
|
|
for (key in moduleOverrides) {
|
|
if (moduleOverrides.hasOwnProperty(key)) {
|
|
Module[key] = moduleOverrides[key];
|
|
}
|
|
}
|
|
// Free the object hierarchy contained in the overrides, this lets the GC
|
|
// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
|
|
moduleOverrides = null;
|
|
|
|
// Emit code to handle expected values on the Module object. This applies Module.x
|
|
// to the proper local x. This has two benefits: first, we only emit it if it is
|
|
// expected to arrive, and second, by using a local everywhere else that can be
|
|
// minified.
|
|
|
|
if (Module['arguments']) arguments_ = Module['arguments'];
|
|
|
|
if (Module['thisProgram']) thisProgram = Module['thisProgram'];
|
|
|
|
if (Module['quit']) quit_ = Module['quit'];
|
|
|
|
// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
|
|
|
|
|
|
|
|
|
|
var STACK_ALIGN = 16;
|
|
|
|
function alignMemory(size, factor) {
|
|
if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default
|
|
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; // A pointer
|
|
} 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);
|
|
}
|
|
}
|
|
|
|
// include: runtime_functions.js
|
|
|
|
|
|
// Wraps a JS function as a wasm function with a given signature.
|
|
function convertJsFunctionToWasm(func, sig) {
|
|
return func;
|
|
}
|
|
|
|
var freeTableIndexes = [];
|
|
|
|
// Weak map of functions in the table to their indexes, created on first use.
|
|
var functionsInTableMap;
|
|
|
|
function getEmptyTableSlot() {
|
|
// Reuse a free index if there is one, otherwise grow.
|
|
if (freeTableIndexes.length) {
|
|
return freeTableIndexes.pop();
|
|
}
|
|
// Grow the table
|
|
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;
|
|
}
|
|
|
|
// Add a wasm function to the table.
|
|
function addFunctionWasm(func, sig) {
|
|
// Check if the function is already in the table, to ensure each function
|
|
// gets a unique index. First, create the map if this is the first use.
|
|
if (!functionsInTableMap) {
|
|
functionsInTableMap = new WeakMap();
|
|
for (var i = 0; i < wasmTable.length; i++) {
|
|
var item = wasmTable.get(i);
|
|
// Ignore null values.
|
|
if (item) {
|
|
functionsInTableMap.set(item, i);
|
|
}
|
|
}
|
|
}
|
|
if (functionsInTableMap.has(func)) {
|
|
return functionsInTableMap.get(func);
|
|
}
|
|
|
|
// It's not in the table, add it now.
|
|
|
|
var ret = getEmptyTableSlot();
|
|
|
|
// Set the new value.
|
|
try {
|
|
// Attempting to call this with JS function will cause of table.set() to fail
|
|
wasmTable.set(ret, func);
|
|
} catch (err) {
|
|
if (!(err instanceof TypeError)) {
|
|
throw err;
|
|
}
|
|
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);
|
|
}
|
|
|
|
// 'sig' parameter is required for the llvm backend but only when func is not
|
|
// already a WebAssembly function.
|
|
function addFunction(func, sig) {
|
|
|
|
return addFunctionWasm(func, sig);
|
|
}
|
|
|
|
// end include: runtime_functions.js
|
|
// include: runtime_debug.js
|
|
|
|
|
|
// end include: runtime_debug.js
|
|
function makeBigInt(low, high, unsigned) {
|
|
return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));
|
|
}
|
|
|
|
var tempRet0 = 0;
|
|
|
|
var setTempRet0 = function(value) {
|
|
tempRet0 = value;
|
|
};
|
|
|
|
var getTempRet0 = function() {
|
|
return tempRet0;
|
|
};
|
|
|
|
|
|
|
|
// === Preamble library stuff ===
|
|
|
|
// Documentation for the public APIs defined in this file must be updated in:
|
|
// site/source/docs/api_reference/preamble.js.rst
|
|
// A prebuilt local version of the documentation is available at:
|
|
// site/build/text/docs/api_reference/preamble.js.txt
|
|
// You can also build docs locally as HTML or other formats in site/
|
|
// An online HTML version (which may be of a different version of Emscripten)
|
|
// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
|
|
|
|
var wasmBinary;
|
|
if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
|
|
var noExitRuntime = Module['noExitRuntime'] || true;
|
|
|
|
// include: wasm2js.js
|
|
|
|
|
|
// wasm2js.js - enough of a polyfill for the WebAssembly object so that we can load
|
|
// wasm2js code that way.
|
|
|
|
// Emit "var WebAssembly" if definitely using wasm2js. Otherwise, in MAYBE_WASM2JS
|
|
// mode, we can't use a "var" since it would prevent normal wasm from working.
|
|
/** @suppress{duplicate, const} */
|
|
var
|
|
WebAssembly = {
|
|
// Note that we do not use closure quoting (this['buffer'], etc.) on these
|
|
// functions, as they are just meant for internal use. In other words, this is
|
|
// not a fully general polyfill.
|
|
Memory: function(opts) {
|
|
this.buffer = new ArrayBuffer(opts['initial'] * 65536);
|
|
},
|
|
|
|
Module: function(binary) {
|
|
// TODO: use the binary and info somehow - right now the wasm2js output is embedded in
|
|
// the main JS
|
|
},
|
|
|
|
Instance: function(module, info) {
|
|
// TODO: use the module and info somehow - right now the wasm2js output is embedded in
|
|
// the main JS
|
|
// This will be replaced by the actual wasm2js code.
|
|
this.exports = (
|
|
// EMSCRIPTEN_START_ASM
|
|
function instantiate(asmLibraryArg) {
|
|
function Table(ret) {
|
|
// grow method not included; table is not growable
|
|
ret.set = function(i, func) {
|
|
this[i] = func;
|
|
};
|
|
ret.get = function(i) {
|
|
return this[i];
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
var bufferView;
|
|
var base64ReverseLookup = new Uint8Array(123/*'z'+1*/);
|
|
for (var i = 25; i >= 0; --i) {
|
|
base64ReverseLookup[48+i] = 52+i; // '0-9'
|
|
base64ReverseLookup[65+i] = i; // 'A-Z'
|
|
base64ReverseLookup[97+i] = 26+i; // 'a-z'
|
|
}
|
|
base64ReverseLookup[43] = 62; // '+'
|
|
base64ReverseLookup[47] = 63; // '/'
|
|
/** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */
|
|
function base64DecodeToExistingUint8Array(uint8Array, offset, b64) {
|
|
var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '=');
|
|
for (; i < bLength; i += 4) {
|
|
b1 = base64ReverseLookup[b64.charCodeAt(i+1)];
|
|
b2 = base64ReverseLookup[b64.charCodeAt(i+2)];
|
|
uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4;
|
|
if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2;
|
|
if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)];
|
|
}
|
|
}
|
|
function initActiveSegments(imports) {
|
|
base64DecodeToExistingUint8Array(bufferView, 1025, "QAAAbCIAAEIPAAASBgAATQIAANs=");
|
|
base64DecodeToExistingUint8Array(bufferView, 1056, "7QAAAJkAAABJAAAAHgAAAAwAAAAH");
|
|
base64DecodeToExistingUint8Array(bufferView, 1089, "QAAAk10AAL1wAADteQAAsn0AACR/AABIzQAALSsgICAwWDB4AChudWxsKQAAAAARAAoAERERAAAAAAUAAAAAAAAJAAAAAAsAAAAAAAAAABEADwoREREDCgcAAQAJCwsAAAkGCwAACwAGEQAAABEREQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1217, "CwAAAAAAAAAAEQAKChEREQAKAAACAAkLAAAACQALAAAL");
|
|
base64DecodeToExistingUint8Array(bufferView, 1275, "DA==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1287, "DAAAAAAMAAAAAAkMAAAAAAAMAAAM");
|
|
base64DecodeToExistingUint8Array(bufferView, 1333, "Dg==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1345, "DQAAAAQNAAAAAAkOAAAAAAAOAAAO");
|
|
base64DecodeToExistingUint8Array(bufferView, 1391, "EA==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1403, "DwAAAAAPAAAAAAkQAAAAAAAQAAAQAAASAAAAEhIS");
|
|
base64DecodeToExistingUint8Array(bufferView, 1458, "EgAAABISEgAAAAAAAAk=");
|
|
base64DecodeToExistingUint8Array(bufferView, 1507, "Cw==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1519, "CgAAAAAKAAAAAAkLAAAAAAALAAAL");
|
|
base64DecodeToExistingUint8Array(bufferView, 1565, "DA==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1577, "DAAAAAAMAAAAAAkMAAAAAAAMAAAMAAAwMTIzNDU2Nzg5QUJDREVGRmF0YWwgKGludGVybmFsKSBlcnJvciBpbiAlcywgbGluZSAlZDogJXMKAGFzc2VydGlvbiBmYWlsZWQ6IDAAY2VsdC9jZWx0LmMAAAAAAAAAAJ0+AEBePgDABD4AgO0+AECJPgAAAAAAwEw/AADNPQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 1745, "/wD/AP8A/wD/AP4BAAH/AP4A/QIAAf8A/gD9AwAB/2Fzc2VydGlvbiBmYWlsZWQ6IE1BWF9GUkFNRV9MRU5HVEggPj0gcHNFbmNDLT5mcmFtZV9sZW5ndGgAc2lsay9WQUQuYwBhc3NlcnRpb24gZmFpbGVkOiBwc0VuY0MtPmZyYW1lX2xlbmd0aCA9PSA4ICogc2lsa19SU0hJRlQoIHBzRW5jQy0+ZnJhbWVfbGVuZ3RoLCAzICkAAAAAAAAwdQAAcBcAACDR//8g0f//YXNzZXJ0aW9uIGZhaWxlZDogZW5jQ29udHJvbCAhPSBOVUxMAHNpbGsvY2hlY2tfY29udHJvbF9pbnB1dC5jAGFzc2VydGlvbiBmYWlsZWQ6IDA=");
|
|
base64DecodeToExistingUint8Array(bufferView, 2048, "/fr06dS2loN4bmJVSDwxKCAZEw8NCwkIBwYFBAMCAQDS0M7Lx8G3qI5oSjQlGxQOCgYEAg==");
|
|
base64DecodeToExistingUint8Array(bufferView, 2112, "38m3p5iKfG9iWE9GPjgyLCcjHxsYFRIQDgwKCAYEAwIBALywm4p3YUMrGgoApXdQPS8jGxQOCQQAcT8AAAAAAAwjPFNshJ20zuQPIDdNZX2Xr8nhEypCWXKJorjR5gwZMkhheJOsyN8aLEVacoeftM3hDRY1UGqCnLTN5A8ZLEBac46oxN4TGD5SZHiRqL7WFh8yT2d4l6rL4xUdLUFqfJarxOAeMUtheY6lutHlExk0Rl10j6bA2xoiPkthdpGnwtkZIThGW3GPpcTfFSIzSGF1kavE3hQdMkNadZCoxd0WHzBCX3WSqMTeGCEzTXSGnrTI4BUcRldqfJWqwtkaITVAU3WYrczhGyJBX2yBm67S4RQaSGNxg5qwyNsiKz1OXXKbsc3lFx02YXyKo7PR5R4mOFl2gZ6yyOcVHTE/VW+Oo8HeGzBNZ4Wes8TX6B0vSmN8l7DG3O0hKj1MXXmbrs/hHTVXcIiaqrzQ4xgeNFSDlqa6y+UlMEBUaHacscnmUQsKCQoJCgnvCO8ICgn8CBcJ7whICxQKWgk/CQoJ4gjiCOII4giSCLcJJAkkCQoJCgkKCSQJJAk/CTIJkAzOCiQJJAkKCeIIrQifCNUIkgicCaoJPwlaCVoJWglaCT8JZwkKCZcN8AtPCJ8I4gjiCOII7wgKCdUI0gxFDBQKWgnHCK0InwiSCJIIQggAEAUPrQg8CjwKZwkKCVoJPwkaCGoMrAw/Ca0I+QmCCSQJCgl3CK0ICg2gDaYKkgjVCJwJMgk/CZ8INQgyCXQJFwk/CVoJdAl0CXQJnAk/CcMOLQ6CCd8JPwniCOII/AifCAAItgyZDJkKHguPCRcJ/Aj8COIITwi/DOQMwQr2Co8J1QjVCMcITwg1CDkLpQtJCj8JZwkyCZIIxwjHCEIImQx9DEkKFAriCIUIxwitCK0IXQhqDO4MtApnCeII4gjiCO8IkghCCEUMyAycCQ0I7wjECT8JtwmCCYUIsw3SDAoJjApXCqoJPwlaCSQJTwhfDc8N3gvwC/wIngetCOII4gjiCEwNJg0nCH8KOQsyCXQJ4giqCewJsA6gDZ4HZApRC98JWgk/CZwJ1QjUC8gMtApIC7QKaghPCO8IugjHCG8OSQ7pB7EHZAqMChQKxAkXCT8JhwxVDTIJGghIC0gLJAm3CccIdwgKDSYNHgvcChcJagjiCO8IQggNCBcJ/AiFCHcIhQg/CUkKjAqMCvkJZwmCCa0I1QitCK0IJAl0CS8KjAreC6wM9gpIC6oJGgj8CAoJMglMCa0IaghPCO8IxAnpCukKPAoUCj8JXA6BDroILgeFCMEKpgpxCtEJnwjpClgMpgr5CR4L0QmFCFoJrQiFCNSylIFsYFVST009Ozk4MzEwLSopKCYkIh8eFQwKAwEA//X07Onh2cu+sK+hlYh9cmZbUUc8NCsjHBQTEgwLBQCzioyUl5WZl6N0Q1I7XEhkWVw=");
|
|
base64DecodeToExistingUint8Array(bufferView, 3232, "EAAAAABjQiQkIiQiIiIiU0UkNCJ0ZkZERLBmREQiQVVEVCR0jZiLqoS7uNiJhPmouYtoZmRERLLaubmq9Ni7u6r0u7vbimebuLmJdLebmIiE2bi4qqTZq5uL9Km4uaqk2N/aitaPvNqo9I2Im6qoitzbi6TbytiJqLr2uYt0udu5imRkhmRmIkREZESoy93aqKeaiGhGpPariYuJm9rbi//+/e4OAwIBAP/+/NojAwIBAP/++tA7BAIBAP/+9sJHCgIBAP/87LdSCAIBAP/867RaEQIBAP/44KthHgQBAP/+7K1fJQcB");
|
|
base64DecodeToExistingUint8Array(bufferView, 3472, "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");
|
|
base64DecodeToExistingUint8Array(bufferView, 5255, "AWRmZkREJCJgpGueubS5i2ZAQiQiIgABINCLjb+YuZtoYKtopmZmZoQBAAAAABAQAFBtTmu5i2dl0NSNi62Ze2ckAAAAAAAAATAAAAAAAAAgRId7d3dnRWJEZ3h2dmZHYoaInbi2mYuG0Kj4S72PeWsgMSIiIgARAtLri3u5iWmGYodotmS3q4ZkRkRGQkIig0CmZkQkAgEAhqZmRCIiQoTU9p6La2tXZmTbfXqJdmeEcoeJaatqMiKk1o2PuZd5Z8AiAAAAAAAB0G1Ku4b5n4lmbpp2V2V3ZQACACQkQkQjYKRmZCQAAiGniq5mZFQCAmRreHckxRgA//799AwDAgEA//784CYDAgEA//770TkEAgEA//70w0UEAgEA//vouFQHAgEA//7wulYOAgEA//7vslseBQEA//jjsWQTAgE=");
|
|
base64DecodeToExistingUint8Array(bufferView, 5584, "////nASa///////jZg9c///////VUxhI7P////+WTCE/1v///755TSs3uf////WJRys7i/////+DQjJCa8L//6Z0TDc1ff//AAAAAAAAAABkAAMAKAADAAMAAwAFAA4ADgAKAAsAAwAIAAkABwADAFsBAAAgABAAZiarASAOAAAgEAAAIBQAAGAUAACAFAAAgBUAANAVAAAgFgAAAAAAAFzKvti235rinOZ47Hr0zPw0A4YLiBNkGWYdSiBCJ6Q1+ff29fTq0srJyMWuUjs4NzYuFgwLCgkHAEAAy5YA18OmfW5SAAAAAKsWAACuFgAAeACAQADongoA5gDz3cC1AGQA8AAgAGQAzTwAMAAgq1UAwIBAAM2aZjMA1auAVSsA4MCggGBAIABkKBAHAwEAAApn8g5WzeQdCmfyDnVSggxZmgQZdVKCDEYRMQrtA2IURhExCtoC1wf5xq0P2gLXByK2UgXa+qQKIrZSBQAAAABG8y4eK+NLDh9mgBgcLB0K2mFIEu2c9AbsMBML45ClBO2kHQIK32sDAAAAAAAAAAAqr9XJz/9AABEAY/9hARD+owAnK71W2f8GAFsAVv+6ABcAgPzAGNhN7f/c/2YAp//o/0gBSfwICiU+AAAAAAAAh8c9yUAAgACG/yQANgEA/UgCMyRFRQwAgAASAHL/IAGL/5/8GxB7OAAAAAAAAAAAaAINyPb/JwA6ANL/rP94ALgAxf7j/QQFBBVAIwAAAADmPsbE8/8AABQAGgAFAOH/1f/8/0EAWgAHAGP/CP/U/1ECLwY0CscMAAAAAAAAAADkVwXFAwDy/+z/8f8CABkAJQAZAPD/uf+V/7H/MgAkAW8C1gMIBbgFAAAAAAAAAACUa2fEEQAMAAgAAQD2/+r/4v/g/+r/AwAsAGQAqADzAD0BfQGtAccBE/WV5lkS8ykfBlQg");
|
|
base64DecodeToExistingUint8Array(bufferView, 6304, "vQCo/WkCZ3d1AGH/0vsIdDQA3QCo9nRu/P8RAury5WbQ//YCjPClXbD/iQN17wZTnf/MA4LvZkeV/8cDi/AnO5n/gANh8q4upf8FA8/0XiK5/2MCofeYFtL/qQGh+rQLYXNzZXJ0aW9uIGZhaWxlZDogMABzaWxrL3Jlc2FtcGxlcl9wcml2YXRlX2Rvd25fRklSLmMAYXNzZXJ0aW9uIGZhaWxlZDogMABzaWxrL3Jlc2FtcGxlci5jAAYAAwAHAwABCgACBhIKDAQAAgAAAAkEBwQAAwwHB2Fzc2VydGlvbiBmYWlsZWQ6IGluTGVuID49IFMtPkZzX2luX2tIegBhc3NlcnRpb24gZmFpbGVkOiBTLT5pbnB1dERlbGF5IDw9IFMtPkZzX2luX2tIegBhc3NlcnRpb24gZmFpbGVkOiBmc19rSHogPT0gOCB8fCBmc19rSHogPT0gMTIgfHwgZnNfa0h6ID09IDE2AHNpbGsvY29udHJvbF9jb2RlYy5jAGFzc2VydGlvbiBmYWlsZWQ6IHBzRW5jLT5zQ21uLm5iX3N1YmZyID09IDIgfHwgcHNFbmMtPnNDbW4ubmJfc3ViZnIgPT0gNABhc3NlcnRpb24gZmFpbGVkOiAoIHBzRW5jLT5zQ21uLnN1YmZyX2xlbmd0aCAqIHBzRW5jLT5zQ21uLm5iX3N1YmZyICkgPT0gcHNFbmMtPnNDbW4uZnJhbWVfbGVuZ3RoAGFzc2VydGlvbiBmYWlsZWQ6IENvbXBsZXhpdHkgPj0gMCAmJiBDb21wbGV4aXR5IDw9IDEwAGFzc2VydGlvbiBmYWlsZWQ6IHBzRW5jQy0+cGl0Y2hFc3RpbWF0aW9uTFBDT3JkZXIgPD0gTUFYX0ZJTkRfUElUQ0hfTFBDX09SREVSAGFzc2VydGlvbiBmYWlsZWQ6IF9mdD4xAGNlbHQvZW50ZW5jLmMAYXNzZXJ0aW9uIGZhaWxlZDogX2JpdHM+MABhc3NlcnRpb24gZmFpbGVkOiBfbmJpdHM8PUVDX1NZTV9CSVRTAGFzc2VydGlvbiBmYWlsZWQ6IF90aGlzLT5vZmZzK190aGlzLT5lbmRfb2Zmczw9X3NpemUAYXNzZXJ0aW9uIGZhaWxlZDogbiA8IDI1AHNpbGsvc3RlcmVvX2VuY29kZV9wcmVkLmMAYXNzZXJ0aW9uIGZhaWxlZDogaXhbIG4gXVsgMCBdIDwgMwBhc3NlcnRpb24gZmFpbGVkOiBpeFsgbiBdWyAxIF0gPCBTVEVSRU9fUVVBTlRfU1VCX1NURVBTAAAAAADgcCwPAwIBAP7twIRGFwQA//zimz0LAg==");
|
|
base64DecodeToExistingUint8Array(bufferView, 7328, "+vXqy0cyKiYjIR8dHBsaGRgXFhUUExIREA8ODQwLCgkIBwYFBAMCAQCzYwBHOCseFQwG");
|
|
base64DecodeToExistingUint8Array(bufferView, 7392, "x6WQfG1gVEc9MyogFw8IAPHh08e7r6SZjoR7cmlgWFBIQDkyLCYhHRgUEAwJBQIAzBwAAOAcAADwHAAAD4OKipubra0=");
|
|
base64DecodeToExistingUint8Array(bufferView, 7472, "RV1zdoOKjYqWlpuWm6CmoIOAho2NjZGRkZabm5uboKCgoKamra22wLbAwMDNwM3gHB0AADAdAABAHQAAAAAAAAQGGAcFAAACAAAMHCkN/PcPKhkOAf4+Kff2JUH8A/oEQgf4EA4m/SEAAAAAAAAAAA0WJxcM/yRAG/r5CjcrEQEBCAEBBvVKNff0N0z0CP0DXRv8Gic7A/gCAE0LCfgWLPoHKAkaAwn5FGX5BAP4KhoA8SFEAhf+Ny7+DwP/FRAp+hs9JwX1KlgEAf48QQb8//tJOAH3E14d9wAMYwYECO1mLvMDAg0DAgnrVEju9S5o6ggSJjAXAPBGU+sLBfV1Fvj6F3X0AwP4XxwE9g9NPPH/BHwC/AMmVBjnAg0qDR8V/Dgu//8jT/MT+UFY9/IUBFEx4xQASwPvBfcsXPgB/RZFH/pfKfQFJ0MQ/AEA+ng33PMsegToUQULAwcCAAkKWHAdAACgHQAA8B0AAC4CWlddW1Ji");
|
|
base64DecodeToExistingUint8Array(bufferView, 7856, "bXh2DHFzdXdjO1dvP29wUH58fXyBeX4XhH9/f35/eoWChmV2d5F+Vnx4e3eqrWttnB4AALAeAADAHgAACBAgYXNzZXJ0aW9uIGZhaWxlZDogdHlwZU9mZnNldCA+PSAwICYmIHR5cGVPZmZzZXQgPCA2AHNpbGsvZW5jb2RlX2luZGljZXMuYwBhc3NlcnRpb24gZmFpbGVkOiBlbmNvZGVfTEJSUiA9PSAwIHx8IHR5cGVPZmZzZXQgPj0gMgBhc3NlcnRpb24gZmFpbGVkOiBwc0VuY0MtPnBzTkxTRl9DQi0+b3JkZXIgPT0gcHNFbmNDLT5wcmVkaWN0TFBDT3JkZXIACAoMEAAAAAAAAAB9MxoSDwwLCgkIBwYFBAMCAQDGaS0WDwwLCgkIBwYFBAMCAQDVonRTOysgGBIPDAkHBgUDAgDvu3Q7HBALCgkIBwYFBAMCAQD65byHVjMeEw0KCAYFBAMCAQD569W5nIBnU0I1KiEaFRENCgD++evOpHZNLhsQCgcFBAMCAQD//fnv3L+cd1U5JRcPCgYEAgD//fv27d/Ls5h8Yks3KB0VDwD//v333KJqQyocEgwJBgQDAg==");
|
|
base64DecodeToExistingUint8Array(bufferView, 8320, "HzlroM3N////////////////RS9Db6bN////////////////UkpPX22AkaCtzc3N4P//4P/gfUo7RWGNtv//////////////rXNVSUxcc5GtzeDg////////poZxZmVma3Z9ipGbprbAwM2W4LaGZVNPVWF4ka3N4P///////+DAlnhlXFldZnaGoLbA4ODg/+DgtpuGdm1oZmpvdoORoK2D");
|
|
base64DecodeToExistingUint8Array(bufferView, 8496, "8b6yhFdKKQ4A38GdjGo5JxI=");
|
|
base64DecodeToExistingUint8Array(bufferView, 8528, "g0qNT1CKX2iGX2NbfV1Me3N7");
|
|
base64DecodeToExistingUint8Array(bufferView, 8560, "gADWKgDrgBUA9LhICwD41oAqBwD44apQGQUA++zGfjYSAwD67tOfUiMPBQD658uogFg1GQYA/O7YuZRsRygSBAD98+HHpoBaOR8NAwD+9unUt5NtSSwXCgIA//rw38amgFo6IRAGAQD/+/Tn0rWSbksuGQwFAQD//fju3cSkgFw8IxIIAwEA//358uXQtJJuTDAbDgcDAQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 8720, "gQDPMgDsgRQA9blICgD51YEqBgD64qlXGwQA++nCgj4UBAD67M+gYy8RAwD/8Nm2g1EpCwEA//7pyZ9rPRQCAQD/+enOqoBWMhcHAQD/+u7ZupRsRicSBgEA//zz4simgFo4Hg0EAQD//PXn0bSSbkwvGQsEAQD//fjt28KjgF0+JRMIAwEA//768eLNsZFvTzMeDwYCAQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 8880, "gQDLNgDqgRcA9bhJCgD614EpBQD86K1WGAMA/fDIgTgPAgD99NmkXiYKAQD99eK9hEcbBwEA/fbny59pOBcGAQD/+OvVs4VVLxMFAQD//vPdwp91RiUMAgEA//746tCrgFUwFggCAQD//vrw3L2Va0MkEAYCAQD//vvz48mmgFo3HQ0FAgEA//789urVt5NtSSsWCgQCAQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 9040, "ggDIOgDnghoA9LhMDAD51oIrBgD86K1XGAMA/fHLgzgOAgD+9t2nXiMIAQD++ejBgkEXBQEA//vv06JjLQ8EAQD/+/PfuoNKIQsDAQD//PXmyp5pORgIAgEA//3369azhFQsEwcCAQD//vrw38SfcEUkDwYCAQD//v3159GwiF03GwsDAgEA//79/O/dwp51TCoSBAMCAQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 9202, "AgUJDhQbIyw2QU1aaHeH");
|
|
base64DecodeToExistingUint8Array(bufferView, 9232, "/jFDTVJdY8YLEhgfJC3/LkJOV15o0A4VICozQv9eaG1wc3b4NUVQWF9mYXNzZXJ0aW9uIGZhaWxlZDogX2Z0PjEAY2VsdC9lbnRkZWMuYwBhc3NlcnRpb24gZmFpbGVkOiBmcmFtZV9sZW5ndGggPT0gMTIgKiAxMABzaWxrL2VuY29kZV9wdWxzZXMuYwBhc3NlcnRpb24gZmFpbGVkOiB3aW5fdHlwZSA9PSAxIHx8IHdpbl90eXBlID09IDIAc2lsay9mbG9hdC9hcHBseV9zaW5lX3dpbmRvd19GTFAuYwBhc3NlcnRpb24gZmFpbGVkOiAoIGxlbmd0aCAmIDMgKSA9PSAwAGFzc2VydGlvbiBmYWlsZWQ6IG9yZGVyID49IDAgJiYgb3JkZXIgPD0gU0lMS19NQVhfT1JERVJfTFBDAHNpbGsvZmxvYXQvc2NodXJfRkxQLmMAYXNzZXJ0aW9uIGZhaWxlZDogT3JkZXIgPD0gbGVuZ3RoAHNpbGsvZmxvYXQvTFBDX2FuYWx5c2lzX2ZpbHRlcl9GTFAuYwBhc3NlcnRpb24gZmFpbGVkOiAwAGNlbHQvY2VsdF9scGMuYwBhc3NlcnRpb24gZmFpbGVkOiBuPjAAYXNzZXJ0aW9uIGZhaWxlZDogb3ZlcmxhcD49MABhc3NlcnRpb24gZmFpbGVkOiBtYXhfcGl0Y2g+MABjZWx0L3BpdGNoLmMAYXNzZXJ0aW9uIGZhaWxlZDogbGVuPjA=");
|
|
base64DecodeToExistingUint8Array(bufferView, 9816, "AwAAAAIAAAADAAAAAgAAAAUAAAACAAAAAwAAAAIAAAADAAAAAgAAAAUAAAACAAAAAwAAAAIAAABhc3NlcnRpb24gZmFpbGVkOiBsZW4+PTMALi9jZWx0L3BpdGNoLmgAYXNzZXJ0aW9uIGZhaWxlZDogSyA+IDAAc2lsay9mbG9hdC9zb3J0X0ZMUC5jAGFzc2VydGlvbiBmYWlsZWQ6IEwgPiAwAGFzc2VydGlvbiBmYWlsZWQ6IEwgPj0gSwAAAQAAAAEAAAAAAAH/Af8C/gL+A/0AAQAB/wL/Av4D/gP9B/4HAAAAAAAC////AAABAQABAAEAAAAAAAEAAAAAAAEAAAABAAAAAAD/AgEAAQEAAP//AAAAAAAAAf8AAf8A/wH+Av7+Av0CA/38A/wEBPsF+vsG+QYFCPcAAAEAAAAAAAAA/wEAAAH/AAH//wH/AgH/Av7+Av4CAgP9AAEAAAAAAAABAAEAAAH/AQAAAgH/Av//Av8CAv8D/v7+AwABAAABAAH/Av8C/wID/gP+/gQE/QX9/Ab8BgX7CPr7+QkAAAAAAAAAAPsI/wb/BvwK+gr+Bv8G+wr3DP0H/gf5DRAYImFzc2VydGlvbiBmYWlsZWQ6IEZzX2tIeiA9PSA4IHx8IEZzX2tIeiA9PSAxMiB8fCBGc19rSHogPT0gMTYAc2lsay9mbG9hdC9waXRjaF9hbmFseXNpc19jb3JlX0ZMUC5jAGFzc2VydGlvbiBmYWlsZWQ6IGNvbXBsZXhpdHkgPj0gU0lMS19QRV9NSU5fQ09NUExFWABhc3NlcnRpb24gZmFpbGVkOiBjb21wbGV4aXR5IDw9IFNJTEtfUEVfTUFYX0NPTVBMRVgAYXNzZXJ0aW9uIGZhaWxlZDogRnNfa0h6ID09IDgAYXNzZXJ0aW9uIGZhaWxlZDogdGFyZ2V0X3B0ciArIHNmX2xlbmd0aF84a0h6IDw9IGZyYW1lXzRrSHogKyBmcmFtZV9sZW5ndGhfNGtIegBhc3NlcnRpb24gZmFpbGVkOiBiYXNpc19wdHIgPj0gZnJhbWVfNGtIegBhc3NlcnRpb24gZmFpbGVkOiBiYXNpc19wdHIgKyBzZl9sZW5ndGhfOGtIeiA8PSBmcmFtZV80a0h6ICsgZnJhbWVfbGVuZ3RoXzRrSHoAYXNzZXJ0aW9uIGZhaWxlZDogbGVuZ3RoX2Rfc3JjaCA+IDAAYXNzZXJ0aW9uIGZhaWxlZDogKmxhZ0luZGV4ID49IDAAYXNzZXJ0aW9uIGZhaWxlZDogbmJfc3ViZnIgPT0gUEVfTUFYX05CX1NVQkZSID4+IDEAYXNzZXJ0aW9uIGZhaWxlZDogYnVmX2xlbiA+PSBwc0VuYy0+c0Ntbi5waXRjaF9MUENfd2luX2xlbmd0aABzaWxrL2Zsb2F0L2ZpbmRfcGl0Y2hfbGFnc19GTFAuYw==");
|
|
base64DecodeToExistingUint8Array(bufferView, 10934, "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");
|
|
base64DecodeToExistingUint8Array(bufferView, 15393, "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");
|
|
base64DecodeToExistingUint8Array(bufferView, 17025, "Dyc0PURKT1RYXF9jZmlsb3J1d3p8foGDhYeJi46PkZOVl5mbnZ6goqOlp6iqq62usLGztLa3ubq7vb7AwcLExcfIycvMzc/Q0dPU1dfY2dvc3d/g4ePk5ufo6uvs7u/x8vP19vj5+vz9/wAAAAAAAAAcKzQ7QUZKTlFVV1pdX2JkZmlrbW9xc3R2eHp7fX+AgoOFhoiJioyNj5CRk5SVl5iZmpydnp+goqOkpaanqKmrrK2ur7CxsrO0tba3uLm6u7y8vb6/wMHCw8TFxsfIycrLy8zNzs/Q0dLT1NXW1tfY2drb3N3e3+Dg4eLj5OXm5+jp6uvs7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAAAAAAAAAAgdKTE4PkJGSk1QU1ZYW11fYWNlZ2lrbG5wcXN0dnd5ent9fn+BgoOEhoeIiYqMjY6PkJGSk5SVlpeYmZqcnZ6fn6ChoqOkpaanqKmqq6usra6vsLGxsrO0tbW2t7i5ubq7vL29vr/AwMHCw8PExcbGx8jIycrLy8zNzs7P0NHR0tPT1NXW1tfY2Nna29vc3d3e3+Dg4eLi4+Tl5ebn6Ojp6urr7O3t7u/w8PHy8/P09fb29/j5+fr7/P3/YXNzZXJ0aW9uIGZhaWxlZDogMABzaWxrL2VuY19BUEkuYwBhc3NlcnRpb24gZmFpbGVkOiAhcmV0AGFzc2VydGlvbiBmYWlsZWQ6IGVuY0NvbnRyb2wtPm5DaGFubmVsc0ludGVybmFsID09IDEgfHwgcHNFbmMtPnN0YXRlX0Z4eFsgMCBdLnNDbW4uZnNfa0h6ID09IHBzRW5jLT5zdGF0ZV9GeHhbIDEgXS5zQ21uLmZzX2tIegBhc3NlcnRpb24gZmFpbGVkOiBlbmNDb250cm9sLT5uQ2hhbm5lbHNBUEkgPT0gMSAmJiBlbmNDb250cm9sLT5uQ2hhbm5lbHNJbnRlcm5hbCA9PSAxAGFzc2VydGlvbiBmYWlsZWQ6IHBzRW5jLT5zdGF0ZV9GeHhbIDAgXS5zQ21uLmlucHV0QnVmSXggPT0gcHNFbmMtPnN0YXRlX0Z4eFsgMCBdLnNDbW4uZnJhbWVfbGVuZ3RoAGFzc2VydGlvbiBmYWlsZWQ6IGVuY0NvbnRyb2wtPm5DaGFubmVsc0ludGVybmFsID09IDEgfHwgcHNFbmMtPnN0YXRlX0Z4eFsgMSBdLnNDbW4uaW5wdXRCdWZJeCA9PSBwc0VuYy0+c3RhdGVfRnh4WyAxIF0uc0Ntbi5mcmFtZV9sZW5ndGgAAACAuwAAeAAAABUAAAAVAAAAAJpZPwAAAAAAAIA/AACAP8BGAAADAAAACAAAAHgAAAALAAAA8EYAAOBHAAAQSAAAgAcAAAMAAADwSQAAEH4AAEB/AAD4fwAAMEoAAIgBAABQZgAAMGcAAMBo");
|
|
base64DecodeToExistingUint8Array(bufferView, 18114, "AQACAAMABAAFAAYABwAIAAoADAAOABAAFAAYABwAIgAoADAAPABOAGQ=");
|
|
base64DecodeToExistingUint8Array(bufferView, 18181, "WlBLRT84MSgiHRQSCgAAAAAAAAAAbmRaVE5HQTozLScgGhQMAAAAAAAAdm5nXVZQS0ZBOzUvKB8XDwQAAAAAfndwaF9ZU05IQjw2LycgGREMAQAAhn94cmdhW1VOSEI8Ni8pIx0XEAoBkImCfHFrZV9YUkxGQDkzLSchGg8BmJGKhHt1b2liXFZQSkM9NzErJBQBopuUjoV/eXNsZmBaVE1HQTs1Lh4BrKWemI+Jg312cGpkXldRS0U/OC0UyMjIyMjIyMjGwby3sq2oo56ZlIFo");
|
|
base64DecodeToExistingUint8Array(bufferView, 18416, "CAAIAAgACAAQABAAEAAVABUAGAAdACIAJAAAAAAAAABqHI04UrseOghp3DqC7Vc7iWOyOwMqBTww3Dk8tD53PByjnjzR8sU8/obxPJurED0FrSo9hMJGPVPmZD0RiYI9h5+TPcuypT3Rvrg9Or/MPVSv4T0Uivc9DiUHPtn0Ej5fMR8+aNcrPorjOD4wUkY+lB9UPr9HYj6OxnA+sJd/PlJbhz5gD48+mOWWPnnbnj5w7qY+2BuvPvtgtz4Ru78+RifIPrei0D54Ktk+lLvhPgxT6j7e7fI+Bon7Pr4QAj8fWgY/JJ8KP1DeDj8rFhM/QUUXPyVqGz9zgx8/zo8jP+aNJz90fCs/P1ovPxkmMz/n3jY/mYM6PzMTPj/FjEE/d+9EP386SD8nbUs/zoZOP+WGUT/xbFQ/jjhXP2npWT9Ff1w/+vleP3NZYT+vnWM/wcZlP8/UZz8RyGk/0qBrP25fbT9QBG8/9I9wP+YCcj+9XXM/H6F0P7/NdT9X5HY/sOV3P5fSeD/jq3k/c3J6Pycnez/nyns/nV58PzXjfD+cWX0/vcJ9P4Yffj/ecH4/q7d+P8/0fj8mKX8/hlV/P756fz+WmX8/zLJ/PxTHfz8c138/guN/P93sfz+2838/ivh/P8j7fz/W/X8/B/9/P6X/fz/o/38//f9/PwAAgD/gAQAAh4gIO/////8FAGAAAwAgAAQACAACAAQABAAB");
|
|
base64DecodeToExistingUint8Array(bufferView, 18972, "cGkAADBt");
|
|
base64DecodeToExistingUint8Array(bufferView, 18992, "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");
|
|
base64DecodeToExistingUint8Array(bufferView, 26250, "KQApACkAKQB7AHsAewCkAKQA8AAKARsBJwEpACkAKQApACkAKQApACkAewB7AHsAewDwAPAA8AAKAQoBMQE+AUgBUAF7AHsAewB7AHsAewB7AHsA8ADwAPAA8AAxATEBMQE+AT4BVwFfAWYBbAHwAPAA8ADwAPAA8ADwAPAAMQExATEBMQFXAVcBVwFfAV8BcgF4AX4BgwE=");
|
|
base64DecodeToExistingUint8Array(bufferView, 26416, "KAcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcoDxccHyIkJicpKissLS4vLzEyMzQ1Njc3OTo7PD0+Pz9BQkNERUZHRygUISkwNTk9QEJFR0lLTE5QUlVXWVtcXmBiZWdpa2xucHJ1d3l7fH6AKBcnMzxDSU9TV1teYWRmaWtvc3Z5fH6Bg4eLjpGUlpmbn6OmqayusbMjHDFBTllja3J4foSIjZGVmZ+lq7C0ub3Ax83T2Nzh5ejv9fsVITpPYXB9iZSdpq62vcPJz9nj6/P7ESM/Vmp7i5ilsbvFztbe5u36GR83S1tpdYCKkpqhqK60ub7I0Nfe5evw9f8QJEFZboCQn625xM/Z4ury+gspSmeAl6y/0eHx/wkrT26Ko7rP4/YMJ0dje5CktsbW5PH9CSxRcY6owNbr/wcxWn+gv9z3BjNfhqrL6gcvV3ubuNTtBjRhia7Q8AU5apfA5wU7b57K8wU3Z5O74AU8caHO+ARBeq/gBEN/tuoAAAAAAAAAAODg4ODg4ODgoKCgoLm5ubKyqIY9JeDg4ODg4ODg8PDw8M/Pz8bGt5BCKKCgoKCgoKCgubm5ucHBwbe3rIpAJvDw8PDw8PDwz8/Pz8zMzMHBtI9CKLm5ubm5ubm5wcHBwcHBwbe3rIpBJ8/Pz8/Pz8/PzMzMzMnJyby8sI1CKMHBwcHBwcHBwcHBwcLCwri4rYtBJ8zMzMzMzMzMycnJycbGxru7r4xCKA==");
|
|
base64DecodeToExistingUint8Array(bufferView, 26994, "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");
|
|
base64DecodeToExistingUint8Array(bufferView, 32316, "MHwAADBt");
|
|
base64DecodeToExistingUint8Array(bufferView, 32338, "GAAwAEgAYAAIACAAOABQAGgAEAAoAEAAWABwAAQAHAA0AEwAZAAMACQAPABUAGwAFAAsAEQAXAB0AAEAGQAxAEkAYQAJACEAOQBRAGkAEQApAEEAWQBxAAUAHQA1AE0AZQANACUAPQBVAG0AFQAtAEUAXQB1AAIAGgAyAEoAYgAKACIAOgBSAGoAEgAqAEIAWgByAAYAHgA2AE4AZgAOACYAPgBWAG4AFgAuAEYAXgB2AAMAGwAzAEsAYwALACMAOwBTAGsAEwArAEMAWwBzAAcAHwA3AE8AZwAPACcAPwBXAG8AFwAvAEcAXwB3AHgAAACIiAg8AgAAAAUAGAADAAgAAgAEAAQAAQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 32620, "UH4AADBt");
|
|
base64DecodeToExistingUint8Array(bufferView, 32642, "DAAYACQAMAAEABAAHAAoADQACAAUACAALAA4AAEADQAZACUAMQAFABEAHQApADUACQAVACEALQA5AAIADgAaACYAMgAGABIAHgAqADYACgAWACIALgA6AAMADwAbACcAMwAHABMAHwArADcACwAXACMALwA7ADwAAACJiIg8AwAAAAUADAADAAQABAAB");
|
|
base64DecodeToExistingUint8Array(bufferView, 32804, "gH8AADBtAAAAAAAAlYsAADeYAAD/pQAABLUAAGfFAABF1wAAweoAAP//AABhc3NlcnRpb24gZmFpbGVkOiBmbCtmczw9MzI3NjgAY2VsdC9sYXBsYWNlLmMAYXNzZXJ0aW9uIGZhaWxlZDogZnM+MA==");
|
|
base64DecodeToExistingUint8Array(bufferView, 32930, "zkAAAMhAAAC4QAAAqkAAAKJAAACaQAAAkEAAAIxAAACcQAAAlkAAAJJAAACOQAAAnEAAAJRAAACKQAAAkEAAAIxAAACUQAAAmEAAAI5AAABwQAAAcEAAAHBAAABwQAAAcEA=");
|
|
base64DecodeToExistingUint8Array(bufferView, 33040, "SH9BgUKAQYBAgD6AQIBAgFxOXE9cTlpPdClzKHIohBqEGpERoQywCrELGLMwijaHNoQ1hjiFN4Q3hD1yRmBKWEtYV0pZQltDZDtsMngoeiVhK04yU05UUVhLVkpXR1pJXUpdSm0ociR1InUijxGREpITogylCrIHvQa+CLEJF7I2cz9mQmJFY0pZR1tJW05ZVlBcQl1AZjtnPGg8dTR7LIojhR9hJk0tPVpdPGkqayluLXQmcSZwJnwahBuIE4wUmw6fEJ4Sqg2xCrsIwAavCZ8KFbI7bkdWS1VUU1tCWElXSFxLYkhpOms2czRyN3A4gTOEKJYhjB1iI00qKnlgQmwrbyh1LHsgeCR3IX8hhiKLFZMXmBSeGZoaphWtELgNuAqWDYsPFrI/ckpSVFNcUmc+YEhgQ2VJa0hxN3Y0fTR2NHU3hzGJJ50gkR1hIU0oAABmPwAATD8AACY/AAAAPwCGaz8AFC4/AHC9PgDQTD4CAQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 33424, "AwAAAAQAAAAEAAAABgAAAIP5ogBETm4A/CkVANFXJwDdNPUAYtvAADyZlQBBkEMAY1H+ALveqwC3YcUAOm4kANJNQgBJBuAACeouAByS0QDrHf4AKbEcAOg+pwD1NYIARLsuAJzphAC0JnAAQX5fANaROQBTgzkAnPQ5AItfhAAo+b0A+B87AN7/lwAPmAUAES/vAApaiwBtH20Az342AAnLJwBGT7cAnmY/AC3qXwC6J3UA5evHAD178QD3OQcAklKKAPtr6gAfsV8ACF2NADADVgB7/EYA8KtrACC8zwA29JoA46kdAF5hkQAIG+YAhZllAKAUXwCNQGgAgNj/ACdzTQAGBjEAylYVAMmocwB74mAAa4zAABnERwDNZ8MACejcAFmDKgCLdsQAphyWAESv3QAZV9EApT4FAAUH/wAzfj8AwjLoAJhP3gC7fTIAJj3DAB5r7wCf+F4ANR86AH/yygDxhx0AfJAhAGokfADVbvoAMC13ABU7QwC1FMYAwxmdAK3EwgAsTUEADABdAIZ9RgDjcS0Am8aaADNiAAC00nwAtKeXADdV1QDXPvYAoxAYAE12/ABknSoAcNerAGN8+AB6sFcAFxXnAMBJVgA71tkAp4Q4ACQjywDWincAWlQjAAAfuQDxChsAGc7fAJ8x/wBmHmoAmVdhAKz7RwB+f9gAImW3ADLoiQDmv2AA78TNAGw2CQBdP9QAFt7XAFg73gDem5IA0iIoACiG6ADiWE0AxsoyAAjjFgDgfcsAF8BQAPMdpwAY4FsALhM0AIMSYgCDSAEA9Y5bAK2wfwAe6fIASEpDABBn0wCq3dgArl9CAGphzgAKKKQA05m0AAam8gBcd38Ao8KDAGE8iACKc3gAr4xaAG/XvQAtpmMA9L/LAI2B7wAmwWcAVcpFAMrZNgAoqNIAwmGNABLJdwAEJhQAEkabAMRZxADIxUQATbKRAAAX8wDUQ60AKUnlAP3VEAAAvvwAHpTMAHDO7gATPvUA7PGAALPnwwDH+CgAkwWUAMFxPgAuCbMAC0XzAIgSnACrIHsALrWfAEeSwgB7Mi8ADFVtAHKnkABr5x8AMcuWAHkWSgBBeeIA9N+JAOiUlwDi5oQAmTGXAIjtawBfXzYAu/0OAEiatABnpGwAcXJCAI1dMgCfFbgAvOUJAI0xJQD3dDkAMAUcAA0MAQBLCGgALO5YAEeqkAB05wIAvdYkAPd9pgBuSHIAnxbvAI6UpgC0kfYA0VNRAM8K8gAgmDMA9Ut+ALJjaADdPl8AQF0DAIWJfwBVUikAN2TAAG3YEAAySDIAW0x1AE5x1ABFVG4ACwnBACr1aQAUZtUAJwedAF0EUAC0O9sA6nbFAIf5FwBJa30AHSe6AJZpKQDGzKwArRRUAJDiagCI2YkALHJQAASkvgB3B5QA8zBwAAD8JwDqcagAZsJJAGTgPQCX3YMAoz+XAEOU/QANhowAMUHeAJI5nQDdcIwAF7fnAAjfOwAVNysAXICgAFqAkwAQEZIAD+jYAGyArwDb/0sAOJAPAFkYdgBipRUAYcu7AMeJuQAQQL0A0vIEAEl1JwDrtvYA2yK7AAoUqgCJJi8AZIN2AAk7MwAOlBoAUTqqAB2jwgCv7a4AXCYSAG3CTQAtepwAwFaXAAM/gwAJ8PYAK0CMAG0xmQA5tAcADCAVANjDWwD1ksQAxq1LAE7KpQCnN80A5qk2AKuSlADdQmgAGWPeAHaM7wBoi1IA/Ns3AK6hqwDfFTEAAK6hAAz72gBkTWYA7QW3ACllMABXVr8AR/86AGr5uQB1vvMAKJPfAKuAMABmjPYABMsVAPoiBgDZ5B0APbOkAFcbjwA2zQkATkLpABO+pAAzI7UA8KoaAE9lqADSwaUACz8PAFt4zQAj+XYAe4sEAIkXcgDGplMAb27iAO/rAACbSlgAxNq3AKpmugB2z88A0QIdALHxLQCMmcEAw613AIZI2gD3XaAAxoD0AKzwLwDd7JoAP1y8ANDebQCQxx8AKtu2AKMlOgAAr5oArVOTALZXBAApLbQAS4B+ANoHpwB2qg4Ae1mhABYSKgDcty0A+uX9AInb/gCJvv0A5HZsAAap/AA+gHAAhW4VAP2H/wAoPgcAYWczACoYhgBNveoAs+evAI9tbgCVZzkAMb9bAITXSAAw3xYAxy1DACVhNQDJcM4AMMu4AL9s/QCkAKIABWzkAFrdoAAhb0cAYhLSALlchABwYUkAa1bgAJlSAQBQVTcAHtW3ADPxxAATbl8AXTDkAIUuqQAdssMAoTI2AAi3pADqsdQAFvchAI9p5AAn/3cADAOAAI1ALQBPzaAAIKWZALOi0wAvXQoAtPlCABHaywB9vtAAm9vBAKsXvQDKooEACGpcAC5VFwAnAFUAfxTwAOEHhgAUC2QAlkGNAIe+3gDa/SoAayW2AHuJNAAF8/4Aub+eAGhqTwBKKqgAT8RaAC34vADXWpgA9MeVAA1NjQAgOqYApFdfABQ/sQCAOJUAzCABAHHdhgDJ3rYAv2D1AE1lEQABB2sAjLCsALLA0ABRVUgAHvsOAJVywwCjBjsAwEA1AAbcewDgRcwATin6ANbKyADo80EAfGTeAJtk2ADZvjEApJfDAHdY1ABp48UA8NoTALo6PABGGEYAVXVfANK99QBuksYArC5dAA5E7QAcPkIAYcSHACn96QDn1vMAInzKAG+RNQAI4MUA/9eNAG5q4gCw/cYAkwjBAHxddABrrbIAzW6dAD5yewDGEWoA98+pAClz3wC1yboAtwBRAOKyDQB0uiQA5X1gAHTYigANFSwAgRgMAH5mlAABKRYAn3p2AP39vgBWRe8A2X42AOzZEwCLurkAxJf8ADGoJwDxbsMAlMU2ANioVgC0qLUAz8wOABKJLQBvVzQALFaJAJnO4wDWILkAa16qAD4qnAARX8wA/QtKAOH0+wCOO20A4oYsAOnUhAD8tKkA7+7RAC41yQAvOWEAOCFEABvZyACB/AoA+0pqAC8c2ABTtIQATpmMAFQizAAqVdwAwMbWAAsZlgAacLgAaZVkACZaYAA/Uu4AfxEPAPS1EQD8y/UANLwtADS87gDoXcwA3V5gAGeOmwCSM+8AyRe4AGFYmwDhV7wAUYPGANg+EADdcUgALRzdAK8YoQAhLEYAWfPXANl6mACeVMAAT4b6AFYG/ADlea4AiSI2ADitIgBnk9wAVeiqAIImOADK55sAUQ2kAJkzsQCp1w4AaQVIAGWy8AB/iKcAiEyXAPnRNgAhkrMAe4JKAJjPIQBAn9wA3EdVAOF0OgBn60IA/p3fAF7UXwB7Z6QAuqx6AFX2ogAriCMAQbpVAFluCAAhKoYAOUeDAInj5gDlntQASftAAP9W6QAcD8oAxVmKAJT6KwDTwcUAD8XPANtargBHxYYAhUNiACGGOwAseZQAEGGHACpMewCALBoAQ78SAIgmkAB4PIkAqMTkAOXbewDEOsIAJvTqAPdnigANkr8AZaMrAD2TsQC9fAsApFHcACfdYwBp4d0AmpQZAKgplQBozigACe20AESfIABOmMoAcIJjAH58IwAPuTIAp/WOABRW5wAh8QgAtZ0qAG9+TQClGVEAtfmrAILf1gCW3WEAFjYCAMQ6nwCDoqEAcu1tADmNegCCuKkAazJcAEYnWwAANO0A0gB3APz0VQABWU0A4HGA");
|
|
base64DecodeToExistingUint8Array(bufferView, 36211, "QPsh+T8AAAAALUR0PgAAAICYRvg8AAAAYFHMeDsAAACAgxvwOQAAAEAgJXo4AAAAgCKC4zYAAAAAHfNpNWFzc2VydGlvbiBmYWlsZWQ6IF9rPjAAY2VsdC9jd3JzLmM=");
|
|
base64DecodeToExistingUint8Array(bufferView, 36320, "QI4AAACRAAC8kwAAdJYAACiZAADYmwAAhJ4AAOyfAACooAAAHKEAAGihAACgoQAAwKEAANihAADkoQAAYXNzZXJ0aW9uIGZhaWxlZDogX24+PTI=");
|
|
base64DecodeToExistingUint8Array(bufferView, 36416, "AQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 37124, "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");
|
|
base64DecodeToExistingUint8Array(bufferView, 42145, "QMpFG0z/UoJas2Kia2B1YXNzZXJ0aW9uIGZhaWxlZDogcW4gPD0gMjU2AAAAAAAACA0QExUXGBobHB0eHyAgISIiIyQkJSVhc3NlcnRpb24gZmFpbGVkOiBjb2RlZEJhbmRzID4gc3RhcnQAY2VsdC9yYXRlLmMAYXNzZXJ0aW9uIGZhaWxlZDogYml0c1tqXSA+PSAwAGFzc2VydGlvbiBmYWlsZWQ6IGViaXRzW2pdID49IDAAYXNzZXJ0aW9uIGZhaWxlZDogQyplYml0c1tqXTw8QklUUkVTID09IGJpdHNbal0AYXNzZXJ0aW9uIGZhaWxlZDogZmluICE9IGZvdXQKSW4tcGxhY2UgRkZUIG5vdCBzdXBwb3J0ZWQAY2VsdC9raXNzX2ZmdC5jAGFzc2VydGlvbiBmYWlsZWQ6IG09PTQAYXNzZXJ0aW9uIGZhaWxlZDogc3QtPnNpZ25hbGxpbmc9PTAAY2VsdC9jZWx0X2VuY29kZXIuYwACAQBhc3NlcnRpb24gZmFpbGVkOiAhY2VsdF9pc25hbihmcmVxWzBdKSAmJiAoQz09MSB8fCAhY2VsdF9pc25hbihmcmVxW05dKSkAYXNzZXJ0aW9uIGZhaWxlZDogY291bnQ+MAAZFwI=");
|
|
base64DecodeToExistingUint8Array(bufferView, 42642, "gD8AAABAAABAQAAAgEAAAKBAAADAQAAA4EAAAABBAACAQQAAwEEAABBCAAAwQgAASEIAAGBCAAB4QgAAhkIAAJBCAACeQgAAsEIAANRCAAAGQw==");
|
|
base64DecodeToExistingUint8Array(bufferView, 42738, "gD8AAIA/AACAPwAAgD8AAIA/AACAPwAAgD8AAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAABAQAAAQEAAAIBAAACgQAAAwEAAAABBAAAAQX58d21XKRMJBAIAAP//nG5WRjszLSglIR8cGhkXFhUUExIREBAPDw4NDQwMDAwLCwsKCgoJCQkJCQkICAgICAcHBwcHBwYGBgYGBgYGBgYGBgYGBgYFBQUFBQUFBQUFBQUEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAwMDAwMDAwMDAwMDAwMDAwMCYXNzZXJ0aW9uIGZhaWxlZDogIWNlbHRfaXNuYW4odG1wWzBdKQBhc3NlcnRpb24gZmFpbGVkOiAhY2VsdF9pc25hbihub3JtKQAAAAAAAAAz8AEN+/rw+Qv6ahoc8hXjBxLu7xXv9xTn/d4wC/Ph7OL3AvQF/wgJCQjzEu/e+xH1APwKAgoP+AL/AAUN/fAB+wMH5PMGJP0TxO/kB/Xi+QLW6/0G6iH3B+IV8hj17O779AzPzs8QCdv/CSLz4eEMECzWAvcI7voJJBMLDQzrA+T0AyEZ8gsBotkS9PXx+TE0CtUJOQgV+g7xLPgH4vP+9xn+gRL1zBrlGwr2BysG6CkK7uUKEQkK7/YU+hY3I7AkGejcDwntWBNAzd0RAPkp8BsED/8S8C/ZyvgN5+xm7vssC+RHAs37BQKt9+MIFcs62/kNJgki/9cVBOjc3+sgS/4BvP8v4yAUDL+pBRD0GCgPBxPm7xEG/tvi9yCB2QDh5QTqF/qzI8Mg2+gN9f/Y/RH5DQs77QoG7gANA/rpEwvvDf+wKMtF48oA/CHn/iYjJPEuAvPw+PgM6PfJ+/cgCwcM7vaq2jYl5xLVB+Xlyg0JFkYGI/kX8dT6B76rICjt9/kM8QcCBt0LHAAaDgEBBAwSIxbu/Q7/Bw748v0E/e35/+flGeb+Ierl5wT3BxUa4gr37AsbCgXuDvwC7/v59/MPHQH28PYjJPnq1BEeFhX/FvUg+PkF9gUe7B3s3gz8+gbzCvu8/xgJE+jAHxMb5kvTKSfWCAYX4hDnHiII2v0SEOEW/PcBFAkm4ADTAPrzC+fg6h/o9fX8/BTeFhQJ5xv7HOMdBhX67jYE0hcV8uEk1+gEFgoLByTg88zvGBzb3P8YCdojMBIC/y0KJxjaDQjwCBkLB+P1BxTi2tMO7uT3QT0Wy9rwJC4U2SDD+vrc3+7kOGUtC+Tp48MU0QIwG+8BKAEDzQ8jHBYjNcPjDPrrCgPsAucB+h8L/QH2zAZ+l3p/gH9/gH9sDH8wgNyAf3+AgH9ZgH+AgIB/f4CAo64UfUGufya2UVioTzPRkeYOU6iQGCObYp3Q0y5TxLEt7NcJBDQ2XfYEDQN7Bl6Ru/LhCgw1sfXr/tS4XEHHONp/yIB/f4BWdbWAf+2dkH+Af9BydoCAde/6eYB/gFI2ln9/32TZ6RKy3uP/4n/mf4B+gBvpsYiBf0hCHQe+yIuAIKgAAECoAAAZAAAAIA==");
|
|
base64DecodeToExistingUint8Array(bufferView, 43904, "1hQQAGk8AZ8YPBINPhl/Ik83dn9fH/xXFQwC8hIXCBH/+AUEGCUVDSQNERIlHiEBCPD1++H9+wAGAzr5//AF8xAK/vIL/AP1AAAAAAAAAAAW//kHHeXh7/MhLPgLIRhODxMe/ugFMQUkHfL10N8V1tr0N9s2+AEkEQAzHzsH9DUEIPIwBfbw+AHwyOj6Ev4XBi769hQj1PHPJBAF+bG9DEb9scqr6C/qIRVF/wsWDvDw6uT1C9cf5t/t/BsgzgX22ur4I+EB1/H1LBzv1+kRAunm8/PvBg7h5wntJ/gEH//T9eSk0vEVduotzQvs7PEN65/j4OnWXgEX+D/90hPmINi25hr88x7s4ufy4dPVBMTQ9N4CAgMNDwsQBS73yfDHHQ4mzv7U9fg05dr5FC8RxQAvLsEj7xMhRO0CD/Ac8Jka3S/ZxB4f6czzdC/nHige6gIM5e4f9hv4vgwOBObk8wMN5s0lBQLrLwMNGdfl+PwFtN8cCgnSthMcGR82yUQm6OACBEQL/2MFEP62KBrmIR//vA76GQkdPD0H+QDoB00E/xD5DfHtHOHo8CUYDR4K4gsL9hY8HC392ML7mgng5coVD/sl1fUl7S/AgOWOFb47Lv30qfcEE4/cTjnm2rP2Bga1GZ/1IdIBDevf7BD6/fX85SYI1/7fEhPmAePq/PLJ9bD9CyJaMwsRKyR/4B1nCRsNQDhG8gP0CiUDDOr2LhwKFBroEgkHDiL7+R/yyAvu+O/59tgK3+DVBQkL/Aoy9PsuCQcBCw9b7wfOFwbinQDvDgj25+K7wh9/cull+8r66gfIJxLjAC4IsQTrEuA+9Pj0xh/gEQboGRgJ/O0tBhHyBeUQ/NcZ3AUPDDIbGRfUu/ft0PgEDPoN7eLcGiX//eLW8vbsGsrl1ARJ5logu+PwA2cP7yUY6eEh28AZDa/k4BsF3ekP6hP5CR4T6RvzKx3j+gnY39/gCQvQ+OnMLhHq1iPx1xAiH9bt9TcH2Vn13xTyFiAD7/oOIgE366b4EhsN4xUP38339QTw7hf8/DABBx3y9PARIwgA+f4JCBH6NeDrzgVjxPvLCuEM+wdQJBLhCWIkwd0E8+ToHPMSEP/u3goUBwQdCxn5JA4tGAHwHgYj+vXoDf8bJxQw9fzzHAvh7h/jFv7s8AUe9OT9XfAXEuMGytsc/f3R/dzJ/Sn2L/4XKvm55VPAB+gIGu8PDB/i2vPfyATvFBIB4vv64fLbABYK4iXvEgYFF9zgDhLzw8y7LOIQEvznDlEa+OnFNJgRd+AaEQEXLR3Ax/JJFfPzCbz5zAMY2SzxGw4T9+T1BQPe/gIW+ukEAw3q8/buHQYs8+j4Ah4OKwYRt/r5FLD5+eQPu9r7nN0PsRcd7uUVvtsI6tkwBPMB9wvjFgbPIPIv7vwszLYrHhfyBQDlBPkK/AoB8Avu/vsC9QDs/CZKOydA9hr92LwD4s0I7eXSMzQ2JFpcDg37ABDCEAvR2/r7FTbHICr6PvcQFRgJ9vwhMg3xAd3QEvXvvfMVJtQk8B0RBfYSEeACCBbI8eAoKxMu+ZygEzUYFebQm649Jqvk3v8/+/snJ9og9OQUKPgCHwzd8xTnHggD8/fsAvMYJfYhBhTw6Pr67fsWFQoL/Nn/BjEp8ccVwk278wC2Afna+AY/HAQazFI/DS3fLMy/69LPQO8gGETZ8PvmHAXD5AIYC/TfCdv95Bbb9BMA7v4OAQQI9/4r7/6+4TjYqdz+/NbT/x/V8Rs/9SD23xvtBA/m3h382b8O7Ovv3A07L9rfDdv42/n6tOH00gcY6+LyCQ/08y/l5//ZABT3BgcEAwcnMhb5DuwBRuQd1wrw++T+2yDuET717M4kFcL0yDQyEQMwLNfnAxD9ACH6Dxsi5xYJEfUkEP4MFcwt/vYuFe5D5PMeJSoQ9wtLB8DY9h056QU1swPv+y/J3dzzNMu5NJHp5uQd1TftK+029N/U2e324fYVJsfsAucI+jIMDxnnD+L6CRklE/wf6gIEAiQHA96wJPb++x/cMboU3BUYGdLNJMbQ2PY3Ry8K/wEC0rwQDQC240nM7vUH1K7guuT/2bz61wzq8Cj15zP3FQQE3geyEAba4v7UIAAWQAW4/vL28PjnDGbGJfbpDzEH+QLs4C36MBweIf8W+h5B7x1KJeb2D+gTvhb24f/u9wsl/C0FKREBARjGKQXNDggrEPb/LSDAA9/n/eW8DBf189vYBOv0IOntTCnp6NS///EBRz8FFP0V6R/gEv4bHy772fvdEu7Y9gMMAv7qKAX6PCQDHeUKGcoFGicj6NsepRz86+XZ+gUMgCbwHaHjUv4jAgwI6gpQ0QLnt7EQ4uC+MBXT9dEO5e/5D9Ty1ObgGukR+eQa+hwG5gIN8unyEy4QAt/rHO/WLNsB2RxU0g8KDdRI5hog5PStAgri1PbkNS1BAOc5JN8GHSzLCxP+5SMgMQQXJiQYCjPZBPkaJd0L0e4cEN0qEevXHA70C9MH1fES+ybYzuLrCZ4NDBdLyPn9/P/eDM8LGu7k7yEN8igYuNsKEfoWEBD69OLyCijpDA/98Q3I/OIB/e8bMvtA3O0HHRYZCfDGu9jDufIqXRoL+sb1RswTCeLfC9vR6+rYCi8E6REwKdAOCg8i6f7RF+Dz9ubm/BAm8gD0+fkULP/g5fAE+u4OBQTjHAf5D/Xs09wQVCLF4hZ+CERP7xW8JQUPPzF/plUrBxAJBtPH1TkL6fXjPOYAByroChfnCPnYE+8jBBvZpRvcIgIQ6BkH6wURCuriCe/D5iEVOs3yRdoUB1D8v/rlNfQv//EBPGax/AwJFiX4/CUC/fHw9fsT+tUU5+4K5QDk5fUK7v788BoO+gf6ATX+4xcJ4vr8+jhGAN/s7/foLvuXL9LNFBTLr//5S/vrvwzMFs70MTZMrwot18US7RkO4cv7DB9U6QIHAgrgJ/70AfcA9vUJD/j+Av8KDvvYE/n5GvwCAeUjIBXhGiv3BOAowswkFiYWJKAG9unPD9/u/QApFe0VF9np+gYvOARKAJ4d0fLcFeoWEA0MEPsNEfPxAd7mGgwgGw29GwIIChIQFO/vOcAFDhMf7tTS8ATnEYLoJwQIN+feJ/ADCUdI4ckGCucgq+sS+A8M5fkB6/77MPASAermEA7hG/rx6wTyEtwUQ50MKecx1CNRbi8ivvIOxCIdtwopI1kH3RYHG+z6OBpCBiHJNQHrDhFENzsAEvcF1wb7jvQdKukKUeUUy+LCKF8Z/AMS+PHjrgLH/cPj4zECyQW7nc/NBucMWSzfBSkBF9vb5NADBNfix93Z//PI+zIxKfz8Ier/ISISKNYMAfr+EhEnLAtBxNMKWxUJwvUIRSUY4hUa5QHkGEL4BrkiGCw6su05EcQBDP3/2BYL+xkMAUhPB84XEg0V9ewFTaIYDznNAyQ1/wQOHuEWKCD13tzFOhkVyukoLhIADDagncUFd9oyNwzwQwAiIycj/0UYG+Ld/LoC1Pn6E/c8LOv2JSvw/R7xvx/JEp5MQBkY7vm89iYbxCQhEB4i2dsfDDXKDubPgPP76vWrN/jN9d/24bTXFyzYyoGbE+nxDxs6xAgO3wEw9/WFAzUXBOQWAuO9JAwHN+tYFP/r7wMpIPby+8dDORUX/uW36HgVEt0q+QPT50zeMgvKpQOP7PsvD9ERG/3m+QoHSthA+fvoz+j99hvv+P0O5SENJxz52h0QLBM3/QnzxysrHwCj7xPIBPTnJavziiHvOEew/Ab17i/MGQkwlQEVFP0K8PwYER/D7s4Y9gxHGgv9BAEA+dgSJt4mEQjeAhV74OYrDt7/9yXwBu/CRBYRC7UhsD73tUwk1/jY9bko2T7PrxD3zDQ9EZnl9vjKxxUX8MwkEgr7CA/jBe3bCMsGE9sm7zAKAFEuRuNlCyzU/RgLAw73Cw7TDS79x0QsP2IZ5OkPIPY1+v73+hCV9fXkOznqJipTGwUd4gzr8x8m6zr29vH++wsMt+TaFgLnScz0ySDBFTMhNOY35uY54PzMwxXfpc1Fpsva1Ay07E3T+VYrk9+X2If2ALgtzbXP2v/CEv8e1PL2vSj23i7A4B3zIQPg+xzl510YRNg5F/3rxhHZ7+qnCxLSGxgufz1XH3/cL+kvf+hueh5kAGD0BjIs80kEN/XxMSr6FN06EiYqSBPrCwnbBx0fEO8NzhMF6TPw+wToTArL5Pm/Sijw4yDwz939O6DO1dXD8fjc3t/yC/3ZBI6F9c/rDsgBK8EaKBL25vLx3d31INS9AhYHA/fizeQcBuoQIufMyvj6BQgU8O/UGwMf+9D//XQLR+HRbTLq9McgQgjno8r2E7TeYTDc7uLZ5vQcDgz04SYCCgTYFBDDAkAnBQ8hKMPPXfYhHPXl7ifC+vo+C/gmvQwbJ+V77vq/U8AUE/UhGBE4TgfxNpv3c6AyMyMiGyXY9QjcKtMC6QBD+PfzMvLlBAD48h73HQ8J2iX4MtI2KfX49eYnLQ7m7+VFJidiQgAqe5vtrXXgOAoMqE/LOD9fwgkk87HwJdIj3g4RygUV+Qc/OA8btOcE5sEcvcwr0boo9Ci+2wAjJcsE780LFQ7e/BjWHRYHHAwlJ9ntQcTO/gFSJxPp1eq93d4gZlF/JEPTAb3M/CMUHEdW3fet3gwJ6QIOHOkH5y0HEdsA7R8aKOXwEQXrFxhgyTTt8voBMt5WyyYCzNzzPKuIIAf0Fkb5oia04ewP5AcGKDVYAyYS+OrpMyX3DeAZ6xsfFBL38wEV6PMnD/Xj3BIPCBsVov/qMUL/Bv3Y7gYcDCHFPjzQWv9sCRL+G02/UtDa7fV/MkIS8+o82ijy5vMmQzkeIRokJu8b5BQMwBIF3+UN5iAj+9DyXCvR8igLM0IWwfDDBOQbFN/i6+PLH9gYK/ztFUMUZPCjTvruzNv3QuH4GhIEGOoR/vMbAAju5wXr6PkSoxUHArVFMvvx7zzWNwH8AwouEPMt+fbUlDEC8cD0uCDa0wrKDfPl3MA6wptYqrnZ94AgD/w28Nnm3C4wwPYTHvMi+DI86vr14gUyIDgAGQZEC+Mt9/QEARLPANrtWh0jMwjQYP/09+DBv/kmWRyr5OnngDhP3GP62wfzu9LjGUDrEQEqvgFQGuAVDw8GBvYPfwUmG1fH5wtI6/sL875OJP0p6wjfF0kcOef7BOrRDwTHuCEBEgI1uZ3r/ZFsR/JSGT3QBQnN7Of9Dt8O/d4WDO3a8AIVEBrhSyzhEBpCEffq6hbUFhsCOvIKt9Y358NI/x7G5z8a0Nga4jwI7//u7Cvs/OR/lh1GQOUn3/uo2MwaLO8XAs8W9/hWMdXEAQotJMv8ISYwuAETFb8E+8Ib5xH6BtPZ0gQaf/cS3+79IQL7D+bqi8HvxT22B9HGgL0P8IAMAhQJ0NgrA9jw2vrq5PDF6gb7C/S+2BvC1O0m/Sf4KOgNFTLE6jXj+gEWxQAR2XOAqwAA0KsAANC0AAAgAAAAGAAAAA51");
|
|
base64DecodeToExistingUint8Array(bufferView, 48048, "j6gfgILDVd12gMN/gO+Af2j3gCEtfwVTVICrgNMwy4Auf+99ddeLpYG8/6ewIGoHpLsAALC7AAAYAAAAAgAAAAE=");
|
|
base64DecodeToExistingUint8Array(bufferView, 48132, "BcEjPel9oz0llvQ94nQiPqwcSj7dJXE+NLqLPrR3nj7kv7A+rYjCPiXJ0z4YeuQ+GJX0PsgKAj8cfAk/SZ0QP8ptFz/A7R0/nx0kP1T+KT8ukS8/4Nc0P2PUOT/wiD4/0/dCP6sjRz8XD0s/2LxOP60vUj9qalU/zm9YP5pCWz+O5V0/S1tgP26mYj9kyWQ/m8ZmP2+gaD/3WGo/gPJrP99ubT8L0G4/yhdwP+BHcT/hYXI/TWdzP5ZZdD8MOnU//wl2P4rKdj+7fHc/wCF4P2K6eD+dR3k/S8p5PyRDej/ysno/Oxp7P8h5ez8g0ns/yCN8PzdvfD/ytHw/XvV8P+AwfT/sZ30/t5p9P7TJfT8G9X0/ER1+PxhCfj9OZH4/04N+P/2gfj/tu34/w9R+P7Prfj/vAH8/hxR/P40mfz9DN38/qkZ/P+NUfz8PYn8/L25/P2R5fz++g38/P41/PxiWfz84nn8/wqV/P6Osfz8Qs38/9bh/P3e+fz9yw38/Gch/P2zMfz9b0H8/BtR/P2/Xfz+D2n8/Zt1/PxXgfz+C4n8/zeR/P+bmfz/N6H8/kup/P0bsfz/I7X8/KO9/P3jwfz+m8X8/w/J/P7/zfz+69H8/lPV/P172fz8n938/z/d/P3f4fz/9+H8/lPl/Pwn6fz9/+n8/9Pp/P1n7fz+t+38/Afx/P1T8fz+Y/H8/2/x/Px79fz9Q/X8/gv1/P7X9fz/n/X8/Cf5/Pzv+fz9d/n8/fv5/P4/+fz+w/n8/0v5/P+P+fz/0/n8/Ff9/Pyb/fz83/38/R/9/P1j/fz9Y/38/af9/P3r/fz96/38/i/9/P5v/fz+b/38/m/9/P6z/fz+s/38/vf9/P73/fz+9/38/zv9/P87/fz/O/38/zv9/P87/fz/e/38/3v9/P97/fz/e/38/3v9/P97/fz/v/38/7/9/P+//fz/v/38/7/9/P+//fz/v/38/7/9/P+//fz/v/38/7/9/P+//fz/v/38/AACAPwAAgD8AAIA/AACAPwAAgD8AAIA/AACAPwAAgD8AAIA/AACAPwAAgD8=");
|
|
base64DecodeToExistingUint8Array(bufferView, 48944, "5lo0OHdOMznT2ck5kpEzOsxgjDph+8k6mX4JO8uAMzvVJWM7dy6MO6iKqTtFuMk7h6bsO+guCTyuZh089wIzPJP/STxPWGI8XhF8PC6Rizy9x5k8XKyoPPM8uDyBecg87l/ZPDnw6jxjKv08NQcIPRDMET3N5Bs9YVAmPcsOMT0AHzw9/oBHPcY0Uz0/OF89aYtrPUUueD1pkII9ezCJPeD3jz2K5ZY9e/mdPbEzpT0hk6w9UBi0PTPCuz1PkcM9EoTLPQKb0z0f1ts91zPkPa+07D0hWPU9qB3+PaGCAz7yBgg+x5sMPt1AET409hU+RbsaPhGQHz5UdCQ+y2cpPjNqLj6NezM+Ups4PsXJPT4cBkM+WVBIPnqoTT63DVM+UoBYPggAXj5UjGM+8iRpPiXKbj4ke3Q+rDd6PgAAgD6r6YI++diFPoXNiD5Qx4s+N8aOPvfJkT6z0pQ+JuCXPg/ymj5sCJ4+HCOhPv9BpD7QZKc+sYuqPhy2rT5U5LA+0xW0PrpKtz7ogro++b29Pg38wD7iPMQ+VoDHPkfGyj6VDs4++1jRPnql1D7x89c+HETbPtmV3j4I6eE+pz3lPlOT6D4M6us+r0HvPhya8j4O8/U+iEz5PiKm/D4AAAA/76wBP7xZAz95BgU/8rIGPylfCD/6Cgo/VrYLPyxhDT98Cw8/E7UQP/JdEj8IBhQ/Q60VP4JTFz+2+Bg/3JwaP9U/HD+P4R0/+YEfPwQhIT+MviI/o1okPxf1JT/WjSc/8iQpPyi6Kj+YTSw/Ad8tP3JuLz/K+zA/+YYyP+0PND+nljU/BBs3P+WcOD9YHDo/PZk7P4MTPT8qiz4/AABAPxVyQT834UI/d01EP8O2RT/rHEc//n9IP+zfST+SPEs/4ZVMP+rrTT95Pk8/j41QPyvZUT8dIVM/c2VUPw2mVT/r4lY//BtYPy9RWT9zglo/ya9bPw7ZXD9D/l0/WB9fP0s8YD/8VGE/amliP4V5Yz88hWQ/oIxlP36PZj/WjWc/uodoP/Z8aT+cbWo/illrP9FAbD9PI20/BAFuP/HZbj/zrW8/HH1wP0lHcT98DHI/tMxyP/CHcz8QPnQ/E+90P/qadT+zQXY/P+N2P41/dz+tFng/fqh4PwE1eT80vHk/GD56P526ej/CMXs/d6N7P7sPfD+fdnw/Ath8P/QzfT9lin0/RNt9P7Mmfj+PbH4/66x+P6Pnfj/aHH8/f0x/P4F2fz8Cm38/0Ll/PxzTfz/F5n8/y/R/Py/9fz8AAIA/BAAAAAgAAAAMAAAAEAAAABQAAAAYAAAAHAAAACAAAAAoAAAAMAAAADgAAABAAAAAUAAAAGAAAABwAAAAiAAAAKAAAADAAAAA8A==");
|
|
base64DecodeToExistingUint8Array(bufferView, 49986, "gD4AAIA+AACAPgAAgD4AAIA+AACAPgAAgD4AAIA+AACAPgAAgD4AAIA+AACAPgAAgD4AAIA+AACAPgAAgD7QJbQ+lzmtPgmlnz767Ys+zaxlPvipKj40MNI9WvENPVrxDb00MNK9+Kkqvs2sZb767Yu+CaWfvpc5rb7QJbS+h4qxPhuDlj5gI0k+xEKNPcRCjb1gI0m+G4OWvoeKsb6HirG+G4OWvmAjSb7EQo29xEKNPWAjST4bg5Y+h4qxPpc5rT7NrGU+WvENPfipKr4JpZ++0CW0vvrti740MNK9NDDSPfrtiz7QJbQ+CaWfPvipKj5a8Q29zaxlvpc5rb59Pac+0osKPtKLCr59Pae+fT2nvtKLCr7Siwo+fT2nPn09pz7Siwo+0osKvn09p759Pae+0osKvtKLCj59Pac+CaWfPlrxDT367Yu+lzmtvjQw0r3NrGU+0CW0PvipKj74qSq+0CW0vs2sZb40MNI9lzmtPvrtiz5a8Q29CaWfvhuDlj7EQo29h4qxvmAjSb5gI0k+h4qxPsRCjT0bg5a+G4OWvsRCjT2HirE+YCNJPmAjSb6HirG+xEKNvRuDlj767Ys++Kkqvpc5rb5a8Q090CW0PjQw0j0JpZ++zaxlvs2sZT4JpZ8+NDDSvdAltL5a8Q29lzmtPvipKj767Yu+YXNzZXJ0aW9uIGZhaWxlZDogc3QtPm1vZGUgPT0gTU9ERV9IWUJSSUQgfHwgY3Vycl9iYW5kd2lkdGggPT0gT1BVU19CQU5EV0lEVEhfV0lERUJBTkQAc3JjL29wdXNfZW5jb2Rlci5jAGFzc2VydGlvbiBmYWlsZWQ6IHN0LT5zaWxrX21vZGUuaW50ZXJuYWxTYW1wbGVSYXRlID09IDE2MDAw");
|
|
base64DecodeToExistingUint8Array(bufferView, 50672, "4C4AAOgDAACwNgAA6AMAAIA+AADoAwAAIE4AAOgDAADwVQAA6AM=");
|
|
base64DecodeToExistingUint8Array(bufferView, 50740, "4C4AABAnAAAQJwAA+CoAAPgqAACAPgAAvDQAALw0AACYOgAAmDoAACBOAACAPgAAgD4AAFBGAABQRgAAwF0AAFBGAABQRgAACFIAAAhSAAAAfQAA8FUAAPBVAABgbQAAYG0AAAD6AABwlAAAcJQAAFDDAABQwwAADQAAABEAAAARAAAAEwAAAAAAAAAIAAAABAAAAOF6VD/2KFw/nMcAABAAAAAEAAAAmplZP65HYT+cxwAAIAAAAAQAAADBymE/w/VoP5zHAAAwAAAACAAAALgeZT+DwGo/pMcAAEAAAAAIAAAAqMZrP9ejcD+kxwAAUAAAABAAAAAxCGw/16NwP6zHAABgAAAAEAAAANejcD+F63E/rMcAAIAAAAAQAAAAMzNzPzMzcz+sxwAAoAAAABAAAACPwnU/j8J1P6zHAADAAAAAIAAAANnOdz/Zznc/tMcAAAABAAAgAAAAmpl5P5qZeT+0xwAAwMcAACAAAADgyAAAIAAAAADKAAAgAAAAIMsAAEAAAAAAAAAAJZHguiDq7z8AAAAAAADwPyWR4Log6u8/3ksrz82o7z9aH/+a5jzvP1XPF7Xap+4/vqBk9qLr7T/XkG46uArtP4voz2UHCOw/td5vtOPm6j9YAHQU96rpPyJyVTQxWOg/UMWuabXy5j9Y5LYByH7lP5RFJ2y7AOQ/RytKS9184j+po+NqZPfgP6qpl6W+6N4/FsR6gkjv2z9LZsyPhQnZPz/p4VfuPdY/wmpufT+S0z+gvqdqaQvRPytyXzkIW80/J5liL5D3yD+hB8qvF/HEP8pirICMSsE/IsW+bFQKvD9hhQCFH0G2P4/ecB+5NbE/Q4TJnk7DqT8he3vfEXiiP/NHKOi855g/We0O5+l1jj8hAg6hSs1+PwAAAAAAAAAAwVNMzh7i7z8AAAAAAADwP8FTTM4e4u8/z0LImg2J7z8MbeeYf/buP4gSLXk8Le4/mk30twwx7T+1sMC6ngbsP8yZDhlms+o/3Hksx3U96T9RqyK7VqvnP5U2yU3cA+Y/davnpPdN5D93AJvei5DiPxOB6h9E0uA/xgDD0dky3j9TPgRVo9faP9kIYcE/ndc/qGoG4Z+M1D9uJH0YKa3RP1rvefZDCc4/GwBgK1cuyT9RlmsbkM7EP4vsWq3Z68A/6dYpXn4Kuz/fF/rUby61PwYNgUwAOLA/yr1E5fQvqD+mFfjtmHihP0v1U9J5Q5g/lM+f9I0BkD8Abjc9/6iDP95pGUbNmXU/4IWMy+EoYz/8qfHSTWJAPwAAAAAAAAAAuaajkCLa7z8AAAAAAADwP7mmo5Ai2u8/hQsW2ntp7z9ERs1417DuPyZTw4bAtO0/M9ouXVZ77D+pzhc5EwzrP6nqcSGHb+k/cuaRHgqv5z/W0WnEadTlP8CnpBSV6eM/OaAA5Ur44T/qgxvfzQngP1Vq1TJCTdw/Q13e+5+s2D8PWvbBhT7VPx8F28pDDdI/oGc3IxhBzj+Mi3rz4frIP/CuSIb7TMQ/dOMnH8w3wD/uYYrNIm+5PztOVcoAirM/6GEuyuhXrT8kM80qInmlP7tpbfnMgp4/Iix0b4/vlD8+Ed0W2YyLP13CX5umMoE/UAiy2AUHdD+ByCq+BBtlP9zuq5Ov21I/G8qaom1GNz8=");
|
|
base64DecodeToExistingUint8Array(bufferView, 52000, "yFEM0oT07z8AAAAAAADwP8hRDNKE9O8/9pUH6SnS7z/a08TxMpnvP9T9ENkPSu8/fp+7blvl7j9hwT+d2WvuPx3X8SV13u0/an9v7Dw+7T/J6jXBYIzsP3ckRQEuyus/Hrx+2gv56j860L80dxrqP/UlI4D+L+k/8kBDgz076D8OB1Pe2D3nP/fyr6N5OeY/TMjFIMkv5T/OuHiRbCLkP/+ZWhkBE+M/L5wx7RcD4j9j2QbNMvTgP01ahnKBz98/zY9k+zW+3T8VxjeQBbfbP+AHrag9vNk/YDMKk/PP1z/zHfzEAfTVP0qFZ/gFKtQ/5808FGBz0j+NyjQ3MtHQP9jRevDBiM4/ryd4Eiqbyz/ISJPeedrIP7XPWyMfR8Y/PVdCFB/hwz+1zQFAHajBP026kLvGNr8/LgwmONRzuz9mkgUKxAS4P4BUFsd55rQ/YkhOJm4Vsj+kFYSXhRuvP+yy6yCnlqo/l6hBRZOTpj8+eC/vWAmjP9XnrEfI3Z8/bM9NFzl2mj/08djo/8mVPw8LtaZ5x5E/VRds+h67jD/+pLEosveGPzy3lup+JYI/pfu1zFROfD9nH1R3n8J1PwXEfxU7dXA/dH+znJ1vaD/T8PMAksBhP/dS2/qnI1k/P8Gs7XlAUT/xQgCR+sJGP3uyzVM+gDw/JlGSIvCPMD/HVG5gehQhP32Jfzcgqws/8WjjiLX45D4=");
|
|
base64DecodeToExistingUint8Array(bufferView, 52545, "0VAAAAAAAAU=");
|
|
base64DecodeToExistingUint8Array(bufferView, 52564, "AQ==");
|
|
base64DecodeToExistingUint8Array(bufferView, 52588, "AgAAAAMAAAC40A==");
|
|
base64DecodeToExistingUint8Array(bufferView, 52612, "Ag==");
|
|
base64DecodeToExistingUint8Array(bufferView, 52627, "//////8=");
|
|
base64DecodeToExistingUint8Array(bufferView, 52868, "4NA=");
|
|
}
|
|
|
|
var scratchBuffer = new ArrayBuffer(16);
|
|
var i32ScratchView = new Int32Array(scratchBuffer);
|
|
var f32ScratchView = new Float32Array(scratchBuffer);
|
|
var f64ScratchView = new Float64Array(scratchBuffer);
|
|
|
|
function wasm2js_scratch_load_i32(index) {
|
|
return i32ScratchView[index];
|
|
}
|
|
|
|
function wasm2js_scratch_store_i32(index, value) {
|
|
i32ScratchView[index] = value;
|
|
}
|
|
|
|
function wasm2js_scratch_load_f64() {
|
|
return f64ScratchView[0];
|
|
}
|
|
|
|
function wasm2js_scratch_store_f64(value) {
|
|
f64ScratchView[0] = value;
|
|
}
|
|
|
|
function wasm2js_scratch_store_f32(value) {
|
|
f32ScratchView[2] = value;
|
|
}
|
|
|
|
function wasm2js_scratch_load_f32() {
|
|
return f32ScratchView[2];
|
|
}
|
|
|
|
function asmFunc(env) {
|
|
var memory = env.memory;
|
|
var buffer = memory.buffer;
|
|
var HEAP8 = new Int8Array(buffer);
|
|
var HEAP16 = new Int16Array(buffer);
|
|
var HEAP32 = new Int32Array(buffer);
|
|
var HEAPU8 = new Uint8Array(buffer);
|
|
var HEAPU16 = new Uint16Array(buffer);
|
|
var HEAPU32 = new Uint32Array(buffer);
|
|
var HEAPF32 = new Float32Array(buffer);
|
|
var HEAPF64 = new Float64Array(buffer);
|
|
var Math_imul = Math.imul;
|
|
var Math_fround = Math.fround;
|
|
var Math_abs = Math.abs;
|
|
var Math_clz32 = Math.clz32;
|
|
var Math_min = Math.min;
|
|
var Math_max = Math.max;
|
|
var Math_floor = Math.floor;
|
|
var Math_ceil = Math.ceil;
|
|
var Math_trunc = Math.trunc;
|
|
var Math_sqrt = Math.sqrt;
|
|
var abort = env.abort;
|
|
var nan = NaN;
|
|
var infinity = Infinity;
|
|
var emscripten_resize_heap = env.emscripten_resize_heap;
|
|
var emscripten_memcpy_big = env.emscripten_memcpy_big;
|
|
var __wasi_fd_close = env.fd_close;
|
|
var __wasi_fd_write = env.fd_write;
|
|
var abort = env.abort;
|
|
var setTempRet0 = env.setTempRet0;
|
|
var legalimport$__wasi_fd_seek = env.fd_seek;
|
|
var __stack_pointer = 5296384;
|
|
var i64toi32_i32$HIGH_BITS = 0;
|
|
// EMSCRIPTEN_START_FUNCS
|
|
function opus_encode_native($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) {
|
|
var $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = Math_fround(0), $18 = 0, $19 = 0, $20 = 0, $21 = Math_fround(0), $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = Math_fround(0), $27 = 0, $28 = Math_fround(0), $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = Math_fround(0), $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = Math_fround(0), $48 = Math_fround(0), $49 = Math_fround(0), $50 = 0, $51 = 0, $52 = 0;
|
|
$15 = __stack_pointer - 624 | 0;
|
|
__stack_pointer = $15;
|
|
$14 = $15;
|
|
HEAP32[$14 + 616 >> 2] = 0;
|
|
HEAP32[$0 + 18136 >> 2] = 0;
|
|
$13 = -1;
|
|
label$1 : {
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$23 = ($4 | 0) < 1276 ? $4 : 1276;
|
|
if (($23 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
if (($23 | 0) == 1) {
|
|
$13 = -2;
|
|
if (HEAP32[$0 + 144 >> 2] == (Math_imul($2, 10) | 0)) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$19 = HEAP32[$0 >> 2] + $0 | 0;
|
|
$22 = HEAP32[$0 + 4 >> 2];
|
|
$38 = HEAP32[$0 + 108 >> 2] != 2051 ? HEAP32[$0 + 116 >> 2] : $38;
|
|
$13 = HEAP32[$0 + 168 >> 2];
|
|
HEAP32[$14 + 416 >> 2] = $14 + 612;
|
|
opus_custom_encoder_ctl($19, 10015, $14 + 416 | 0);
|
|
HEAP32[$14 + 544 >> 2] = 0;
|
|
$20 = ($5 | 0) < ($13 | 0) ? $5 : $13;
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
if (HEAP32[$0 + 44 >> 2] < 7) {
|
|
break label$9;
|
|
}
|
|
$29 = HEAP32[$0 + 144 >> 2];
|
|
if (($29 | 0) < 16e3) {
|
|
break label$9;
|
|
}
|
|
$41 = 1;
|
|
$5 = Math_imul(HEAP32[$0 + 112 >> 2], $2);
|
|
if (($5 | 0) >= 1) {
|
|
$13 = 0;
|
|
while (1) {
|
|
$16 = HEAPF32[($13 << 2) + $1 >> 2];
|
|
$21 = $16 > $21 ? $21 : $16;
|
|
$17 = $16 < $17 ? $17 : $16;
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$24 = HEAP32[$0 + 7640 >> 2];
|
|
$30 = HEAP32[$0 + 7636 >> 2];
|
|
run_analysis($0 + 188 | 0, HEAP32[$14 + 612 >> 2], $6, $7, $2, $8, $9, $10, $29, $20, $11, $14 + 544 | 0);
|
|
$16 = Math_fround(-$21);
|
|
$5 = 0;
|
|
if (Math_fround(Math_fround(1) / Math_fround(1 << $20)) >= ($16 < $17 ? $17 : $16)) {
|
|
break label$4;
|
|
}
|
|
if (HEAPF32[$14 + 580 >> 2] > Math_fround(.10000000149011612) ^ 1) {
|
|
break label$5;
|
|
}
|
|
$21 = Math_fround(HEAPF32[$0 + 18128 >> 2] * Math_fround(.9990000128746033));
|
|
$5 = Math_imul(HEAP32[$0 + 112 >> 2], $2);
|
|
if (($5 | 0) < 1) {
|
|
break label$8;
|
|
}
|
|
$13 = 0;
|
|
$16 = Math_fround(0);
|
|
while (1) {
|
|
$17 = HEAPF32[($13 << 2) + $1 >> 2];
|
|
$16 = Math_fround($16 + Math_fround($17 * $17));
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$26 = Math_fround($5 | 0);
|
|
if (Math_fround($16 / $26) < $21) {
|
|
break label$6;
|
|
}
|
|
$13 = 0;
|
|
$16 = Math_fround(0);
|
|
while (1) {
|
|
$17 = HEAPF32[($13 << 2) + $1 >> 2];
|
|
$16 = Math_fround($16 + Math_fround($17 * $17));
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$7;
|
|
}
|
|
$24 = -1;
|
|
if (HEAP32[$0 + 7648 >> 2]) {
|
|
tonality_analysis_reset($0 + 188 | 0);
|
|
}
|
|
$30 = -1;
|
|
break label$5;
|
|
}
|
|
$16 = Math_fround(0);
|
|
$26 = Math_fround($5 | 0);
|
|
if (Math_fround(Math_fround(0) / $26) < $21) {
|
|
break label$6;
|
|
}
|
|
}
|
|
$21 = Math_fround($16 / $26);
|
|
}
|
|
HEAPF32[$0 + 18128 >> 2] = $21;
|
|
}
|
|
HEAP32[$0 + 140 >> 2] = -1;
|
|
$41 = 0;
|
|
$5 = 1;
|
|
}
|
|
$51 = $5;
|
|
HEAP32[$0 + 18120 >> 2] = 0;
|
|
if (HEAP32[$14 + 544 >> 2]) {
|
|
if (HEAP32[$0 + 124 >> 2] == -1e3) {
|
|
$5 = $0;
|
|
label$19 : {
|
|
label$20 : {
|
|
$13 = HEAP32[$0 + 14228 >> 2];
|
|
if (($13 | 0) != 1002) {
|
|
if ($13) {
|
|
break label$20;
|
|
}
|
|
$13 = $14 + 564 | 0;
|
|
break label$19;
|
|
}
|
|
$13 = $14 + 572 | 0;
|
|
break label$19;
|
|
}
|
|
$13 = $14 + 568 | 0;
|
|
}
|
|
$46 = Math_floor(+Math_fround(Math_fround(Math_fround(1) - HEAPF32[$13 >> 2]) * Math_fround(100)) + .5);
|
|
label$18 : {
|
|
if (Math_abs($46) < 2147483648) {
|
|
$13 = ~~$46;
|
|
break label$18;
|
|
}
|
|
$13 = -2147483648;
|
|
}
|
|
HEAP32[$5 + 140 >> 2] = $13;
|
|
}
|
|
$6 = $0;
|
|
$5 = HEAP32[$14 + 576 >> 2];
|
|
$13 = 1101;
|
|
label$23 : {
|
|
if (($5 | 0) < 13) {
|
|
break label$23;
|
|
}
|
|
$13 = 1102;
|
|
if (($5 | 0) < 15) {
|
|
break label$23;
|
|
}
|
|
$13 = 1103;
|
|
if (($5 | 0) < 17) {
|
|
break label$23;
|
|
}
|
|
$13 = ($5 | 0) < 19 ? 1104 : 1105;
|
|
}
|
|
HEAP32[$6 + 18120 >> 2] = $13;
|
|
}
|
|
$16 = Math_fround(0);
|
|
if (!(HEAP32[$0 + 120 >> 2] == 1 | HEAP32[$0 + 112 >> 2] != 2)) {
|
|
$16 = compute_stereo_width($1, $2, HEAP32[$0 + 144 >> 2], $0 + 14260 | 0);
|
|
}
|
|
$5 = $2 ? $2 : HEAP32[$0 + 144 >> 2] / 400 | 0;
|
|
label$26 : {
|
|
label$27 : {
|
|
$13 = HEAP32[$0 + 164 >> 2];
|
|
if (($13 | 0) != -1e3) {
|
|
if (($13 | 0) == -1) {
|
|
break label$27;
|
|
}
|
|
$6 = HEAP32[$0 + 144 >> 2];
|
|
break label$26;
|
|
}
|
|
$6 = HEAP32[$0 + 144 >> 2];
|
|
$13 = Math_imul($6, HEAP32[$0 + 112 >> 2]) + ((Math_imul($6, 60) | 0) / ($5 | 0) | 0) | 0;
|
|
break label$26;
|
|
}
|
|
$6 = HEAP32[$0 + 144 >> 2];
|
|
$13 = (Math_imul($23, $6) << 3) / ($5 | 0) | 0;
|
|
}
|
|
HEAP32[$0 + 160 >> 2] = $13;
|
|
$5 = ($6 | 0) / ($2 | 0) | 0;
|
|
label$29 : {
|
|
label$30 : {
|
|
label$31 : {
|
|
$7 = HEAP32[$0 + 148 >> 2];
|
|
label$32 : {
|
|
if (!$7) {
|
|
$8 = (Math_imul($6, 12) | 0) / ($2 | 0) | 0;
|
|
$13 = ((($8 | 0) / 2 | 0) + ((Math_imul($13, 12) | 0) / 8 | 0) | 0) / ($8 | 0) | 0;
|
|
$23 = ($13 | 0) < ($23 | 0) ? $13 : $23;
|
|
$13 = (Math_imul($8, $23) << 3) / 12 | 0;
|
|
HEAP32[$0 + 160 >> 2] = $13;
|
|
$8 = 1;
|
|
if (($23 | 0) < 2) {
|
|
break label$32;
|
|
}
|
|
}
|
|
label$34 : {
|
|
if (($23 | 0) < 3 | (Math_imul($5, 24) | 0) > ($13 | 0)) {
|
|
break label$34;
|
|
}
|
|
$29 = Math_imul($5, $23);
|
|
if (($5 | 0) > 49) {
|
|
break label$31;
|
|
}
|
|
if (($29 | 0) < 300) {
|
|
break label$34;
|
|
}
|
|
if (($13 | 0) >= 2400) {
|
|
break label$30;
|
|
}
|
|
}
|
|
$8 = $23;
|
|
}
|
|
$13 = HEAP32[$0 + 14240 >> 2];
|
|
$13 = $13 ? $13 : 1101;
|
|
$6 = 0;
|
|
$2 = HEAP32[$0 + 14224 >> 2];
|
|
$15 = ($5 | 0) > 100 ? 1002 : $2 ? $2 : 1e3;
|
|
$1 = ($5 | 0) == 25 & ($15 | 0) != 1e3;
|
|
$23 = $1 ? 50 : $5;
|
|
label$35 : {
|
|
if (($23 | 0) > 16) {
|
|
$2 = $23;
|
|
break label$35;
|
|
}
|
|
if (!(($23 | 0) == 10 | ($15 | 0) != 1e3 ? ($4 | 0) != 1 : 0)) {
|
|
$1 = ($23 | 0) < 13;
|
|
$15 = 1e3;
|
|
$2 = ($23 | 0) == 12 ? 25 : 16;
|
|
break label$35;
|
|
}
|
|
$6 = 50 / ($23 | 0) | 0;
|
|
$1 = 3;
|
|
$2 = 50;
|
|
}
|
|
label$39 : {
|
|
if (($13 | 0) >= 1104) {
|
|
$4 = 1103;
|
|
if (($15 | 0) == 1e3) {
|
|
break label$39;
|
|
}
|
|
}
|
|
if (($13 | 0) == 1102) {
|
|
$4 = 1101;
|
|
if (($15 | 0) == 1002) {
|
|
break label$39;
|
|
}
|
|
}
|
|
$4 = ($13 | 0) < 1105 ? ($15 | 0) == 1001 ? 1104 : $13 : $13;
|
|
}
|
|
$23 = HEAP32[$0 + 14192 >> 2];
|
|
$13 = 0;
|
|
if (($2 | 0) <= 399) {
|
|
while (1) {
|
|
$13 = $13 + 1 | 0;
|
|
$2 = $2 << 1;
|
|
if (($2 | 0) < 400) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = $13 << 3;
|
|
}
|
|
$2 = $3;
|
|
label$44 : {
|
|
label$45 : {
|
|
switch ($15 - 1e3 | 0) {
|
|
case 0:
|
|
$13 = $13 - 16 | ($4 << 5) + 96 & 224;
|
|
break label$44;
|
|
case 2:
|
|
$13 = ((($4 | 0) > 1102 ? $4 : 1102) << 5) - -64 & 96 | $13 | 128;
|
|
break label$44;
|
|
default:
|
|
break label$45;
|
|
}
|
|
}
|
|
$13 = $13 + 240 | $4 << 4 | 96;
|
|
}
|
|
HEAP8[$2 | 0] = $13 | ((($23 | 0) == 2) << 2 | $1);
|
|
$13 = $1 >>> 0 < 2;
|
|
if (($1 | 0) == 3) {
|
|
HEAP8[$3 + 1 | 0] = $6;
|
|
}
|
|
$13 = $13 ? 1 : 2;
|
|
if (HEAP32[$0 + 148 >> 2]) {
|
|
break label$1;
|
|
}
|
|
$0 = ($8 | 0) > ($13 | 0) ? $8 : $13;
|
|
$13 = opus_packet_pad($3, $13, $0) ? -3 : $0;
|
|
break label$1;
|
|
}
|
|
$42 = $29 << 3;
|
|
$9 = HEAP32[$0 + 40 >> 2];
|
|
$34 = HEAP32[$0 + 44 >> 2];
|
|
$8 = HEAP32[$0 + 112 >> 2];
|
|
$10 = $13;
|
|
if (($5 | 0) == 50) {
|
|
break label$29;
|
|
}
|
|
$44 = 1;
|
|
$10 = Math_imul(Math_imul($8, -40) - 20 | 0, $5 - 50 | 0) + $13 | 0;
|
|
break label$29;
|
|
}
|
|
$42 = $29 << 3;
|
|
$9 = HEAP32[$0 + 40 >> 2];
|
|
$34 = HEAP32[$0 + 44 >> 2];
|
|
$8 = HEAP32[$0 + 112 >> 2];
|
|
$10 = $13;
|
|
}
|
|
$10 = $7 ? $10 : (($10 | 0) / -12 | 0) + $10 | 0;
|
|
$32 = $34 + 90 | 0;
|
|
$25 = (Math_imul($10, $32) | 0) / 100 | 0;
|
|
$36 = Math_imul($9, 12) + 20 | 0;
|
|
$18 = (Math_imul($25, $9) | 0) / ($36 | 0) | 0;
|
|
$10 = 127;
|
|
label$49 : {
|
|
label$50 : {
|
|
switch (HEAP32[$0 + 124 >> 2] - 3001 | 0) {
|
|
case 1:
|
|
$10 = 0;
|
|
break label$49;
|
|
case 0:
|
|
break label$49;
|
|
default:
|
|
break label$50;
|
|
}
|
|
}
|
|
$10 = HEAP32[$0 + 140 >> 2];
|
|
if (($10 | 0) >= 0) {
|
|
$10 = Math_imul($10, 327) >> 8;
|
|
if (HEAP32[$0 + 108 >> 2] != 2049) {
|
|
break label$49;
|
|
}
|
|
$10 = ($10 | 0) < 115 ? $10 : 115;
|
|
break label$49;
|
|
}
|
|
$10 = HEAP32[$0 + 108 >> 2] == 2048 ? 115 : 48;
|
|
}
|
|
$11 = HEAP32[$0 + 120 >> 2];
|
|
label$53 : {
|
|
label$54 : {
|
|
if (($11 | 0) != -1e3) {
|
|
if (($8 | 0) != 2) {
|
|
break label$54;
|
|
}
|
|
HEAP32[$0 + 14192 >> 2] = $11;
|
|
$8 = $11;
|
|
break label$53;
|
|
}
|
|
if (($8 | 0) != 2) {
|
|
break label$54;
|
|
}
|
|
$8 = ((Math_imul(Math_imul($10, $10), 2e3) >>> 14 | 0) + (HEAP32[$0 + 14192 >> 2] == 2 ? 16e3 : 18e3) | 0) < ($25 - $18 | 0) ? 2 : 1;
|
|
}
|
|
HEAP32[$0 + 14192 >> 2] = $8;
|
|
}
|
|
$25 = !(HEAP32[$14 + 544 >> 2] | $41) & HEAP32[$0 + 184 >> 2] != 0;
|
|
HEAP32[$0 + 56 >> 2] = $25;
|
|
$11 = $44 ? Math_imul(Math_imul($8, -40) - 20 | 0, $5 - 50 | 0) + $13 | 0 : $13;
|
|
$11 = $7 ? $11 : (($11 | 0) / -12 | 0) + $11 | 0;
|
|
$11 = (Math_imul($32, $11) | 0) / 100 | 0;
|
|
$27 = (Math_imul($11, $9) | 0) / ($36 | 0) | 0;
|
|
$33 = HEAP32[$0 + 108 >> 2];
|
|
label$57 : {
|
|
if (($33 | 0) == 2051) {
|
|
$11 = 1002;
|
|
HEAP32[$0 + 14224 >> 2] = 1002;
|
|
$25 = $0 + 14224 | 0;
|
|
$33 = (($6 | 0) / 100 | 0) > ($2 | 0);
|
|
break label$57;
|
|
}
|
|
$18 = HEAP32[$0 + 136 >> 2];
|
|
label$59 : {
|
|
if (($18 | 0) == -1e3) {
|
|
$31 = $0;
|
|
$27 = $11 - $27 | 0;
|
|
$17 = Math_fround(Math_fround(1) - $16);
|
|
$21 = Math_fround(Math_fround($16 * Math_fround(1e4)) + Math_fround($17 * Math_fround(1e4)));
|
|
label$61 : {
|
|
if (Math_fround(Math_abs($21)) < Math_fround(2147483648)) {
|
|
$18 = ~~$21;
|
|
break label$61;
|
|
}
|
|
$18 = -2147483648;
|
|
}
|
|
$39 = $18;
|
|
$16 = Math_fround(Math_fround($16 * Math_fround(44e3)) + Math_fround($17 * Math_fround(64e3)));
|
|
label$63 : {
|
|
if (Math_fround(Math_abs($16)) < Math_fround(2147483648)) {
|
|
$11 = ~~$16;
|
|
break label$63;
|
|
}
|
|
$11 = -2147483648;
|
|
}
|
|
$11 = $39 + (Math_imul($11 - $18 | 0, Math_imul($10, $10)) >> 14) | 0;
|
|
$11 = ($33 | 0) == 2048 ? $11 + 8e3 | 0 : $11;
|
|
$18 = HEAP32[$0 + 14228 >> 2];
|
|
$18 = ($27 | 0) < ((($18 | 0) == 1002 ? $11 - 4e3 | 0 : ($18 | 0) > 0 ? $11 + 4e3 | 0 : $11) | 0) ? 1e3 : 1002;
|
|
HEAP32[$31 + 14224 >> 2] = $18;
|
|
if (!(!HEAP32[$0 + 48 >> 2] | 128 - $10 >> 4 >= ($9 | 0))) {
|
|
HEAP32[$0 + 14224 >> 2] = 1e3;
|
|
$18 = 1e3;
|
|
}
|
|
$11 = (Math_imul($44 ? 9e3 : 6e3, $2) | 0) / ($6 << 3) | 0;
|
|
if (($23 | 0) >= ($11 | 0) ? !(($10 | 0) > 100 & $25) : 0) {
|
|
break label$59;
|
|
}
|
|
$18 = ($11 | 0) > ($23 | 0) ? 1002 : 1e3;
|
|
}
|
|
HEAP32[$0 + 14224 >> 2] = $18;
|
|
}
|
|
$25 = $0 + 14224 | 0;
|
|
$6 = ($6 | 0) / 100 | 0;
|
|
$33 = ($6 | 0) > ($2 | 0);
|
|
if (($2 | 0) >= ($6 | 0)) {
|
|
$11 = $18;
|
|
break label$57;
|
|
}
|
|
$11 = 1002;
|
|
if (($18 | 0) == 1002) {
|
|
$11 = $18;
|
|
break label$57;
|
|
}
|
|
HEAP32[$25 >> 2] = 1002;
|
|
}
|
|
if (HEAP32[$0 + 176 >> 2]) {
|
|
HEAP32[$25 >> 2] = 1002;
|
|
$11 = 1002;
|
|
}
|
|
$27 = 0;
|
|
label$69 : {
|
|
label$70 : {
|
|
label$71 : {
|
|
$18 = HEAP32[$0 + 14228 >> 2];
|
|
if (($18 | 0) < 1) {
|
|
break label$71;
|
|
}
|
|
if (!(($11 | 0) != 1002 ? ($18 | 0) == 1002 : 0)) {
|
|
if (($11 | 0) != 1002) {
|
|
break label$71;
|
|
}
|
|
$6 = 1002;
|
|
if (($18 | 0) == 1002) {
|
|
break label$70;
|
|
}
|
|
}
|
|
$6 = 1002;
|
|
$45 = 1;
|
|
label$73 : {
|
|
if (($11 | 0) != 1002) {
|
|
$43 = 1;
|
|
$6 = $11;
|
|
break label$73;
|
|
}
|
|
$31 = 0;
|
|
if ($33) {
|
|
break label$69;
|
|
}
|
|
HEAP32[$25 >> 2] = $18;
|
|
$45 = 0;
|
|
$27 = 1;
|
|
$6 = $18;
|
|
}
|
|
$31 = 1;
|
|
break label$69;
|
|
}
|
|
$6 = $11;
|
|
}
|
|
$45 = 1;
|
|
$31 = 0;
|
|
}
|
|
label$75 : {
|
|
label$76 : {
|
|
if (($8 | 0) != 1 | HEAP32[$0 + 14232 >> 2] != 2 | (HEAP32[$0 + 68 >> 2] | ($18 | 0) == 1002)) {
|
|
break label$76;
|
|
}
|
|
if (($6 | 0) == 1002) {
|
|
break label$76;
|
|
}
|
|
$8 = 2;
|
|
HEAP32[$0 + 14192 >> 2] = 2;
|
|
HEAP32[$0 + 68 >> 2] = 1;
|
|
break label$75;
|
|
}
|
|
HEAP32[$0 + 68 >> 2] = 0;
|
|
}
|
|
$33 = $0 + $22 | 0;
|
|
$13 = $44 ? Math_imul(Math_imul($8, -40) - 20 | 0, $5 - 50 | 0) + $13 | 0 : $13;
|
|
$13 = $7 ? $13 : (($13 | 0) / -12 | 0) + $13 | 0;
|
|
$8 = (Math_imul($32, $13) | 0) / 100 | 0;
|
|
$39 = $0;
|
|
label$78 : {
|
|
label$79 : {
|
|
label$80 : {
|
|
label$81 : {
|
|
label$82 : {
|
|
label$83 : {
|
|
label$84 : {
|
|
if (($6 & -2) == 1e3) {
|
|
$7 = 1;
|
|
$11 = 1002;
|
|
$32 = 0;
|
|
$8 = ($34 | 0) <= 1 ? ($8 << 2) / 5 | 0 : $8;
|
|
$8 = $8 - ((Math_imul($8, $9) | 0) / (Math_imul($9, 6) + 10 | 0) | 0) | 0;
|
|
$9 = $8;
|
|
if (($6 | 0) != 1002) {
|
|
break label$84;
|
|
}
|
|
break label$83;
|
|
}
|
|
$11 = 1002;
|
|
if (($6 | 0) == 1002) {
|
|
$32 = 0;
|
|
$7 = 1;
|
|
if (($34 | 0) > 4) {
|
|
break label$83;
|
|
}
|
|
$8 = (Math_imul($8, 9) | 0) / 10 | 0;
|
|
break label$83;
|
|
}
|
|
$9 = $8 - ((Math_imul($8, $9) | 0) / ($36 | 0) | 0) | 0;
|
|
}
|
|
$8 = $9;
|
|
$32 = 0;
|
|
if (($18 | 0) == 1002) {
|
|
silk_InitEncoder($33, HEAP32[$0 + 180 >> 2], $14 + 440 | 0);
|
|
$32 = 1;
|
|
$6 = HEAP32[$0 + 14224 >> 2];
|
|
}
|
|
$7 = 1;
|
|
if (($6 | 0) == 1002) {
|
|
break label$83;
|
|
}
|
|
$7 = 0;
|
|
if (HEAP32[$0 + 84 >> 2] ? 0 : !HEAP32[$0 + 14252 >> 2]) {
|
|
break label$82;
|
|
}
|
|
$11 = $6;
|
|
}
|
|
$13 = Math_imul($10, $10);
|
|
$9 = (Math_imul($13, 2e3) >> 14) + 12e3 | 0;
|
|
$10 = (Math_imul($13, 2500) >> 14) + 11e3 | 0;
|
|
label$89 : {
|
|
label$90 : {
|
|
$6 = HEAP32[$0 + 14252 >> 2];
|
|
if (!$6) {
|
|
$13 = 1105;
|
|
$22 = 1;
|
|
if (((HEAP32[$0 + 14244 >> 2] < 1105 ? 2e3 : -2e3) + $9 | 0) <= ($8 | 0)) {
|
|
break label$80;
|
|
}
|
|
if ($6) {
|
|
break label$89;
|
|
}
|
|
if (HEAP32[$0 + 14244 >> 2] < 1104) {
|
|
break label$90;
|
|
}
|
|
$10 = $10 - 1e3 | 0;
|
|
break label$89;
|
|
}
|
|
if (($8 | 0) < ($9 | 0)) {
|
|
break label$89;
|
|
}
|
|
HEAP32[$0 + 14240 >> 2] = 1105;
|
|
HEAP32[$0 + 14244 >> 2] = 1105;
|
|
$13 = 1105;
|
|
break label$79;
|
|
}
|
|
$10 = $10 + 1e3 | 0;
|
|
}
|
|
if (($8 | 0) >= ($10 | 0)) {
|
|
$13 = 1104;
|
|
$22 = 1;
|
|
break label$80;
|
|
}
|
|
if (!$6) {
|
|
$13 = 1103;
|
|
$22 = 0;
|
|
if (((HEAP32[$0 + 14244 >> 2] < 1103 ? 9700 : 8300) | 0) <= ($8 | 0)) {
|
|
break label$80;
|
|
}
|
|
$13 = 9e3;
|
|
if ($6) {
|
|
break label$81;
|
|
}
|
|
$13 = HEAP32[$0 + 14244 >> 2] < 1102 ? 9700 : 8300;
|
|
break label$81;
|
|
}
|
|
$13 = 9e3;
|
|
if (($8 | 0) < 9e3) {
|
|
break label$81;
|
|
}
|
|
HEAP32[$0 + 14240 >> 2] = 1103;
|
|
HEAP32[$0 + 14244 >> 2] = 1103;
|
|
$13 = 1103;
|
|
break label$79;
|
|
}
|
|
$13 = HEAP32[$0 + 14240 >> 2];
|
|
break label$78;
|
|
}
|
|
$13 = ($8 | 0) < ($13 | 0) ? 1101 : 1103;
|
|
$22 = 0;
|
|
}
|
|
HEAP32[$39 + 14240 >> 2] = $13;
|
|
HEAP32[$0 + 14244 >> 2] = $13;
|
|
if ($6 | $7 | (HEAP32[$0 + 88 >> 2] | $22 ^ 1)) {
|
|
break label$79;
|
|
}
|
|
$13 = 1103;
|
|
HEAP32[$0 + 14240 >> 2] = 1103;
|
|
}
|
|
$6 = $11;
|
|
}
|
|
$9 = HEAP32[$0 + 132 >> 2];
|
|
if (($13 | 0) > ($9 | 0)) {
|
|
HEAP32[$0 + 14240 >> 2] = $9;
|
|
$13 = $9;
|
|
}
|
|
$9 = HEAP32[$0 + 128 >> 2];
|
|
if (($9 | 0) != -1e3) {
|
|
HEAP32[$0 + 14240 >> 2] = $9;
|
|
$13 = $9;
|
|
}
|
|
if (!(($6 | 0) == 1002 | ($29 | 0) > 1874)) {
|
|
$13 = ($13 | 0) < 1103 ? $13 : 1103;
|
|
HEAP32[$0 + 14240 >> 2] = $13;
|
|
}
|
|
$6 = HEAP32[$0 + 144 >> 2];
|
|
label$97 : {
|
|
if (($6 | 0) > 24e3) {
|
|
$22 = $13;
|
|
break label$97;
|
|
}
|
|
$22 = 1104;
|
|
label$99 : {
|
|
label$100 : {
|
|
label$101 : {
|
|
label$102 : {
|
|
if (($13 | 0) <= 1104) {
|
|
if (($6 | 0) >= 16001) {
|
|
$22 = $13;
|
|
break label$97;
|
|
}
|
|
if (($13 | 0) > 1103) {
|
|
break label$102;
|
|
}
|
|
if (($6 | 0) < 12001) {
|
|
break label$101;
|
|
}
|
|
$22 = $13;
|
|
break label$97;
|
|
}
|
|
HEAP32[$0 + 14240 >> 2] = 1104;
|
|
if (($6 | 0) >= 16001) {
|
|
break label$97;
|
|
}
|
|
}
|
|
$22 = 1103;
|
|
HEAP32[$0 + 14240 >> 2] = 1103;
|
|
if (($6 | 0) >= 12001) {
|
|
break label$97;
|
|
}
|
|
break label$100;
|
|
}
|
|
if (($13 | 0) > 1102) {
|
|
break label$100;
|
|
}
|
|
if (($6 | 0) > 8e3) {
|
|
$22 = $13;
|
|
break label$97;
|
|
}
|
|
$22 = $13;
|
|
if (($13 | 0) != 1102) {
|
|
break label$97;
|
|
}
|
|
break label$99;
|
|
}
|
|
$22 = 1102;
|
|
HEAP32[$0 + 14240 >> 2] = 1102;
|
|
if (($6 | 0) > 8e3) {
|
|
break label$97;
|
|
}
|
|
}
|
|
$22 = 1101;
|
|
HEAP32[$0 + 14240 >> 2] = 1101;
|
|
}
|
|
$13 = HEAP32[$0 + 18120 >> 2];
|
|
if (!(!$13 | ($9 | 0) != -1e3)) {
|
|
$11 = $0;
|
|
$18 = $13;
|
|
$9 = HEAP32[$0 + 14192 >> 2];
|
|
label$107 : {
|
|
label$108 : {
|
|
if ((Math_imul($9, 18e3) | 0) >= ($8 | 0)) {
|
|
$10 = 0;
|
|
if (!$7) {
|
|
break label$108;
|
|
}
|
|
$7 = 1;
|
|
$6 = 1101;
|
|
break label$107;
|
|
}
|
|
if ((Math_imul($9, 24e3) | 0) < ($8 | 0)) {
|
|
$10 = $7;
|
|
break label$108;
|
|
}
|
|
$10 = $7;
|
|
$6 = 1102;
|
|
if (!($7 ^ 1)) {
|
|
break label$107;
|
|
}
|
|
}
|
|
$7 = $10;
|
|
$6 = (Math_imul($9, 3e4) | 0) < ($8 | 0) ? (Math_imul($9, 44e3) | 0) < ($8 | 0) ? 1105 : 1104 : 1103;
|
|
}
|
|
$13 = ($6 | 0) < ($13 | 0) ? $18 : $6;
|
|
HEAP32[$11 + 18120 >> 2] = $13;
|
|
$22 = ($13 | 0) > ($22 | 0) ? $22 : $13;
|
|
HEAP32[$0 + 14240 >> 2] = $22;
|
|
}
|
|
$13 = 0;
|
|
label$113 : {
|
|
if (!HEAP32[$0 + 48 >> 2] | $7) {
|
|
break label$113;
|
|
}
|
|
$6 = HEAP32[$0 + 40 >> 2];
|
|
if (!$6) {
|
|
break label$113;
|
|
}
|
|
$7 = 125 - (($6 | 0) < 25 ? $6 : 25) | 0;
|
|
$9 = HEAP32[$0 + 52 >> 2];
|
|
$10 = ($9 | 0) == 1;
|
|
$11 = ($6 | 0) < 6;
|
|
$13 = $22;
|
|
label$114 : {
|
|
while (1) {
|
|
$6 = $13 << 3;
|
|
$18 = HEAP32[$6 + 41864 >> 2];
|
|
$6 = HEAP32[$6 + 41868 >> 2];
|
|
$6 = Math_imul(($18 - ($10 ? $6 : 0) | 0) + ($9 ? 0 : $6) | 0, $7);
|
|
$6 = (Math_imul($6 & 65535, 655) >>> 16 | 0) + Math_imul($6 >> 16, 655) | 0;
|
|
if (($8 | 0) > ($6 | 0) | $11) {
|
|
break label$114;
|
|
}
|
|
if (($13 | 0) > 1101) {
|
|
$13 = $13 - 1 | 0;
|
|
HEAP32[$0 + 14240 >> 2] = $13;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$0 + 14240 >> 2] = $22;
|
|
$13 = 0;
|
|
break label$113;
|
|
}
|
|
$13 = ($6 | 0) < ($8 | 0);
|
|
}
|
|
HEAP32[$0 + 52 >> 2] = $13;
|
|
HEAP32[$14 + 400 >> 2] = $20;
|
|
opus_custom_encoder_ctl($19, 4036, $14 + 400 | 0);
|
|
$13 = HEAP32[$0 + 14224 >> 2];
|
|
if (!(($13 | 0) != 1002 | HEAP32[$0 + 14240 >> 2] != 1102)) {
|
|
HEAP32[$0 + 14240 >> 2] = 1103;
|
|
}
|
|
label$118 : {
|
|
label$119 : {
|
|
label$120 : {
|
|
label$121 : {
|
|
label$122 : {
|
|
label$123 : {
|
|
if (HEAP32[$0 + 176 >> 2]) {
|
|
$11 = 1101;
|
|
HEAP32[$0 + 14240 >> 2] = 1101;
|
|
break label$123;
|
|
}
|
|
$11 = HEAP32[$0 + 14240 >> 2];
|
|
if (($13 | 0) != 1e3) {
|
|
break label$123;
|
|
}
|
|
if (($11 | 0) > 1103) {
|
|
break label$122;
|
|
}
|
|
}
|
|
if (!(($13 | 0) != 1001 | ($11 | 0) > 1103)) {
|
|
HEAP32[$25 >> 2] = 1e3;
|
|
$13 = 1e3;
|
|
}
|
|
$7 = HEAP32[$0 + 144 >> 2];
|
|
$6 = ($7 | 0) / 50 | 0;
|
|
if (($6 | 0) < ($2 | 0)) {
|
|
break label$121;
|
|
}
|
|
$9 = $13;
|
|
break label$120;
|
|
}
|
|
$9 = 1001;
|
|
HEAP32[$0 + 14224 >> 2] = 1001;
|
|
$7 = HEAP32[$0 + 144 >> 2];
|
|
$6 = ($7 | 0) / 50 | 0;
|
|
if (($6 | 0) < ($2 | 0) | ((Math_imul($7, 3) | 0) / 50 | 0) < ($2 | 0)) {
|
|
break label$119;
|
|
}
|
|
break label$118;
|
|
}
|
|
$9 = 1e3;
|
|
if (($13 | 0) != 1e3) {
|
|
break label$119;
|
|
}
|
|
}
|
|
$13 = Math_imul($7, 3);
|
|
$10 = ($13 | 0) / 50 | 0;
|
|
if (($10 | 0) >= ($2 | 0)) {
|
|
break label$118;
|
|
}
|
|
if (($9 | 0) != 1e3) {
|
|
break label$119;
|
|
}
|
|
if ((($7 << 1) / 25 | 0) == ($2 | 0)) {
|
|
$6 = ($7 | 0) / 25 | 0;
|
|
break label$119;
|
|
}
|
|
$6 = (($13 | 0) / 25 | 0) == ($2 | 0) ? $10 : $6;
|
|
}
|
|
$13 = ($2 | 0) / ($6 | 0) | 0;
|
|
if (($30 | 0) != -1) {
|
|
HEAP32[$0 + 7640 >> 2] = $24;
|
|
HEAP32[$0 + 7636 >> 2] = $30;
|
|
}
|
|
$13 = encode_multiframe_packet($0, $1, $13, $6, $3, $4, $27, $20, $12);
|
|
break label$1;
|
|
}
|
|
if (HEAP32[$0 + 14248 >> 2]) {
|
|
HEAP32[$0 + 14248 >> 2] = 0;
|
|
$43 = 1;
|
|
$31 = 1;
|
|
$32 = 2;
|
|
}
|
|
$13 = HEAP32[$0 + 160 >> 2];
|
|
$30 = 0;
|
|
label$129 : {
|
|
if (!$31) {
|
|
$18 = 0;
|
|
$4 = 0;
|
|
break label$129;
|
|
}
|
|
$18 = 0;
|
|
$4 = 0;
|
|
if (($9 | 0) == 1002) {
|
|
break label$129;
|
|
}
|
|
$6 = HEAP32[$0 + 14192 >> 2];
|
|
$4 = Math_imul($6, 40) + 20 | 0;
|
|
$9 = (Math_imul(Math_imul($4, 200 - $5 | 0) + $13 | 0, 3) | 0) / 3200 | 0;
|
|
$4 = (((Math_imul(($23 << 3) - ($4 << 1) | 0, 240) | 0) / ((48e3 / ($5 | 0) | 0) + 240 | 0) | 0) + $4 | 0) / 8 | 0;
|
|
$4 = ($4 | 0) > ($9 | 0) ? $9 : $4;
|
|
$30 = ($6 << 3 | 4) < ($4 | 0) ? ($4 | 0) < 257 ? $4 : 257 : 0;
|
|
$18 = ($30 | 0) != 0;
|
|
$4 = $18;
|
|
}
|
|
$39 = $4;
|
|
$40 = $3 + 1 | 0;
|
|
$22 = $23 - 1 | 0;
|
|
ec_enc_init($14 + 440 | 0, $40, $22);
|
|
$34 = $2 + $38 | 0;
|
|
$4 = $15 - ((Math_imul($34, HEAP32[$0 + 112 >> 2]) << 2) + 15 & -16) | 0;
|
|
$20 = $4;
|
|
__stack_pointer = $4;
|
|
$31 = $0 + 14280 | 0;
|
|
$15 = HEAP32[$0 + 112 >> 2];
|
|
$9 = memcpy($4, $31 + (Math_imul($15, HEAP32[$0 + 172 >> 2] - $38 | 0) << 2) | 0, Math_imul($15, $38) << 2);
|
|
$27 = (Math_imul($2, $13) | 0) / ($7 << 3) | 0;
|
|
$6 = $0;
|
|
label$131 : {
|
|
if (HEAP32[$0 + 14224 >> 2] == 1002) {
|
|
$13 = silk_lin2log(60) << 8;
|
|
break label$131;
|
|
}
|
|
$13 = HEAP32[$33 + 8 >> 2];
|
|
}
|
|
$4 = HEAP32[$0 + 14200 >> 2];
|
|
$13 = $13 - $4 | 0;
|
|
$13 = Math_imul($13 >> 16, 983) + $4 + (Math_imul($13 & 65535, 983) >>> 16) | 0;
|
|
HEAP32[$6 + 14200 >> 2] = $13;
|
|
$24 = $0 + 14208 | 0;
|
|
$15 = silk_log2lin($13 >> 8);
|
|
$6 = HEAP32[$0 + 112 >> 2];
|
|
$13 = (Math_imul($38, $6) << 2) + $9 | 0;
|
|
$4 = HEAP32[$0 + 144 >> 2];
|
|
label$133 : {
|
|
if (HEAP32[$0 + 108 >> 2] == 2048) {
|
|
$4 = (Math_imul($15 << 16 >> 16, 2471) | 0) / (($4 | 0) / 1e3 | 0) | 0;
|
|
if (($2 | 0) < 1) {
|
|
break label$133;
|
|
}
|
|
$15 = $4 << 16 >> 16;
|
|
$7 = ((Math_imul($15, $4 >> 16) + (Math_imul($4 & 65535, $15) >> 16) | 0) + Math_imul(($4 >> 15) + 1 >> 1, $4) | 0) - 8388608 | 0;
|
|
$10 = $7 << 16 >> 16;
|
|
$15 = Math_imul($4, -471) + 268435456 | 0;
|
|
$4 = $15 >> 6;
|
|
$37 = $4 & 65535;
|
|
$36 = $15 >> 22;
|
|
$35 = Math_fround(Math_fround(((Math_imul($10, $37) >> 16) + Math_imul($36, $10) | 0) + Math_imul(($7 >> 15) + 1 >> 1, $4) | 0) * Math_fround(3.725290298461914e-9));
|
|
$7 = Math_imul(($15 >> 21) + 1 >> 1, $4);
|
|
$4 = $4 << 16 >> 16;
|
|
$47 = Math_fround(Math_fround(($7 + Math_imul($36, $4) | 0) + (Math_imul($4, $37) >> 16) | 0) * Math_fround(3.725290298461914e-9));
|
|
$48 = Math_fround(Math_fround($15 | 0) * Math_fround(3.725290298461914e-9));
|
|
$4 = 0;
|
|
$49 = Math_fround(Math_fround(0 - ($15 << 1) | 0) * Math_fround(3.725290298461914e-9));
|
|
$17 = HEAPF32[$0 + 14212 >> 2];
|
|
$21 = HEAPF32[$0 + 14208 >> 2];
|
|
while (1) {
|
|
$15 = Math_imul($4, $6) << 2;
|
|
$26 = HEAPF32[$15 + $1 >> 2];
|
|
$16 = Math_fround($48 * $26);
|
|
$28 = $16;
|
|
$16 = Math_fround($21 + $16);
|
|
$28 = Math_fround(Math_fround($28 - Math_fround($47 * $16)) + Math_fround(1.0000000031710769e-30));
|
|
HEAPF32[$0 + 14212 >> 2] = $28;
|
|
$21 = Math_fround(Math_fround($49 * $26) + Math_fround($17 - Math_fround($35 * $16)));
|
|
HEAPF32[$0 + 14208 >> 2] = $21;
|
|
HEAPF32[$13 + $15 >> 2] = $16;
|
|
$17 = $28;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($6 | 0) != 2) {
|
|
break label$133;
|
|
}
|
|
$7 = $13 + 4 | 0;
|
|
$10 = $1 + 4 | 0;
|
|
$17 = HEAPF32[$0 + 14220 >> 2];
|
|
$21 = HEAPF32[$0 + 14216 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$15 = $4 << 3;
|
|
$26 = HEAPF32[$15 + $10 >> 2];
|
|
$16 = Math_fround($48 * $26);
|
|
$28 = $16;
|
|
$16 = Math_fround($21 + $16);
|
|
$28 = Math_fround(Math_fround($28 - Math_fround($47 * $16)) + Math_fround(1.0000000031710769e-30));
|
|
HEAPF32[$0 + 14220 >> 2] = $28;
|
|
$21 = Math_fround(Math_fround($49 * $26) + Math_fround($17 - Math_fround($35 * $16)));
|
|
HEAPF32[$0 + 14216 >> 2] = $21;
|
|
HEAPF32[$7 + $15 >> 2] = $16;
|
|
$17 = $28;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$133;
|
|
}
|
|
$17 = Math_fround(Math_fround(18.900001525878906) / Math_fround($4 | 0));
|
|
$21 = Math_fround(Math_fround(1) - $17);
|
|
$16 = HEAPF32[$24 >> 2];
|
|
if (($6 | 0) != 2) {
|
|
$4 = 0;
|
|
if (($2 | 0) > 0) {
|
|
while (1) {
|
|
$15 = $4 << 2;
|
|
$26 = HEAPF32[$15 + $1 >> 2];
|
|
HEAPF32[$13 + $15 >> 2] = $26 - $16;
|
|
$16 = Math_fround(Math_fround($21 * $16) + Math_fround(Math_fround($17 * $26) + Math_fround(1.0000000031710769e-30)));
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$24 >> 2] = $16;
|
|
break label$133;
|
|
}
|
|
$26 = HEAPF32[$0 + 14216 >> 2];
|
|
if (($2 | 0) >= 1) {
|
|
$4 = 0;
|
|
while (1) {
|
|
$15 = $4 << 3;
|
|
$7 = $15 | 4;
|
|
$28 = HEAPF32[$7 + $1 >> 2];
|
|
$35 = HEAPF32[$1 + $15 >> 2];
|
|
HEAPF32[$13 + $15 >> 2] = $35 - $16;
|
|
HEAPF32[$7 + $13 >> 2] = $28 - $26;
|
|
$16 = Math_fround(Math_fround($21 * $16) + Math_fround(Math_fround($17 * $35) + Math_fround(1.0000000031710769e-30)));
|
|
$26 = Math_fround(Math_fround($21 * $26) + Math_fround(Math_fround($17 * $28) + Math_fround(1.0000000031710769e-30)));
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$0 + 14216 >> 2] = $26;
|
|
HEAPF32[$0 + 14208 >> 2] = $16;
|
|
}
|
|
label$142 : {
|
|
if (!$12) {
|
|
break label$142;
|
|
}
|
|
$16 = Math_fround(0);
|
|
$15 = Math_imul($2, $6);
|
|
if (($15 | 0) >= 1) {
|
|
$4 = 0;
|
|
while (1) {
|
|
$17 = HEAPF32[($4 << 2) + $13 >> 2];
|
|
$16 = Math_fround($16 + Math_fround($17 * $17));
|
|
$4 = $4 + 1 | 0;
|
|
if (($15 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($16 == $16 ? !($16 < Math_fround(1e9) ^ 1) : 0) {
|
|
break label$142;
|
|
}
|
|
memset($13, 0, $15 << 2);
|
|
HEAP32[$24 + 8 >> 2] = 0;
|
|
HEAP32[$24 + 12 >> 2] = 0;
|
|
HEAP32[$24 >> 2] = 0;
|
|
HEAP32[$24 + 4 >> 2] = 0;
|
|
}
|
|
$21 = Math_fround(1);
|
|
label$145 : {
|
|
if (HEAP32[$25 >> 2] != 1002) {
|
|
$4 = 1;
|
|
$36 = $20;
|
|
$10 = $20 - ((Math_imul($2, $6) << 1) + 15 & -16) | 0;
|
|
__stack_pointer = $10;
|
|
$26 = HEAPF32[$14 + 580 >> 2];
|
|
$52 = HEAP32[$14 + 544 >> 2];
|
|
$13 = $23 - $30 | 0;
|
|
$27 = Math_imul(((($13 | 0) < ($27 | 0) ? $13 : $27) << 3) - 8 | 0, $5);
|
|
label$147 : {
|
|
label$148 : {
|
|
label$149 : {
|
|
label$150 : {
|
|
label$151 : {
|
|
label$152 : {
|
|
$24 = HEAP32[$25 >> 2];
|
|
if (($24 | 0) == 1001) {
|
|
$6 = (HEAP32[$0 + 52 >> 2] << 1) + (HEAP32[$0 + 144 >> 2] == (Math_imul($2, 50) | 0) ? 2 : 1) | 0;
|
|
$12 = HEAP32[$0 + 148 >> 2];
|
|
$15 = HEAP32[$0 + 14192 >> 2];
|
|
$13 = ($27 | 0) / ($15 | 0) | 0;
|
|
if (($13 | 0) < 12e3) {
|
|
break label$152;
|
|
}
|
|
$4 = 2;
|
|
if (($13 | 0) < 16e3) {
|
|
break label$152;
|
|
}
|
|
$4 = 3;
|
|
if (($13 | 0) < 2e4) {
|
|
break label$152;
|
|
}
|
|
$4 = 4;
|
|
if (($13 | 0) < 24e3) {
|
|
break label$152;
|
|
}
|
|
$4 = 5;
|
|
if (($13 | 0) < 32e3) {
|
|
break label$152;
|
|
}
|
|
$4 = 6;
|
|
if (($13 | 0) < 64e3) {
|
|
break label$152;
|
|
}
|
|
$4 = HEAP32[($6 << 2) + 50840 >> 2] + (($13 - 64e3 | 0) / 2 | 0) | 0;
|
|
break label$151;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = $27;
|
|
$12 = HEAP32[$0 + 14256 >> 2];
|
|
if ($12) {
|
|
break label$150;
|
|
}
|
|
$6 = $27;
|
|
break label$147;
|
|
}
|
|
$4 = Math_imul($4, 20);
|
|
$7 = $4 + 50720 | 0;
|
|
$20 = HEAP32[$7 >> 2];
|
|
$4 = $4 + 50700 | 0;
|
|
$6 = $6 << 2;
|
|
$37 = Math_imul($20 - $13 | 0, HEAP32[$4 + $6 >> 2]);
|
|
$4 = HEAP32[$4 >> 2];
|
|
$4 = ($37 + Math_imul(HEAP32[$6 + $7 >> 2], $13 - $4 | 0) | 0) / ($20 - $4 | 0) | 0;
|
|
}
|
|
$4 = $12 ? $4 : $4 + 100 | 0;
|
|
$4 = Math_imul(($11 | 0) == 1104 ? $4 + 300 | 0 : $4, $15);
|
|
$6 = ($15 | 0) == 2 ? ($13 | 0) > 11999 ? $4 - 1e3 | 0 : $4 : $4;
|
|
HEAP32[$0 + 36 >> 2] = $6;
|
|
$12 = HEAP32[$0 + 14256 >> 2];
|
|
if (!$12) {
|
|
break label$149;
|
|
}
|
|
$27 = $6;
|
|
}
|
|
if (HEAP32[$0 + 148 >> 2]) {
|
|
break label$148;
|
|
}
|
|
$6 = $27;
|
|
break label$147;
|
|
}
|
|
$21 = Math_fround(Math_fround(1) - Math_fround(exp(+Math_fround(Math_fround($6 - $27 | 0) * Math_fround(.0009765625)) * .6931471805599453)));
|
|
break label$147;
|
|
}
|
|
if (HEAP32[$0 + 176 >> 2]) {
|
|
$6 = $27;
|
|
break label$147;
|
|
}
|
|
$28 = Math_fround(8e3);
|
|
$7 = 13;
|
|
label$155 : {
|
|
label$156 : {
|
|
label$157 : {
|
|
$50 = HEAP32[$0 + 14240 >> 2];
|
|
switch ($50 - 1101 | 0) {
|
|
case 0:
|
|
break label$155;
|
|
case 1:
|
|
break label$157;
|
|
default:
|
|
break label$156;
|
|
}
|
|
}
|
|
$28 = Math_fround(12e3);
|
|
$7 = 15;
|
|
break label$155;
|
|
}
|
|
$28 = Math_fround(16e3);
|
|
$7 = 17;
|
|
}
|
|
$17 = Math_fround(0);
|
|
$37 = HEAP32[$0 + 112 >> 2];
|
|
if (($37 | 0) >= 1) {
|
|
$20 = 0;
|
|
while (1) {
|
|
$6 = Math_imul($20, 21);
|
|
$13 = 0;
|
|
while (1) {
|
|
$16 = HEAPF32[($6 + $13 << 2) + $12 >> 2];
|
|
$35 = $16;
|
|
$4 = $16 < Math_fround(.5);
|
|
$15 = ($4 ? $16 : Math_fround(.5)) > Math_fround(-2);
|
|
$16 = $15 ? Math_fround(.5) : Math_fround(-2);
|
|
$16 = $15 ? $4 ? $35 : $16 : $16;
|
|
$17 = Math_fround($17 + ($16 > Math_fround(0) ? Math_fround($16 * Math_fround(.5)) : $16));
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$20 = $20 + 1 | 0;
|
|
if (($37 | 0) != ($20 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = (0 - ($27 << 1) | 0) / 3 | 0;
|
|
$16 = Math_fround($28 * Math_fround(Math_fround(Math_fround($17 / Math_fround($7 | 0)) * Math_fround($37 | 0)) + Math_fround(.20000000298023224)));
|
|
label$161 : {
|
|
if (Math_fround(Math_abs($16)) < Math_fround(2147483648)) {
|
|
$4 = ~~$16;
|
|
break label$161;
|
|
}
|
|
$4 = -2147483648;
|
|
}
|
|
$13 = ($4 | 0) > ($13 | 0) ? $4 : $13;
|
|
$13 = ($50 & -2) == 1104 ? (Math_imul($13, 3) | 0) / 5 | 0 : $13;
|
|
$6 = $27 + $13 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $6;
|
|
}
|
|
$15 = HEAP32[$0 + 112 >> 2];
|
|
HEAP32[$0 + 8 >> 2] = $15;
|
|
$7 = HEAP32[$0 + 14192 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $7;
|
|
$4 = HEAP32[$0 + 144 >> 2];
|
|
HEAP32[$0 + 32 >> 2] = (Math_imul($2, 1e3) | 0) / ($4 | 0);
|
|
$13 = 8e3;
|
|
$12 = 8e3;
|
|
label$164 : {
|
|
label$165 : {
|
|
switch ($11 - 1101 | 0) {
|
|
default:
|
|
$12 = 12e3;
|
|
$13 = 16e3;
|
|
if (($11 | 0) == 1103 | ($24 | 0) == 1001) {
|
|
break label$164;
|
|
}
|
|
celt_fatal(50496, 50583, 1755);
|
|
abort();
|
|
case 0:
|
|
break label$164;
|
|
case 1:
|
|
break label$165;
|
|
}
|
|
}
|
|
$13 = 12e3;
|
|
$12 = 12e3;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = $13;
|
|
HEAP32[$0 + 20 >> 2] = 16e3;
|
|
HEAP32[$0 + 24 >> 2] = ($24 | 0) == 1001 ? 16e3 : 8e3;
|
|
label$167 : {
|
|
if (($24 | 0) != 1e3) {
|
|
break label$167;
|
|
}
|
|
$42 = $44 ? ($29 << 4) / 3 | 0 : $42;
|
|
if (($42 | 0) > 7999) {
|
|
break label$167;
|
|
}
|
|
HEAP32[$0 + 20 >> 2] = 12e3;
|
|
HEAP32[$0 + 28 >> 2] = $12;
|
|
if (($42 | 0) > 6999) {
|
|
break label$167;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = 8e3;
|
|
HEAP32[$0 + 20 >> 2] = 8e3;
|
|
}
|
|
$12 = $26 >= Math_fround(.10000000149011612);
|
|
$13 = $22 << 3;
|
|
HEAP32[$0 - -64 >> 2] = $13;
|
|
$20 = HEAP32[$0 + 148 >> 2];
|
|
HEAP32[$0 + 60 >> 2] = !$20;
|
|
label$168 : {
|
|
label$169 : {
|
|
label$170 : {
|
|
label$171 : {
|
|
if (!($18 ^ 1 | ($30 | 0) < 2)) {
|
|
$13 = ($30 << 3 ^ -1) + $13 | 0;
|
|
HEAP32[$0 + 64 >> 2] = $13;
|
|
if (($24 | 0) != 1001) {
|
|
break label$168;
|
|
}
|
|
$13 = $13 - 20 | 0;
|
|
HEAP32[$0 + 64 >> 2] = $13;
|
|
if (!$20) {
|
|
break label$169;
|
|
}
|
|
break label$171;
|
|
}
|
|
if (!$20) {
|
|
break label$170;
|
|
}
|
|
if (($24 | 0) != 1001) {
|
|
break label$168;
|
|
}
|
|
}
|
|
$6 = 1;
|
|
$20 = (HEAP32[$0 + 52 >> 2] << 1) + ((Math_imul($2, 50) | 0) == ($4 | 0) ? 2 : 1) | 0;
|
|
$18 = $0;
|
|
label$173 : {
|
|
label$174 : {
|
|
$13 = ((Math_imul($4, $13) | 0) / ($2 | 0) | 0) / ($7 | 0) | 0;
|
|
if (($13 | 0) < 12e3) {
|
|
break label$174;
|
|
}
|
|
$6 = 2;
|
|
if (($13 | 0) < 16e3) {
|
|
break label$174;
|
|
}
|
|
$6 = 3;
|
|
if (($13 | 0) < 2e4) {
|
|
break label$174;
|
|
}
|
|
$6 = 4;
|
|
if (($13 | 0) < 24e3) {
|
|
break label$174;
|
|
}
|
|
$6 = 5;
|
|
if (($13 | 0) < 32e3) {
|
|
break label$174;
|
|
}
|
|
$6 = 6;
|
|
if (($13 | 0) < 64e3) {
|
|
break label$174;
|
|
}
|
|
$6 = HEAP32[($20 << 2) + 50840 >> 2] + (($13 - 64e3 | 0) / 2 | 0) | 0;
|
|
break label$173;
|
|
}
|
|
$6 = Math_imul($6, 20);
|
|
$29 = $6 + 50720 | 0;
|
|
$24 = HEAP32[$29 >> 2];
|
|
$6 = $6 + 50700 | 0;
|
|
$20 = $20 << 2;
|
|
$27 = Math_imul($24 - $13 | 0, HEAP32[$6 + $20 >> 2]);
|
|
$6 = HEAP32[$6 >> 2];
|
|
$6 = ($27 + Math_imul(HEAP32[$20 + $29 >> 2], $13 - $6 | 0) | 0) / ($24 - $6 | 0) | 0;
|
|
}
|
|
$6 = Math_imul(($11 | 0) == 1104 ? $6 + 300 | 0 : $6, $7);
|
|
HEAP32[$18 + 64 >> 2] = (Math_imul(($7 | 0) == 2 ? ($13 | 0) > 11999 ? $6 - 1e3 | 0 : $6 : $6, $2) | 0) / ($4 | 0);
|
|
break label$168;
|
|
}
|
|
if (($24 | 0) != 1001) {
|
|
break label$168;
|
|
}
|
|
}
|
|
$6 = (Math_imul($2, $6) | 0) / ($4 | 0) | 0;
|
|
HEAP32[$0 + 64 >> 2] = ($6 | 0) > ($13 | 0) ? $13 : $6;
|
|
}
|
|
$6 = $0 + 8 | 0;
|
|
$12 = $52 ? $12 : -1;
|
|
if ($32) {
|
|
$13 = 0;
|
|
HEAP32[$14 + 432 >> 2] = 0;
|
|
$7 = ($4 | 0) / 400 | 0;
|
|
$20 = Math_imul((HEAP32[$0 + 172 >> 2] - $7 | 0) - HEAP32[$0 + 116 >> 2] | 0, $15) << 2;
|
|
$29 = ($20 + $0 | 0) + 14280 | 0;
|
|
$24 = HEAP32[$14 + 612 >> 2];
|
|
gain_fade($29, $29, Math_fround(0), Math_fround(1), HEAP32[$24 + 4 >> 2], $7, $15, HEAP32[$24 + 60 >> 2], $4);
|
|
memset($31, 0, $20);
|
|
$15 = HEAP32[$0 + 172 >> 2];
|
|
$4 = Math_imul($15, HEAP32[$0 + 112 >> 2]);
|
|
if (($4 | 0) >= 1) {
|
|
while (1) {
|
|
$16 = Math_fround(HEAPF32[(($13 << 2) + $0 | 0) + 14280 >> 2] * Math_fround(32768));
|
|
$16 = $16 > Math_fround(-32768) ? $16 : Math_fround(-32768);
|
|
HEAP16[($13 << 1) + $10 >> 1] = lrintf($16 < Math_fround(32767) ? $16 : Math_fround(32767));
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_Encode($33, $6, $10, $15, 0, $14 + 432 | 0, $32, $12);
|
|
HEAP32[$0 + 72 >> 2] = 0;
|
|
$15 = HEAP32[$0 + 112 >> 2];
|
|
}
|
|
$4 = Math_imul($2, $15);
|
|
if (($4 | 0) >= 1) {
|
|
$15 = Math_imul($15, $38);
|
|
$13 = 0;
|
|
while (1) {
|
|
$16 = Math_fround(HEAPF32[($13 + $15 << 2) + $9 >> 2] * Math_fround(32768));
|
|
$16 = $16 > Math_fround(-32768) ? $16 : Math_fround(-32768);
|
|
HEAP16[($13 << 1) + $10 >> 1] = lrintf($16 < Math_fround(32767) ? $16 : Math_fround(32767));
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = -3;
|
|
label$181 : {
|
|
if (!silk_Encode($33, $6, $10, $2, $14 + 440 | 0, $14 + 620 | 0, 0, $12)) {
|
|
$13 = HEAP32[$0 + 80 >> 2];
|
|
label$183 : {
|
|
label$184 : {
|
|
$4 = HEAP32[$0 + 14224 >> 2];
|
|
if (($4 | 0) == 1e3) {
|
|
if (($13 | 0) == 8e3) {
|
|
$11 = 1101;
|
|
break label$183;
|
|
}
|
|
if (($13 | 0) == 16e3) {
|
|
break label$184;
|
|
}
|
|
if (($13 | 0) != 12e3) {
|
|
break label$183;
|
|
}
|
|
$11 = 1102;
|
|
break label$183;
|
|
}
|
|
if (($13 | 0) == 16e3) {
|
|
break label$183;
|
|
}
|
|
celt_fatal(50602, 50583, 1863);
|
|
abort();
|
|
}
|
|
$11 = 1103;
|
|
}
|
|
label$187 : {
|
|
if (HEAP32[$0 + 96 >> 2]) {
|
|
$13 = HEAP32[$0 + 18132 >> 2];
|
|
HEAP32[$0 + 72 >> 2] = !$13;
|
|
if (!HEAP32[$14 + 620 >> 2]) {
|
|
break label$187;
|
|
}
|
|
if ($13) {
|
|
break label$181;
|
|
}
|
|
HEAP32[$0 + 14248 >> 2] = 1;
|
|
$43 = 0;
|
|
$4 = HEAP32[$0 + 14192 >> 2];
|
|
$13 = Math_imul($4, 40) + 20 | 0;
|
|
$15 = (Math_imul(HEAP32[$0 + 160 >> 2] + Math_imul($13, 200 - $5 | 0) | 0, 3) | 0) / 3200 | 0;
|
|
$13 = (((Math_imul(($23 << 3) - ($13 << 1) | 0, 240) | 0) / ((48e3 / ($5 | 0) | 0) + 240 | 0) | 0) + $13 | 0) / 8 | 0;
|
|
$13 = ($13 | 0) > ($15 | 0) ? $15 : $13;
|
|
$30 = ($4 << 3 | 4) < ($13 | 0) ? ($13 | 0) < 257 ? $13 : 257 : 0;
|
|
$39 = ($30 | 0) != 0;
|
|
break label$181;
|
|
}
|
|
HEAP32[$0 + 72 >> 2] = 0;
|
|
if (HEAP32[$14 + 620 >> 2]) {
|
|
break label$181;
|
|
}
|
|
}
|
|
$13 = 0;
|
|
HEAP32[$0 + 18136 >> 2] = 0;
|
|
$1 = HEAP32[$0 + 14192 >> 2];
|
|
$0 = HEAP32[$0 + 144 >> 2] / ($2 | 0) | 0;
|
|
if (($0 | 0) <= 399) {
|
|
while (1) {
|
|
$13 = $13 + 1 | 0;
|
|
$0 = $0 << 1;
|
|
if (($0 | 0) < 400) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = $13 << 3;
|
|
}
|
|
label$191 : {
|
|
label$192 : {
|
|
switch ($4 - 1e3 | 0) {
|
|
case 0:
|
|
$0 = $13 - 16 | ($11 << 5) + 96 & 224;
|
|
break label$191;
|
|
case 2:
|
|
$0 = ((($11 | 0) > 1102 ? $11 : 1102) << 5) - -64 & 96 | $13 | 128;
|
|
break label$191;
|
|
default:
|
|
break label$192;
|
|
}
|
|
}
|
|
$0 = $13 + 240 | $11 << 4 | 96;
|
|
}
|
|
HEAP8[$3 | 0] = $0 | (($1 | 0) == 2) << 2;
|
|
$13 = 1;
|
|
}
|
|
break label$145;
|
|
}
|
|
$20 = $36;
|
|
}
|
|
$13 = 21;
|
|
$4 = $11 - 1101 | 0;
|
|
if ($4 >>> 0 <= 3) {
|
|
$13 = HEAP32[($4 << 2) + 50860 >> 2];
|
|
}
|
|
HEAP32[$14 + 384 >> 2] = $13;
|
|
opus_custom_encoder_ctl($19, 10012, $14 + 384 | 0);
|
|
HEAP32[$14 + 368 >> 2] = HEAP32[$0 + 14192 >> 2];
|
|
opus_custom_encoder_ctl($19, 10008, $14 + 368 | 0);
|
|
HEAP32[$14 + 352 >> 2] = -1;
|
|
opus_custom_encoder_ctl($19, 4002, $14 + 352 | 0);
|
|
label$196 : {
|
|
if (HEAP32[$0 + 14224 >> 2] == 1e3) {
|
|
$13 = HEAP32[$0 + 112 >> 2];
|
|
$10 = $20 - (((Math_imul($13, HEAP32[$0 + 144 >> 2]) | 0) / 400 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $10;
|
|
break label$196;
|
|
}
|
|
HEAP32[$14 + 336 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 4006, $14 + 336 | 0);
|
|
HEAP32[$14 + 320 >> 2] = !HEAP32[$0 + 76 >> 2] << 1;
|
|
opus_custom_encoder_ctl($19, 10002, $14 + 320 | 0);
|
|
$13 = HEAP32[$0 + 148 >> 2];
|
|
$4 = HEAP32[$0 + 14224 >> 2];
|
|
label$198 : {
|
|
label$199 : {
|
|
label$200 : {
|
|
if (($4 | 0) == 1001) {
|
|
if (!$13) {
|
|
$13 = HEAP32[$0 + 112 >> 2];
|
|
$15 = HEAP32[$0 + 144 >> 2];
|
|
$5 = (Math_imul($13, $15) | 0) / 400 | 0;
|
|
$10 = $20 - (($5 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $10;
|
|
$4 = 1001;
|
|
break label$198;
|
|
}
|
|
HEAP32[$14 + 256 >> 2] = HEAP32[$0 + 160 >> 2] - HEAP32[$0 + 36 >> 2];
|
|
opus_custom_encoder_ctl($19, 4002, $14 + 256 | 0);
|
|
HEAP32[$14 + 240 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 4020, $14 + 240 | 0);
|
|
break label$200;
|
|
}
|
|
if (!$13) {
|
|
break label$199;
|
|
}
|
|
HEAP32[$14 + 304 >> 2] = 1;
|
|
opus_custom_encoder_ctl($19, 4006, $14 + 304 | 0);
|
|
HEAP32[$14 + 288 >> 2] = HEAP32[$0 + 152 >> 2];
|
|
opus_custom_encoder_ctl($19, 4020, $14 + 288 | 0);
|
|
HEAP32[$14 + 272 >> 2] = HEAP32[$0 + 160 >> 2];
|
|
opus_custom_encoder_ctl($19, 4002, $14 + 272 | 0);
|
|
}
|
|
$4 = HEAP32[$25 >> 2];
|
|
}
|
|
$13 = HEAP32[$0 + 112 >> 2];
|
|
$15 = HEAP32[$0 + 144 >> 2];
|
|
$5 = (Math_imul($13, $15) | 0) / 400 | 0;
|
|
$10 = $20 - (($5 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $10;
|
|
if (($4 | 0) == 1e3) {
|
|
break label$196;
|
|
}
|
|
}
|
|
$6 = HEAP32[$0 + 14228 >> 2];
|
|
if (($6 | 0) == ($4 | 0) | ($6 | 0) < 1) {
|
|
break label$196;
|
|
}
|
|
memcpy($10, ((Math_imul(HEAP32[$0 + 172 >> 2] + ((($15 | 0) / -400 | 0) - $38 | 0) | 0, $13) << 2) + $0 | 0) + 14280 | 0, $5 << 2);
|
|
}
|
|
$4 = HEAP32[$0 + 172 >> 2];
|
|
$15 = Math_imul($4 - $34 | 0, $13);
|
|
label$203 : {
|
|
if (($15 | 0) >= 1) {
|
|
$4 = $0 + 14280 | 0;
|
|
$15 = $15 << 2;
|
|
memmove($31, $4 + (Math_imul($2, $13) << 2) | 0, $15);
|
|
memcpy($4 + $15 | 0, $9, Math_imul($13, $34) << 2);
|
|
break label$203;
|
|
}
|
|
memcpy($31, (Math_imul($34 - $4 | 0, $13) << 2) + $9 | 0, Math_imul($4, $13) << 2);
|
|
}
|
|
$16 = HEAPF32[$0 + 14204 >> 2];
|
|
if (!($16 < Math_fround(1) ^ 1 ? !($21 < Math_fround(1)) : 0)) {
|
|
$13 = HEAP32[$14 + 612 >> 2];
|
|
gain_fade($9, $9, $16, $21, HEAP32[$13 + 4 >> 2], $2, HEAP32[$0 + 112 >> 2], HEAP32[$13 + 60 >> 2], HEAP32[$0 + 144 >> 2]);
|
|
}
|
|
HEAPF32[$0 + 14204 >> 2] = $21;
|
|
$5 = HEAP32[$0 + 14224 >> 2];
|
|
if (!(HEAP32[$0 + 14192 >> 2] != 1 ? ($5 | 0) == 1001 : 0)) {
|
|
$4 = $0;
|
|
$13 = 16384;
|
|
label$208 : {
|
|
if (($8 | 0) > 32e3) {
|
|
break label$208;
|
|
}
|
|
$13 = 0;
|
|
if (($8 | 0) < 16e3) {
|
|
break label$208;
|
|
}
|
|
$13 = 16384 - ((65536e3 - ($8 << 11) | 0) / ($8 - 14e3 | 0) | 0) | 0;
|
|
}
|
|
HEAP32[$4 + 92 >> 2] = $13;
|
|
}
|
|
label$209 : {
|
|
if (HEAP32[$0 + 14256 >> 2] | HEAP32[$0 + 112 >> 2] != 2) {
|
|
break label$209;
|
|
}
|
|
$4 = HEAP16[$0 + 14196 >> 1];
|
|
$8 = HEAP32[$0 + 92 >> 2];
|
|
if (($8 | 0) > 16383 ? ($4 | 0) >= 16384 : 0) {
|
|
break label$209;
|
|
}
|
|
$21 = Math_fround(Math_fround(1) - Math_fround(Math_fround($8 | 0) * Math_fround(6103515625e-14)));
|
|
$13 = 0;
|
|
$15 = HEAP32[$14 + 612 >> 2];
|
|
$12 = 48e3 / HEAP32[$0 + 144 >> 2] | 0;
|
|
$6 = HEAP32[$15 + 4 >> 2] / ($12 | 0) | 0;
|
|
if (($6 | 0) > 0) {
|
|
$26 = Math_fround(Math_fround(1) - Math_fround(Math_fround($4 | 0) * Math_fround(6103515625e-14)));
|
|
$7 = HEAP32[$15 + 60 >> 2];
|
|
while (1) {
|
|
$4 = $13 << 3;
|
|
$15 = $9 + $4 | 0;
|
|
$16 = HEAPF32[$15 >> 2];
|
|
$28 = $16;
|
|
$17 = HEAPF32[(Math_imul($12, $13) << 2) + $7 >> 2];
|
|
$17 = Math_fround($17 * $17);
|
|
$35 = Math_fround(Math_fround($21 * $17) + Math_fround($26 * Math_fround(Math_fround(1) - $17)));
|
|
$4 = ($4 | 4) + $9 | 0;
|
|
$17 = HEAPF32[$4 >> 2];
|
|
$16 = Math_fround($35 * Math_fround(Math_fround($16 - $17) * Math_fround(.5)));
|
|
HEAPF32[$15 >> 2] = $28 - $16;
|
|
HEAPF32[$4 >> 2] = $17 + $16;
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = $6;
|
|
}
|
|
if (($2 | 0) > ($13 | 0)) {
|
|
while (1) {
|
|
$4 = $13 << 3;
|
|
$15 = $9 + $4 | 0;
|
|
$16 = HEAPF32[$15 >> 2];
|
|
$28 = $16;
|
|
$4 = ($4 | 4) + $9 | 0;
|
|
$17 = HEAPF32[$4 >> 2];
|
|
$16 = Math_fround($21 * Math_fround(Math_fround($16 - $17) * Math_fround(.5)));
|
|
HEAPF32[$15 >> 2] = $28 - $16;
|
|
HEAPF32[$4 >> 2] = $17 + $16;
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP16[$0 + 14196 >> 1] = $8;
|
|
}
|
|
label$215 : {
|
|
label$216 : {
|
|
if (($5 | 0) == 1002 | (Math_clz32(HEAP32[$14 + 468 >> 2]) + (HEAP32[$14 + 460 >> 2] + (($5 | 0) == 1001 ? 5 : -15) | 0) | 0) > $22 << 3) {
|
|
break label$216;
|
|
}
|
|
if (($5 | 0) == 1001) {
|
|
ec_enc_bit_logp($14 + 440 | 0, $39, 12);
|
|
}
|
|
if (!$39) {
|
|
break label$216;
|
|
}
|
|
$6 = 1;
|
|
ec_enc_bit_logp($14 + 440 | 0, $43, 1);
|
|
$13 = HEAP32[$14 + 460 >> 2] + Math_clz32(HEAP32[$14 + 468 >> 2]) | 0;
|
|
$4 = $13 - 21 | 0;
|
|
$5 = $13 - 32 | 0;
|
|
$13 = HEAP32[$25 >> 2];
|
|
$4 = $22 - ((($13 | 0) == 1001 ? $4 : $5) + 7 >> 3) | 0;
|
|
$4 = ($4 | 0) < ($30 | 0) ? $4 : $30;
|
|
$4 = ($4 | 0) > 2 ? $4 : 2;
|
|
$5 = ($4 | 0) < 257 ? $4 : 257;
|
|
$7 = 0;
|
|
if (($13 | 0) != 1001) {
|
|
break label$215;
|
|
}
|
|
ec_enc_uint($14 + 440 | 0, $5 - 2 | 0, 256);
|
|
break label$215;
|
|
}
|
|
$6 = 0;
|
|
HEAP32[$0 + 14248 >> 2] = 0;
|
|
$7 = 1;
|
|
$5 = 0;
|
|
}
|
|
$12 = HEAP32[$25 >> 2];
|
|
label$218 : {
|
|
if (($12 | 0) == 1e3) {
|
|
$13 = HEAP32[$14 + 468 >> 2];
|
|
$4 = HEAP32[$14 + 460 >> 2];
|
|
ec_enc_done($14 + 440 | 0);
|
|
$13 = (Math_clz32($13) + $4 | 0) - 25 >> 3;
|
|
$15 = $13;
|
|
break label$218;
|
|
}
|
|
$13 = $22 - $5 | 0;
|
|
ec_enc_shrink($14 + 440 | 0, $13);
|
|
$15 = 0;
|
|
}
|
|
label$220 : {
|
|
if (!(HEAP32[$25 >> 2] != 1e3 | $6)) {
|
|
$4 = $43;
|
|
$8 = 0;
|
|
break label$220;
|
|
}
|
|
HEAP32[$14 + 224 >> 2] = $14 + 544;
|
|
opus_custom_encoder_ctl($19, 10022, $14 + 224 | 0);
|
|
if (HEAP32[$25 >> 2] == 1001) {
|
|
HEAP32[$14 + 432 >> 2] = HEAP32[$0 + 100 >> 2];
|
|
HEAP32[$14 + 436 >> 2] = HEAP32[$0 + 104 >> 2];
|
|
HEAP32[$14 + 208 >> 2] = $14 + 432;
|
|
opus_custom_encoder_ctl($19, 10028, $14 + 208 | 0);
|
|
}
|
|
$4 = $43;
|
|
$8 = 0;
|
|
if (!($6 & $4)) {
|
|
break label$220;
|
|
}
|
|
HEAP32[$14 + 192 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 10010, $14 + 192 | 0);
|
|
HEAP32[$14 + 176 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 4006, $14 + 176 | 0);
|
|
HEAP32[$14 + 160 >> 2] = -1;
|
|
opus_custom_encoder_ctl($19, 4002, $14 + 160 | 0);
|
|
if ((celt_encode_with_ec($19, $9, HEAP32[$0 + 144 >> 2] / 200 | 0, $13 + $40 | 0, $5, 0) | 0) < 0) {
|
|
$13 = -3;
|
|
break label$145;
|
|
}
|
|
HEAP32[$14 + 144 >> 2] = $14 + 616;
|
|
opus_custom_encoder_ctl($19, 4031, $14 + 144 | 0);
|
|
opus_custom_encoder_ctl($19, 4028, 0);
|
|
$4 = 1;
|
|
$8 = 1;
|
|
}
|
|
HEAP32[$14 + 128 >> 2] = ($12 | 0) == 1002 ? 0 : 17;
|
|
opus_custom_encoder_ctl($19, 10010, $14 + 128 | 0);
|
|
$12 = HEAP32[$25 >> 2];
|
|
label$224 : {
|
|
if (($12 | 0) == 1e3) {
|
|
break label$224;
|
|
}
|
|
$20 = HEAP32[$0 + 14228 >> 2];
|
|
if (!(($20 | 0) == ($12 | 0) | ($20 | 0) < 1)) {
|
|
opus_custom_encoder_ctl($19, 4028, 0);
|
|
celt_encode_with_ec($19, $10, HEAP32[$0 + 144 >> 2] / 400 | 0, $14 + 432 | 0, 2, 0);
|
|
HEAP32[$14 + 112 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 10002, $14 + 112 | 0);
|
|
}
|
|
if (((HEAP32[$14 + 460 >> 2] + Math_clz32(HEAP32[$14 + 468 >> 2]) | 0) - 32 | 0) > $13 << 3) {
|
|
break label$224;
|
|
}
|
|
if (!(!HEAP32[$0 + 148 >> 2] | (!$8 | HEAP32[$25 >> 2] != 1001))) {
|
|
HEAP32[$14 + 96 >> 2] = HEAP32[$0 + 160 >> 2] - HEAP32[$0 + 36 >> 2];
|
|
opus_custom_encoder_ctl($19, 4002, $14 + 96 | 0);
|
|
}
|
|
HEAP32[$14 + 80 >> 2] = HEAP32[$0 + 148 >> 2];
|
|
opus_custom_encoder_ctl($19, 4006, $14 + 80 | 0);
|
|
$15 = celt_encode_with_ec($19, $9, $2, 0, $13, $14 + 440 | 0);
|
|
if (($15 | 0) < 0) {
|
|
$13 = -3;
|
|
break label$145;
|
|
}
|
|
if (!HEAP32[$0 + 148 >> 2] | (!$8 | HEAP32[$25 >> 2] != 1001)) {
|
|
break label$224;
|
|
}
|
|
memmove($15 + $40 | 0, $13 + $40 | 0, $5);
|
|
$13 = $5 + $13 | 0;
|
|
}
|
|
label$228 : {
|
|
if (!($4 | $7)) {
|
|
$4 = HEAP32[$0 + 144 >> 2];
|
|
opus_custom_encoder_ctl($19, 4028, 0);
|
|
HEAP32[$14 + 64 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 10010, $14 - -64 | 0);
|
|
HEAP32[$14 + 48 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 10002, $14 + 48 | 0);
|
|
HEAP32[$14 + 32 >> 2] = 0;
|
|
opus_custom_encoder_ctl($19, 4006, $14 + 32 | 0);
|
|
HEAP32[$14 + 16 >> 2] = -1;
|
|
opus_custom_encoder_ctl($19, 4002, $14 + 16 | 0);
|
|
$12 = ($4 | 0) / 400 | 0;
|
|
$4 = ($4 | 0) / 200 | 0;
|
|
if (HEAP32[$0 + 14224 >> 2] == 1001) {
|
|
ec_enc_shrink($14 + 440 | 0, $15);
|
|
$13 = $15;
|
|
}
|
|
$7 = $2 - $4 | 0;
|
|
celt_encode_with_ec($19, (Math_imul(HEAP32[$0 + 112 >> 2], $7 - $12 | 0) << 2) + $9 | 0, $12, $14 + 432 | 0, 2, 0);
|
|
if ((celt_encode_with_ec($19, (Math_imul(HEAP32[$0 + 112 >> 2], $7) << 2) + $9 | 0, $4, $13 + $40 | 0, $5, 0) | 0) < 0) {
|
|
break label$228;
|
|
}
|
|
HEAP32[$14 >> 2] = $14 + 616;
|
|
opus_custom_encoder_ctl($19, 4031, $14);
|
|
}
|
|
$12 = HEAP32[$0 + 14192 >> 2];
|
|
$7 = HEAP32[$0 + 14224 >> 2];
|
|
$13 = 0;
|
|
$4 = HEAP32[$0 + 144 >> 2] / ($2 | 0) | 0;
|
|
if (($4 | 0) <= 399) {
|
|
while (1) {
|
|
$13 = $13 + 1 | 0;
|
|
$4 = $4 << 1;
|
|
if (($4 | 0) < 400) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = $13 << 3;
|
|
}
|
|
$4 = $3;
|
|
label$233 : {
|
|
label$234 : {
|
|
switch ($7 - 1e3 | 0) {
|
|
case 0:
|
|
$13 = $13 - 16 | ($11 << 5) + 96 & 224;
|
|
break label$233;
|
|
case 2:
|
|
$13 = ((($11 | 0) > 1102 ? $11 : 1102) << 5) - -64 & 96 | $13 | 128;
|
|
break label$233;
|
|
default:
|
|
break label$234;
|
|
}
|
|
}
|
|
$13 = $13 + 240 | $11 << 4 | 96;
|
|
}
|
|
HEAP8[$4 | 0] = $13 | (($12 | 0) == 2) << 2;
|
|
$12 = HEAP32[$14 + 468 >> 2];
|
|
HEAP32[$0 + 18136 >> 2] = $12 ^ HEAP32[$14 + 616 >> 2];
|
|
$13 = 1002;
|
|
$13 = $45 ? HEAP32[$25 >> 2] : $13;
|
|
HEAP32[$0 + 14228 >> 2] = $13;
|
|
HEAP32[$0 + 14252 >> 2] = 0;
|
|
HEAP32[$0 + 14236 >> 2] = $2;
|
|
$7 = HEAP32[$0 + 14192 >> 2];
|
|
HEAP32[$0 + 14232 >> 2] = $7;
|
|
label$238 : {
|
|
if (!(!HEAP32[$0 + 184 >> 2] | !(HEAP32[$14 + 544 >> 2] | $41))) {
|
|
label$240 : {
|
|
if (!($51 ^ 1 | HEAPF32[$14 + 580 >> 2] < Math_fround(.10000000149011612) ^ 1)) {
|
|
$21 = HEAPF32[$0 + 18128 >> 2];
|
|
$16 = Math_fround(0);
|
|
$4 = Math_imul(HEAP32[$0 + 112 >> 2], $2);
|
|
if (($4 | 0) >= 1) {
|
|
$13 = 0;
|
|
while (1) {
|
|
$17 = HEAPF32[($13 << 2) + $1 >> 2];
|
|
$16 = Math_fround($16 + Math_fround($17 * $17));
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$41 = Math_fround(Math_fround($16 / Math_fround($4 | 0)) * Math_fround(316.2300109863281)) <= $21;
|
|
}
|
|
if ($41) {
|
|
$13 = HEAP32[$0 + 18124 >> 2];
|
|
HEAP32[$0 + 18124 >> 2] = $13 + 1;
|
|
if (($13 | 0) < 10) {
|
|
break label$238;
|
|
}
|
|
if (($13 | 0) < 30) {
|
|
break label$240;
|
|
}
|
|
HEAP32[$0 + 18124 >> 2] = 10;
|
|
break label$238;
|
|
}
|
|
HEAP32[$0 + 18124 >> 2] = 0;
|
|
break label$238;
|
|
}
|
|
$13 = 0;
|
|
HEAP32[$0 + 18136 >> 2] = 0;
|
|
$1 = HEAP32[$0 + 14224 >> 2];
|
|
$0 = HEAP32[$0 + 144 >> 2] / ($2 | 0) | 0;
|
|
if (($0 | 0) <= 399) {
|
|
while (1) {
|
|
$13 = $13 + 1 | 0;
|
|
$0 = $0 << 1;
|
|
if (($0 | 0) < 400) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = $13 << 3;
|
|
}
|
|
label$248 : {
|
|
label$249 : {
|
|
switch ($1 - 1e3 | 0) {
|
|
case 0:
|
|
$0 = $13 - 16 | ($11 << 5) + 96 & 224;
|
|
break label$248;
|
|
case 2:
|
|
$0 = ((($11 | 0) > 1102 ? $11 : 1102) << 5) - -64 & 96 | $13 | 128;
|
|
break label$248;
|
|
default:
|
|
break label$249;
|
|
}
|
|
}
|
|
$0 = $13 + 240 | $11 << 4 | 96;
|
|
}
|
|
HEAP8[$3 | 0] = $0 | (($7 | 0) == 2) << 2;
|
|
$13 = 1;
|
|
break label$145;
|
|
}
|
|
HEAP32[$0 + 18124 >> 2] = 0;
|
|
}
|
|
label$252 : {
|
|
if (((HEAP32[$14 + 460 >> 2] + Math_clz32($12) | 0) - 32 | 0) > $22 << 3) {
|
|
HEAP8[$40 | 0] = 0;
|
|
HEAP32[$0 + 18136 >> 2] = 0;
|
|
$15 = 1;
|
|
break label$252;
|
|
}
|
|
if (HEAP32[$25 >> 2] != 1e3 | $6 | ($15 | 0) < 3) {
|
|
break label$252;
|
|
}
|
|
while (1) {
|
|
if (HEAPU8[$3 + $15 | 0]) {
|
|
break label$252;
|
|
}
|
|
$13 = ($15 | 0) > 3;
|
|
$15 = $15 - 1 | 0;
|
|
if ($13) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$15 = 2;
|
|
}
|
|
$2 = ($5 + $15 | 0) + 1 | 0;
|
|
label$255 : {
|
|
if (HEAP32[$0 + 148 >> 2]) {
|
|
$23 = $2;
|
|
break label$255;
|
|
}
|
|
$13 = -3;
|
|
if (opus_packet_pad($3, $2, $23)) {
|
|
break label$145;
|
|
}
|
|
}
|
|
$13 = $23;
|
|
break label$145;
|
|
}
|
|
$13 = -3;
|
|
}
|
|
}
|
|
__stack_pointer = $14 + 624 | 0;
|
|
return $13;
|
|
}
|
|
function celt_encode_with_ec($0, $1, $2, $3, $4, $5) {
|
|
var $6 = Math_fround(0), $7 = 0, $8 = Math_fround(0), $9 = 0, $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = Math_fround(0), $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = Math_fround(0), $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $54 = 0, $55 = 0, $56 = 0, $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $62 = 0, $63 = Math_fround(0), $64 = 0, $65 = 0, $66 = Math_fround(0), $67 = 0, $68 = Math_fround(0), $69 = Math_fround(0), $70 = 0, $71 = Math_fround(0), $72 = Math_fround(0);
|
|
$39 = __stack_pointer - 192 | 0;
|
|
__stack_pointer = $39;
|
|
$13 = HEAP32[$0 + 8 >> 2];
|
|
$11 = HEAP32[$0 + 4 >> 2];
|
|
$16 = $39;
|
|
HEAP32[$16 + 28 >> 2] = 15;
|
|
HEAP32[$16 + 24 >> 2] = 0;
|
|
HEAP32[$16 + 20 >> 2] = 0;
|
|
HEAP32[$16 + 16 >> 2] = 0;
|
|
HEAP32[$16 + 4 >> 2] = 0;
|
|
$14 = HEAP32[$0 + 36 >> 2];
|
|
$20 = HEAP32[$0 + 32 >> 2];
|
|
$19 = HEAP32[$0 >> 2];
|
|
$18 = HEAP32[$19 + 32 >> 2];
|
|
$24 = HEAP32[$19 + 4 >> 2];
|
|
$30 = HEAP32[$19 + 8 >> 2];
|
|
HEAP32[$16 + 12 >> 2] = 0;
|
|
$7 = -1;
|
|
label$1 : {
|
|
if (!$1 | ($4 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
$21 = HEAP32[$19 + 36 >> 2];
|
|
if (($21 | 0) < 0) {
|
|
break label$1;
|
|
}
|
|
$37 = Math_imul(HEAP32[$0 + 28 >> 2], $2);
|
|
$28 = HEAP32[$19 + 44 >> 2];
|
|
while (1) {
|
|
if ($28 << $15 != ($37 | 0)) {
|
|
$2 = ($15 | 0) < ($21 | 0);
|
|
$15 = $15 + 1 | 0;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break label$1;
|
|
}
|
|
break;
|
|
}
|
|
label$4 : {
|
|
if (!$5) {
|
|
$57 = 1;
|
|
$9 = 1;
|
|
$17 = 0;
|
|
break label$4;
|
|
}
|
|
$57 = ec_tell_frac($5);
|
|
$2 = HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0;
|
|
$9 = $2 - 32 | 0;
|
|
$17 = $2 - 28 >> 3;
|
|
}
|
|
label$6 : {
|
|
label$7 : {
|
|
if (!HEAP32[$0 + 48 >> 2]) {
|
|
$21 = $24 + 1024 | 0;
|
|
$26 = ($4 | 0) < 1275 ? $4 : 1275;
|
|
$29 = $26 - $17 | 0;
|
|
$2 = HEAP32[$0 + 40 >> 2];
|
|
label$9 : {
|
|
if (HEAP32[$0 + 44 >> 2]) {
|
|
if (($2 | 0) == -1) {
|
|
break label$7;
|
|
}
|
|
$28 = HEAP32[$19 >> 2];
|
|
$42 = (Math_imul($2, $37) + ($28 >> 4) | 0) / ($28 >> 3) | 0;
|
|
$35 = $42 >> 6;
|
|
break label$9;
|
|
}
|
|
if (($2 | 0) == -1) {
|
|
break label$7;
|
|
}
|
|
$28 = HEAP32[$19 >> 2];
|
|
$28 = ((Math_imul($2, $37) + (($9 | 0) > 1 ? $9 : 0) | 0) + ($28 << 2) | 0) / ($28 << 3) | 0;
|
|
$28 = ($28 | 0) > ($26 | 0) ? $26 : $28;
|
|
$26 = ($28 | 0) > 2 ? $28 : 2;
|
|
$35 = $26 - $17 | 0;
|
|
}
|
|
$7 = $2;
|
|
break label$6;
|
|
}
|
|
celt_fatal(42472, 42508, 1547);
|
|
abort();
|
|
}
|
|
$35 = $29;
|
|
}
|
|
$2 = Math_imul($11, $21);
|
|
$48 = 3 - $15 | 0;
|
|
$21 = Math_imul($26, 400);
|
|
if (!$5) {
|
|
ec_enc_init($16 + 32 | 0, $3, $26);
|
|
$5 = $16 + 32 | 0;
|
|
}
|
|
$53 = $0 + 244 | 0;
|
|
$2 = $2 << 2;
|
|
$50 = Math_imul($11, $30);
|
|
$3 = $21 >> $48;
|
|
label$12 : {
|
|
if (!HEAP32[$0 + 52 >> 2] | ($42 | 0) < 1) {
|
|
break label$12;
|
|
}
|
|
$21 = (($9 | 0) == 1) << 1;
|
|
$28 = ($42 << 1) - HEAP32[$0 + 208 >> 2] >> 6;
|
|
$21 = ($21 | 0) > ($28 | 0) ? $21 : $28;
|
|
if (($29 | 0) <= ($21 | 0)) {
|
|
break label$12;
|
|
}
|
|
$26 = $17 + $21 | 0;
|
|
ec_enc_shrink($5, $26);
|
|
$29 = $21;
|
|
}
|
|
$21 = $2 + $53 | 0;
|
|
$27 = $50 << 2;
|
|
$12 = ($3 | 0) < ($7 | 0);
|
|
$31 = Math_imul($13, 40);
|
|
$32 = 400 >>> $15 | 0;
|
|
$23 = HEAP32[$19 + 12 >> 2];
|
|
$4 = $24 + $37 | 0;
|
|
$33 = $39 - ((Math_imul($11, $4) << 2) + 15 & -16) | 0;
|
|
$38 = $33;
|
|
__stack_pointer = $33;
|
|
$34 = HEAPF32[$0 + 224 >> 2];
|
|
$54 = HEAP32[$0 + 28 >> 2];
|
|
$39 = (Math_imul($37 - $24 | 0, $13) | 0) / ($54 | 0) | 0;
|
|
label$13 : {
|
|
label$14 : {
|
|
if (($39 | 0) >= 1) {
|
|
$2 = 0;
|
|
while (1) {
|
|
$6 = HEAPF32[($2 << 2) + $1 >> 2];
|
|
$10 = $6 > $10 ? $10 : $6;
|
|
$8 = $6 < $8 ? $8 : $6;
|
|
$2 = $2 + 1 | 0;
|
|
if (($39 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = Math_fround(-$10);
|
|
if (($6 < $8 ? $8 : $6) < $34) {
|
|
break label$13;
|
|
}
|
|
$2 = 0;
|
|
$10 = Math_fround(0);
|
|
$8 = Math_fround(0);
|
|
while (1) {
|
|
$6 = HEAPF32[($2 << 2) + $1 >> 2];
|
|
$10 = $6 > $10 ? $10 : $6;
|
|
$8 = $6 < $8 ? $8 : $6;
|
|
$2 = $2 + 1 | 0;
|
|
if (($39 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$14;
|
|
}
|
|
if ($34 > Math_fround(0)) {
|
|
break label$13;
|
|
}
|
|
}
|
|
$6 = Math_fround(-$10);
|
|
$34 = $6 < $8 ? $8 : $6;
|
|
}
|
|
$22 = Math_imul($11, $24);
|
|
$28 = $21 + $27 | 0;
|
|
$12 = $12 ? $3 : $7;
|
|
$25 = ($7 | 0) == -1;
|
|
$58 = $31 + 20 | 0;
|
|
$31 = $32 - 50 | 0;
|
|
$51 = 1;
|
|
$10 = Math_fround(0);
|
|
$7 = (Math_imul($13, $24) | 0) / ($54 | 0) | 0;
|
|
label$18 : {
|
|
if (($7 | 0) < 1) {
|
|
$8 = Math_fround(0);
|
|
break label$18;
|
|
}
|
|
$39 = ($39 << 2) + $1 | 0;
|
|
$2 = 0;
|
|
$8 = Math_fround(0);
|
|
while (1) {
|
|
$6 = HEAPF32[($2 << 2) + $39 >> 2];
|
|
$10 = $6 > $10 ? $10 : $6;
|
|
$8 = $6 < $8 ? $8 : $6;
|
|
$2 = $2 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$2 = $22 << 2;
|
|
$39 = $27 + $28 | 0;
|
|
$7 = $25 ? $3 : $12;
|
|
$3 = Math_imul($31, $58);
|
|
$12 = ($14 | 0) > ($23 | 0);
|
|
$22 = $26 << 3;
|
|
$6 = Math_fround(-$10);
|
|
$6 = $6 < $8 ? $8 : $6;
|
|
HEAPF32[$0 + 224 >> 2] = $6;
|
|
$6 = $6 < $34 ? $34 : $6;
|
|
label$21 : {
|
|
if (($9 | 0) != 1) {
|
|
$31 = 0;
|
|
break label$21;
|
|
}
|
|
$9 = Math_fround(Math_fround(1) / Math_fround(1 << HEAP32[$0 + 60 >> 2])) >= $6;
|
|
ec_enc_bit_logp($5, $9, 15);
|
|
if ($9 ^ 1) {
|
|
$31 = 0;
|
|
$9 = 1;
|
|
break label$21;
|
|
}
|
|
$31 = 1;
|
|
label$24 : {
|
|
if (($42 | 0) < 1) {
|
|
$9 = $22;
|
|
break label$24;
|
|
}
|
|
$29 = 2;
|
|
$9 = $17 + 2 | 0;
|
|
$35 = ($9 | 0) > ($26 | 0) ? $26 : $9;
|
|
ec_enc_shrink($5, $35);
|
|
$26 = $35;
|
|
$9 = $26 << 3;
|
|
$22 = $9;
|
|
}
|
|
HEAP32[$5 + 20 >> 2] = ($9 - Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) + 32;
|
|
$51 = 0;
|
|
}
|
|
$17 = $2 + $53 | 0;
|
|
$53 = $27 + $39 | 0;
|
|
$43 = 1 << $15;
|
|
$46 = $7 - $3 | 0;
|
|
$25 = $12 ? $23 : $14;
|
|
$54 = ($11 | 0) > 1 ? $11 : 1;
|
|
$3 = $19 + 16 | 0;
|
|
$24 = ($24 << 2) + $33 | 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$7 = $2 << 2;
|
|
celt_preemphasis($7 + $1 | 0, (Math_imul($2, $4) << 2) + $24 | 0, $37, $11, HEAP32[$0 + 28 >> 2], $3, ($0 + $7 | 0) + 192 | 0, HEAP32[$0 + 16 >> 2] != 0 & $6 > Math_fround(65536));
|
|
$2 = $2 + 1 | 0;
|
|
if (($54 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$2 = 0;
|
|
if (!(HEAP32[$0 + 20 >> 2] | (!(HEAP32[$0 + 64 >> 2] != 0 & ($29 | 0) > 3 | (Math_imul($13, 12) | 0) < ($29 | 0)) | ($20 | $31)))) {
|
|
$2 = HEAP32[$0 + 24 >> 2] > 4;
|
|
}
|
|
$64 = HEAP32[$0 + 100 >> 2];
|
|
$52 = $0 + 120 | 0;
|
|
$59 = run_prefilter($0, $33, $17, $11, $37, $64, $16 + 28 | 0, $16 + 24 | 0, $16 + 80 | 0, $2, $29, $52);
|
|
$66 = HEAPF32[$16 + 24 >> 2];
|
|
label$28 : {
|
|
if (!($66 > Math_fround(.4000000059604645))) {
|
|
$1 = 0;
|
|
if (HEAPF32[$0 + 108 >> 2] > Math_fround(.4000000059604645) ^ 1) {
|
|
break label$28;
|
|
}
|
|
}
|
|
if (HEAP32[$52 >> 2]) {
|
|
$1 = 0;
|
|
if (+HEAPF32[$0 + 124 >> 2] > .3 ^ 1) {
|
|
break label$28;
|
|
}
|
|
}
|
|
$60 = +HEAP32[$16 + 28 >> 2];
|
|
$61 = +HEAP32[$0 + 104 >> 2];
|
|
$1 = $60 > $61 * 1.26 | $61 * .79 > $60;
|
|
}
|
|
$65 = $1;
|
|
label$31 : {
|
|
if (!$59) {
|
|
if (($9 + 16 | 0) > ($22 | 0) | $20) {
|
|
break label$31;
|
|
}
|
|
ec_enc_bit_logp($5, 0, 1);
|
|
break label$31;
|
|
}
|
|
ec_enc_bit_logp($5, 1, 1);
|
|
$2 = HEAP32[$16 + 28 >> 2];
|
|
$1 = $2 + 1 | 0;
|
|
$7 = Math_clz32($1);
|
|
$3 = 27 - $7 | 0;
|
|
ec_enc_uint($5, $3, 6);
|
|
ec_enc_bits($5, (-16 << $3) + $1 | 0, 31 - $7 | 0);
|
|
HEAP32[$16 + 28 >> 2] = $2;
|
|
ec_enc_bits($5, HEAP32[$16 + 80 >> 2], 3);
|
|
ec_enc_icdf($5, $64, 42528, 2);
|
|
}
|
|
$62 = 1;
|
|
if (!(HEAP32[$0 + 64 >> 2] | HEAP32[$0 + 24 >> 2] < 1)) {
|
|
$2 = 0;
|
|
$2 = !$20 | ($35 | 0) > 14 ? $2 : HEAP32[$0 + 184 >> 2] != 2;
|
|
$36 = transient_analysis($33, $4, $11, $16 + 12 | 0, $16 + 16 | 0, $2, $16 + 4 | 0);
|
|
}
|
|
$3 = $19;
|
|
label$35 : {
|
|
label$36 : {
|
|
if (!(!$15 | ((HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 29 | 0) > ($22 | 0))) {
|
|
if ($36) {
|
|
break label$36;
|
|
}
|
|
$62 = 0;
|
|
}
|
|
$32 = $38 - ((Math_imul($11, $37) << 2) + 15 & -16) | 0;
|
|
$2 = $32;
|
|
__stack_pointer = $2;
|
|
$1 = ($50 << 2) + 15 & -16;
|
|
$38 = $2 - $1 | 0;
|
|
$2 = $38;
|
|
__stack_pointer = $2;
|
|
$4 = $2 - $1 | 0;
|
|
$2 = $4;
|
|
__stack_pointer = $2;
|
|
$40 = Math_imul($13, $30);
|
|
$31 = $2 - (($40 << 2) + 15 & -16) | 0;
|
|
$7 = $31;
|
|
__stack_pointer = $7;
|
|
$55 = 1;
|
|
$36 = 0;
|
|
$56 = 0;
|
|
break label$35;
|
|
}
|
|
$32 = $38 - ((Math_imul($11, $37) << 2) + 15 & -16) | 0;
|
|
$2 = $32;
|
|
__stack_pointer = $2;
|
|
$1 = ($50 << 2) + 15 & -16;
|
|
$38 = $2 - $1 | 0;
|
|
$2 = $38;
|
|
__stack_pointer = $2;
|
|
$4 = $2 - $1 | 0;
|
|
$2 = $4;
|
|
__stack_pointer = $2;
|
|
$40 = Math_imul($13, $30);
|
|
$31 = $2 - (($40 << 2) + 15 & -16) | 0;
|
|
$7 = $31;
|
|
__stack_pointer = $7;
|
|
$1 = HEAP32[$0 + 24 >> 2];
|
|
label$38 : {
|
|
if (($1 | 0) < 8) {
|
|
$62 = 0;
|
|
break label$38;
|
|
}
|
|
$62 = 0;
|
|
compute_mdcts($19, 0, $33, $32, $13, $11, $15, HEAP32[$0 + 28 >> 2], HEAP32[$0 + 72 >> 2]);
|
|
compute_band_energies($19, $32, $38, $25, $13, $15, HEAP32[$0 + 72 >> 2]);
|
|
amp2Log2($19, $25, $14, $38, $31, $13);
|
|
$49 = 1;
|
|
if (($40 | 0) < 1) {
|
|
break label$38;
|
|
}
|
|
$6 = Math_fround(Math_fround($15 | 0) * Math_fround(.5));
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = ($2 << 2) + $31 | 0;
|
|
HEAPF32[$1 >> 2] = $6 + HEAPF32[$1 >> 2];
|
|
$2 = $2 + 1 | 0;
|
|
if (($40 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$56 = $43;
|
|
}
|
|
compute_mdcts($3, $56, $33, $32, $13, $11, $15, HEAP32[$0 + 28 >> 2], HEAP32[$0 + 72 >> 2]);
|
|
label$41 : {
|
|
label$42 : {
|
|
$6 = HEAPF32[$32 >> 2];
|
|
if ($6 == $6) {
|
|
if (($13 | 0) == 1) {
|
|
break label$42;
|
|
}
|
|
$6 = HEAPF32[($37 << 2) + $32 >> 2];
|
|
$1 = 0;
|
|
if ($6 == $6) {
|
|
break label$41;
|
|
}
|
|
}
|
|
celt_fatal(42531, 42508, 1729);
|
|
abort();
|
|
}
|
|
$1 = 0;
|
|
if (($11 | 0) != 2) {
|
|
break label$41;
|
|
}
|
|
HEAP32[$16 + 16 >> 2] = 0;
|
|
$1 = 1;
|
|
}
|
|
$70 = $1;
|
|
compute_band_energies($19, $32, $38, $25, $13, $15, HEAP32[$0 + 72 >> 2]);
|
|
if (!(!HEAP32[$0 + 64 >> 2] | ($14 | 0) < 3)) {
|
|
$2 = 2;
|
|
while (1) {
|
|
$1 = ($2 << 2) + $38 | 0;
|
|
$6 = HEAPF32[$1 >> 2];
|
|
$8 = Math_fround(HEAPF32[$38 >> 2] * Math_fround(9999999747378752e-20));
|
|
$6 = $6 < $8 ? $6 : $8;
|
|
HEAPF32[$1 >> 2] = $6 > Math_fround(1.0000000036274937e-15) ? $6 : Math_fround(1.0000000036274937e-15);
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
amp2Log2($19, $25, $14, $38, $4, $13);
|
|
$2 = $7 - (($40 << 2) + 15 & -16) | 0;
|
|
$44 = $2;
|
|
__stack_pointer = $2;
|
|
$67 = $14 << 2;
|
|
$45 = memset($2, 0, $67);
|
|
$6 = Math_fround(0);
|
|
label$46 : {
|
|
label$47 : {
|
|
if ($20) {
|
|
break label$47;
|
|
}
|
|
$9 = HEAP32[$0 + 236 >> 2];
|
|
$6 = Math_fround(0);
|
|
if (!$9) {
|
|
break label$47;
|
|
}
|
|
$1 = HEAP32[$0 + 64 >> 2];
|
|
if ($1) {
|
|
break label$46;
|
|
}
|
|
label$48 : {
|
|
label$49 : {
|
|
label$50 : {
|
|
if (($13 | 0) < 1) {
|
|
break label$50;
|
|
}
|
|
$2 = HEAP32[$0 + 92 >> 2];
|
|
$1 = ($2 | 0) > 2 ? $2 : 2;
|
|
$47 = HEAPU16[$18 >> 1];
|
|
$12 = 0;
|
|
$3 = 0;
|
|
$8 = Math_fround(0);
|
|
$10 = Math_fround(0);
|
|
while (1) {
|
|
$17 = Math_imul($12, $30);
|
|
$7 = $47;
|
|
$2 = 0;
|
|
while (1) {
|
|
$6 = HEAPF32[($2 + $17 << 2) + $9 >> 2];
|
|
$41 = $6;
|
|
$24 = $6 < Math_fround(.25);
|
|
$27 = ($24 ? $6 : Math_fround(.25)) > Math_fround(-2);
|
|
$6 = $27 ? Math_fround(.25) : Math_fround(-2);
|
|
$6 = $27 ? $24 ? $41 : $6 : $6;
|
|
$6 = $6 > Math_fround(0) ? Math_fround($6 * Math_fround(.5)) : $6;
|
|
$8 = Math_fround($8 + Math_fround($6 * Math_fround(($2 << 1 | 1) - $1 | 0)));
|
|
$24 = $7 << 16;
|
|
$2 = $2 + 1 | 0;
|
|
$7 = HEAP16[($2 << 1) + $18 >> 1];
|
|
$24 = $7 - ($24 >> 16) | 0;
|
|
$10 = Math_fround($10 + Math_fround($6 * Math_fround($24 | 0)));
|
|
$3 = $3 + $24 | 0;
|
|
if (($1 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($13 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$2 = 0;
|
|
if (($3 | 0) <= 0) {
|
|
break label$50;
|
|
}
|
|
$6 = Math_fround(Math_fround(Math_fround($8 * Math_fround(6)) / Math_fround(Math_imul($1 + 1 | 0, Math_imul($1 - 1 | 0, Math_imul($1, $13))) | 0)) * Math_fround(.5));
|
|
$6 = $6 < Math_fround(.03099999949336052) ? $6 : Math_fround(.03099999949336052);
|
|
$8 = Math_fround($10 / Math_fround($3 | 0));
|
|
$3 = HEAP16[($1 << 1) + $18 >> 1] / 2 << 16 >> 16;
|
|
while (1) {
|
|
$7 = $2;
|
|
$2 = $2 + 1 | 0;
|
|
if (HEAP16[($2 << 1) + $18 >> 1] < ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$34 = $6 > Math_fround(-.03099999949336052) ? $6 : Math_fround(-.03099999949336052);
|
|
$10 = Math_fround($8 + Math_fround(.20000000298023224));
|
|
$2 = 0;
|
|
$24 = 0;
|
|
while (1) {
|
|
$8 = Math_fround($10 + Math_fround($34 * Math_fround($2 - $7 | 0)));
|
|
$3 = $2 << 2;
|
|
$6 = HEAPF32[$9 + $3 >> 2];
|
|
if (($13 | 0) == 2) {
|
|
$63 = HEAPF32[($2 + $30 << 2) + $9 >> 2];
|
|
$6 = $6 > $63 ? $6 : $63;
|
|
}
|
|
$6 = Math_fround(($6 < Math_fround(0) ? $6 : Math_fround(0)) - $8);
|
|
if (!($6 > Math_fround(.25) ^ 1)) {
|
|
HEAPF32[$3 + $45 >> 2] = $6 + Math_fround(-.25);
|
|
$24 = $24 + 1 | 0;
|
|
}
|
|
$2 = $2 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($24 | 0) < 3) {
|
|
break label$48;
|
|
}
|
|
$6 = Math_fround($10 + Math_fround(.25));
|
|
$10 = Math_fround(0);
|
|
if (!($6 > Math_fround(0) ^ 1)) {
|
|
break label$49;
|
|
}
|
|
$2 = 0;
|
|
while (1) {
|
|
$7 = ($2 << 2) + $45 | 0;
|
|
HEAPF32[$7 >> 2] = Math_max(Math_fround(HEAPF32[$7 >> 2] + Math_fround(-.25)), Math_fround(0));
|
|
$2 = $2 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$10 = $6;
|
|
break label$48;
|
|
}
|
|
celt_fatal(42604, 42508, 1770);
|
|
abort();
|
|
}
|
|
memset($45, 0, $1 << 2);
|
|
$34 = Math_fround(0);
|
|
}
|
|
$71 = Math_fround($34 * Math_fround(64));
|
|
$6 = Math_fround($10 + Math_fround(.20000000298023224));
|
|
}
|
|
$63 = $6;
|
|
$1 = HEAP32[$0 + 64 >> 2];
|
|
if ($1) {
|
|
break label$46;
|
|
}
|
|
$8 = Math_fround(0);
|
|
if (($14 | 0) > ($20 | 0)) {
|
|
$34 = $55 ? Math_fround(0) : Math_fround(Math_fround($15 | 0) * Math_fround(.5));
|
|
$6 = Math_fround(-10);
|
|
$2 = $20;
|
|
while (1) {
|
|
$6 = Math_fround($6 + Math_fround(-1));
|
|
$10 = Math_fround(HEAPF32[($2 << 2) + $4 >> 2] - $34);
|
|
$6 = $6 > $10 ? $6 : $10;
|
|
if (($13 | 0) == 2) {
|
|
$10 = Math_fround(HEAPF32[($2 + $30 << 2) + $4 >> 2] - $34);
|
|
$6 = $6 > $10 ? $6 : $10;
|
|
}
|
|
$8 = Math_fround($8 + $6);
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = HEAPF32[$0 + 240 >> 2];
|
|
$68 = Math_fround(Math_min(Math_fround(Math_max(Math_fround(Math_fround($8 / Math_fround($14 - $20 | 0)) - $6), Math_fround(-1.5))), Math_fround(3)));
|
|
HEAPF32[$0 + 240 >> 2] = $6 + Math_fround($68 * Math_fround(.019999999552965164));
|
|
$1 = 0;
|
|
}
|
|
if (!$49) {
|
|
memcpy($31, $4, $40 << 2);
|
|
}
|
|
label$64 : {
|
|
if (!$15) {
|
|
break label$64;
|
|
}
|
|
$2 = (HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 29 | 0;
|
|
label$65 : {
|
|
if (($22 | 0) < ($2 | 0) | $36) {
|
|
break label$65;
|
|
}
|
|
$36 = 0;
|
|
if ($1 | $20 | HEAP32[$0 + 24 >> 2] < 5) {
|
|
break label$65;
|
|
}
|
|
$2 = 1;
|
|
$6 = HEAPF32[$21 >> 2];
|
|
label$66 : {
|
|
label$67 : {
|
|
if (($13 | 0) == 1) {
|
|
HEAPF32[$16 + 80 >> 2] = $6;
|
|
if (($14 | 0) < 2) {
|
|
break label$66;
|
|
}
|
|
while (1) {
|
|
$6 = Math_fround($6 + Math_fround(-1));
|
|
$1 = $2 << 2;
|
|
$8 = HEAPF32[$21 + $1 >> 2];
|
|
$6 = $6 > $8 ? $6 : $8;
|
|
HEAPF32[($16 + 80 | 0) + $1 >> 2] = $6;
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$67;
|
|
}
|
|
$8 = HEAPF32[($30 << 2) + $21 >> 2];
|
|
$6 = $6 > $8 ? $6 : $8;
|
|
HEAPF32[$16 + 80 >> 2] = $6;
|
|
if (($14 | 0) < 2) {
|
|
break label$66;
|
|
}
|
|
while (1) {
|
|
$6 = Math_fround($6 + Math_fround(-1));
|
|
$1 = $2 << 2;
|
|
$8 = HEAPF32[$21 + $1 >> 2];
|
|
$10 = HEAPF32[($2 + $30 << 2) + $21 >> 2];
|
|
$8 = $8 > $10 ? $8 : $10;
|
|
$6 = $6 > $8 ? $6 : $8;
|
|
HEAPF32[($16 + 80 | 0) + $1 >> 2] = $6;
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($14 | 0) < 2) {
|
|
break label$66;
|
|
}
|
|
$2 = $14 - 2 | 0;
|
|
while (1) {
|
|
$1 = ($16 + 80 | 0) + ($2 << 2) | 0;
|
|
$6 = HEAPF32[$1 >> 2];
|
|
$8 = Math_fround(HEAPF32[$1 + 4 >> 2] + Math_fround(-1));
|
|
HEAPF32[$1 >> 2] = $6 > $8 ? $6 : $8;
|
|
$1 = ($2 | 0) > 0;
|
|
$2 = $2 - 1 | 0;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$24 = ($13 | 0) > 1 ? $13 : 1;
|
|
$7 = $14 - 1 | 0;
|
|
$3 = 0;
|
|
$27 = ($14 | 0) < 4;
|
|
$6 = Math_fround(0);
|
|
while (1) {
|
|
if (!$27) {
|
|
$1 = Math_imul($3, $30);
|
|
$2 = 2;
|
|
while (1) {
|
|
$6 = Math_fround($6 + Math_fround(Math_max(Math_fround(Math_fround(Math_max(HEAPF32[($1 + $2 << 2) + $4 >> 2], Math_fround(0))) - Math_fround(Math_max(HEAPF32[($16 + 80 | 0) + ($2 << 2) >> 2], Math_fround(0)))), Math_fround(0))));
|
|
$2 = $2 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $3 + 1 | 0;
|
|
if (($24 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!(Math_fround($6 / Math_fround(Math_imul($14 - 3 | 0, $13) | 0)) > Math_fround(1) ^ 1)) {
|
|
compute_mdcts($19, $43, $33, $32, $13, $11, $15, HEAP32[$0 + 28 >> 2], HEAP32[$0 + 72 >> 2]);
|
|
compute_band_energies($19, $32, $38, $25, $13, $15, HEAP32[$0 + 72 >> 2]);
|
|
amp2Log2($19, $25, $14, $38, $4, $13);
|
|
if (($40 | 0) >= 1) {
|
|
$6 = Math_fround(Math_fround($15 | 0) * Math_fround(.5));
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = ($2 << 2) + $31 | 0;
|
|
HEAPF32[$1 >> 2] = $6 + HEAPF32[$1 >> 2];
|
|
$2 = $2 + 1 | 0;
|
|
if (($40 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$16 + 12 >> 2] = 1045220557;
|
|
$56 = $43;
|
|
$36 = 1;
|
|
}
|
|
$2 = (HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 29 | 0;
|
|
}
|
|
if (($2 | 0) > ($22 | 0)) {
|
|
break label$64;
|
|
}
|
|
ec_enc_bit_logp($5, $36, 3);
|
|
}
|
|
$27 = $44 - ((Math_imul($13, $37) << 2) + 15 & -16) | 0;
|
|
$1 = $27;
|
|
__stack_pointer = $1;
|
|
normalise_bands($19, $32, $1, $38, $25, $13, $43);
|
|
$7 = 0;
|
|
if (!((Math_imul($13, 15) | 0) > ($35 | 0) | $20 | HEAP32[$0 + 24 >> 2] < 2)) {
|
|
$7 = !HEAP32[$0 + 64 >> 2];
|
|
}
|
|
$2 = ($30 << 2) + 15 & -16;
|
|
$49 = $1 - $2 | 0;
|
|
$1 = $49;
|
|
__stack_pointer = $1;
|
|
$1 = $1 - $2 | 0;
|
|
__stack_pointer = $1;
|
|
$12 = $1 - $2 | 0;
|
|
$3 = $12;
|
|
__stack_pointer = $3;
|
|
$72 = dynalloc_analysis($4, $31, $30, $20, $14, $13, $49, HEAP32[$0 + 60 >> 2], HEAP32[$19 + 56 >> 2], $36, HEAP32[$0 + 44 >> 2], HEAP32[$0 + 52 >> 2], $18, $15, $35, $16 + 8 | 0, HEAP32[$0 + 64 >> 2], $45, $52, $1, $3);
|
|
$33 = $3 - $2 | 0;
|
|
$3 = $33;
|
|
__stack_pointer = $3;
|
|
label$79 : {
|
|
if ($7) {
|
|
$2 = 20480 / ($35 | 0) | 0;
|
|
$44 = tf_analysis($19, $25, $36, $33, ($2 | 0) < 78 ? 80 : $2 + 2 | 0, $27, $37, $15, HEAPF32[$16 + 12 >> 2], HEAP32[$16 + 16 >> 2], $1);
|
|
if (($14 | 0) <= ($23 | 0)) {
|
|
break label$79;
|
|
}
|
|
$2 = (($25 << 2) + $33 | 0) - 4 | 0;
|
|
while (1) {
|
|
HEAP32[($23 << 2) + $33 >> 2] = HEAP32[$2 >> 2];
|
|
$23 = $23 + 1 | 0;
|
|
if (($23 | 0) != ($14 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$79;
|
|
}
|
|
if (!(!$20 | !HEAP32[$16 + 4 >> 2])) {
|
|
$44 = 0;
|
|
if (($14 | 0) < 1) {
|
|
break label$79;
|
|
}
|
|
$2 = 0;
|
|
while (1) {
|
|
HEAP32[($2 << 2) + $33 >> 2] = 1;
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$79;
|
|
}
|
|
if (!(!$20 | ($35 | 0) > 14 | HEAP32[$0 + 184 >> 2] == 2)) {
|
|
$44 = $36;
|
|
if (($14 | 0) < 1) {
|
|
break label$79;
|
|
}
|
|
memset($33, 0, $67);
|
|
break label$79;
|
|
}
|
|
$44 = 0;
|
|
if (($14 | 0) < 1) {
|
|
break label$79;
|
|
}
|
|
$2 = 0;
|
|
while (1) {
|
|
HEAP32[($2 << 2) + $33 >> 2] = $36;
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$55 = $0 + 100 | 0;
|
|
$31 = ($13 | 0) > 1 ? $13 : 1;
|
|
$24 = $3 - (($40 << 2) + 15 & -16) | 0;
|
|
$45 = $24;
|
|
__stack_pointer = $24;
|
|
$9 = 0;
|
|
while (1) {
|
|
$32 = ($14 | 0) <= ($20 | 0);
|
|
if (!$32) {
|
|
$3 = Math_imul($9, $30);
|
|
$2 = $20;
|
|
while (1) {
|
|
$1 = $2 + $3 << 2;
|
|
$7 = $4 + $1 | 0;
|
|
$6 = HEAPF32[$7 >> 2];
|
|
if (!(Math_fround(Math_abs(Math_fround($6 - HEAPF32[$1 + $21 >> 2]))) < Math_fround(2) ^ 1)) {
|
|
HEAPF32[$7 >> 2] = $6 + Math_fround(HEAPF32[$1 + $53 >> 2] * Math_fround(-.25));
|
|
}
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($31 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
quant_coarse_energy($19, $20, $14, $25, $4, $21, $22, $24, $5, $13, $15, $29, HEAP32[$0 + 12 >> 2], $0 + 84 | 0, HEAP32[$0 + 24 >> 2] > 3, HEAP32[$0 + 56 >> 2], HEAP32[$0 + 64 >> 2]);
|
|
$47 = 0;
|
|
$1 = HEAP32[$5 + 4 >> 2] << 3;
|
|
$7 = (HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 32 | 0;
|
|
$2 = $36 ? 2 : 4;
|
|
$23 = ($15 | 0) != 0 & $1 >>> 0 >= $7 + ($2 | 1) >>> 0;
|
|
$17 = 0;
|
|
label$90 : {
|
|
if ($32) {
|
|
break label$90;
|
|
}
|
|
$3 = ($20 << 2) + $33 | 0;
|
|
$11 = $1 - $23 | 0;
|
|
label$91 : {
|
|
if ($11 >>> 0 >= $2 + $7 >>> 0) {
|
|
ec_enc_bit_logp($5, HEAP32[$3 >> 2], $2);
|
|
$7 = (HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 32 | 0;
|
|
$17 = HEAP32[$3 >> 2];
|
|
break label$91;
|
|
}
|
|
HEAP32[$3 >> 2] = 0;
|
|
$17 = 0;
|
|
}
|
|
$2 = $20 + 1 | 0;
|
|
if (($14 | 0) == ($2 | 0)) {
|
|
break label$90;
|
|
}
|
|
$3 = $36 ? 4 : 5;
|
|
$9 = $17;
|
|
while (1) {
|
|
$1 = ($2 << 2) + $33 | 0;
|
|
label$94 : {
|
|
if ($3 + $7 >>> 0 <= $11 >>> 0) {
|
|
ec_enc_bit_logp($5, HEAP32[$1 >> 2] ^ $9, $3);
|
|
$9 = HEAP32[$1 >> 2];
|
|
$17 = $17 | $9;
|
|
$7 = (HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 32 | 0;
|
|
break label$94;
|
|
}
|
|
HEAP32[$1 >> 2] = $9;
|
|
}
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$96 : {
|
|
if (!$23) {
|
|
break label$96;
|
|
}
|
|
$2 = ($15 << 3) + 1744 | 0;
|
|
$1 = $36 << 2;
|
|
if (HEAPU8[$2 + ($17 + $1 | 0) | 0] == HEAPU8[(($1 | 2) + $17 | 0) + $2 | 0]) {
|
|
break label$96;
|
|
}
|
|
ec_enc_bit_logp($5, $44, 1);
|
|
$47 = $44 << 1;
|
|
}
|
|
if (!$32) {
|
|
$7 = ($36 << 2) + $47 | 0;
|
|
$3 = $15 << 3;
|
|
$2 = $20;
|
|
while (1) {
|
|
$1 = ($2 << 2) + $33 | 0;
|
|
HEAP32[$1 >> 2] = HEAP8[((HEAP32[$1 >> 2] + $7 | 0) + $3 | 0) + 1744 | 0];
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (((HEAP32[$5 + 20 >> 2] + Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) - 28 | 0) <= ($22 | 0)) {
|
|
label$100 : {
|
|
if (HEAP32[$0 + 64 >> 2]) {
|
|
$2 = 2;
|
|
HEAP32[$0 + 80 >> 2] = 2;
|
|
HEAP32[$0 + 100 >> 2] = 0;
|
|
break label$100;
|
|
}
|
|
$1 = $0;
|
|
label$102 : {
|
|
label$103 : {
|
|
label$104 : {
|
|
if ($20) {
|
|
if (!HEAP32[$0 + 24 >> 2]) {
|
|
break label$103;
|
|
}
|
|
if ($36) {
|
|
break label$104;
|
|
}
|
|
$2 = 3;
|
|
break label$102;
|
|
}
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (!(($2 | 0) > 2 ? !((Math_imul($13, 10) | 0) > ($29 | 0) | $56) : 0)) {
|
|
if (!$2) {
|
|
break label$103;
|
|
}
|
|
break label$104;
|
|
}
|
|
$2 = spreading_decision($19, $27, $0 + 88 | 0, HEAP32[$0 + 80 >> 2], $0 + 96 | 0, $55, ($59 | 0) != 0, $25, $13, $43, $12);
|
|
break label$102;
|
|
}
|
|
$2 = 2;
|
|
break label$102;
|
|
}
|
|
$2 = 0;
|
|
}
|
|
HEAP32[$1 + 80 >> 2] = $2;
|
|
}
|
|
ec_enc_icdf($5, $2, 42630, 5);
|
|
}
|
|
if (HEAP32[$0 + 64 >> 2]) {
|
|
HEAP32[$49 >> 2] = ($35 | 0) > 26 ? 8 : ($35 | 0) / 3 | 0;
|
|
}
|
|
$35 = $45 - (($30 << 2) + 15 & -16) | 0;
|
|
$45 = $35;
|
|
__stack_pointer = $35;
|
|
init_caps($19, $35, $15, $13);
|
|
$12 = $22 << 3;
|
|
$3 = 0;
|
|
$7 = ec_tell_frac($5);
|
|
if (!$32) {
|
|
$29 = 6;
|
|
$25 = $20;
|
|
while (1) {
|
|
$2 = $25;
|
|
$25 = $2 + 1 | 0;
|
|
$9 = $2 << 2;
|
|
$23 = $49 + $9 | 0;
|
|
$1 = 0;
|
|
label$111 : {
|
|
if ((($29 << 3) + $7 | 0) >= ($12 - $3 | 0)) {
|
|
break label$111;
|
|
}
|
|
label$112 : {
|
|
$22 = $9 + $35 | 0;
|
|
if (HEAP32[$22 >> 2] <= 0) {
|
|
$9 = 0;
|
|
break label$112;
|
|
}
|
|
$2 = Math_imul(HEAP16[($25 << 1) + $18 >> 1] - HEAP16[($2 << 1) + $18 >> 1] | 0, $13) << $15;
|
|
$7 = $2 << 3;
|
|
$2 = ($2 | 0) > 48 ? $2 : 48;
|
|
$17 = ($2 | 0) > ($7 | 0) ? $7 : $2;
|
|
$9 = $29;
|
|
$2 = 0;
|
|
while (1) {
|
|
$11 = HEAP32[$23 >> 2];
|
|
ec_enc_bit_logp($5, ($11 | 0) > ($2 | 0), $9);
|
|
$7 = ec_tell_frac($5);
|
|
if (($2 | 0) >= ($11 | 0)) {
|
|
$9 = $2;
|
|
break label$112;
|
|
}
|
|
$1 = $1 + $17 | 0;
|
|
$3 = $3 + $17 | 0;
|
|
if (($7 + 8 | 0) < ($12 - $3 | 0)) {
|
|
$9 = 1;
|
|
$2 = $2 + 1 | 0;
|
|
if (HEAP32[$22 >> 2] <= ($1 | 0)) {
|
|
break label$112;
|
|
}
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$29 = ($29 | 0) > 2 ? $29 - 1 | 0 : 2;
|
|
break label$111;
|
|
}
|
|
if (!$9) {
|
|
break label$111;
|
|
}
|
|
$29 = ($29 | 0) > 2 ? $29 - 1 | 0 : 2;
|
|
}
|
|
HEAP32[$23 >> 2] = $1;
|
|
if (($14 | 0) != ($25 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($13 | 0) == 2) {
|
|
if ($15) {
|
|
$18 = HEAP32[$19 + 32 >> 2];
|
|
$17 = HEAPU16[$18 >> 1];
|
|
$10 = Math_fround(1.0000000036274937e-15);
|
|
$9 = 0;
|
|
$34 = Math_fround(1.0000000036274937e-15);
|
|
while (1) {
|
|
$2 = $17 << 16 >> 16 << $15;
|
|
$9 = $9 + 1 | 0;
|
|
$17 = HEAP16[($9 << 1) + $18 >> 1];
|
|
$1 = $17 << $15;
|
|
if (($2 | 0) < ($1 | 0)) {
|
|
while (1) {
|
|
$6 = HEAPF32[($2 << 2) + $27 >> 2];
|
|
$8 = HEAPF32[($2 + $37 << 2) + $27 >> 2];
|
|
$34 = Math_fround($34 + Math_fround(Math_fround(Math_abs(Math_fround($6 + $8))) + Math_fround(Math_abs(Math_fround($6 - $8)))));
|
|
$10 = Math_fround($10 + Math_fround(Math_fround(Math_abs($6)) + Math_fround(Math_abs($8))));
|
|
$2 = $2 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($9 | 0) != 13) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$2 = HEAP16[$18 + 26 >> 1] << $15 + 1;
|
|
HEAP32[$16 + 20 >> 2] = Math_fround(Math_fround($34 * Math_fround(.7071070075035095)) * Math_fround($2 + ($15 >>> 0 < 2 ? 5 : 13) | 0)) > Math_fround($10 * Math_fround($2 | 0));
|
|
}
|
|
$2 = hysteresis_decision(Math_fround(($46 | 0) / 1e3 | 0), 42640, 42736, 21, HEAP32[$0 + 232 >> 2]);
|
|
$2 = ($2 | 0) < ($20 | 0) ? $20 : $2;
|
|
HEAP32[$0 + 232 >> 2] = ($2 | 0) > ($14 | 0) ? $14 : $2;
|
|
}
|
|
$9 = 5;
|
|
if (($7 + 48 | 0) <= ($12 - $3 | 0)) {
|
|
$22 = $5;
|
|
label$123 : {
|
|
if (!(HEAP32[$0 + 64 >> 2] ? 0 : ($20 | 0) <= 0)) {
|
|
HEAP32[$0 + 228 >> 2] = 0;
|
|
$9 = 5;
|
|
break label$123;
|
|
}
|
|
$12 = HEAP32[$0 + 232 >> 2];
|
|
$34 = HEAPF32[$16 + 12 >> 2];
|
|
$10 = Math_fround(4);
|
|
label$126 : {
|
|
if (($46 | 0) < 64e3) {
|
|
break label$126;
|
|
}
|
|
$10 = Math_fround(5);
|
|
if (($46 | 0) > 79999) {
|
|
break label$126;
|
|
}
|
|
$10 = Math_fround(Math_fround(Math_fround($46 - 64e3 >> 10) * Math_fround(.0625)) + Math_fround(4));
|
|
}
|
|
if (($13 | 0) == 2) {
|
|
$23 = HEAP32[$19 + 32 >> 2];
|
|
$11 = HEAPU16[$23 >> 1];
|
|
$8 = Math_fround(0);
|
|
$18 = 0;
|
|
while (1) {
|
|
$2 = $11 << 16;
|
|
$6 = Math_fround(0);
|
|
$18 = $18 + 1 | 0;
|
|
$11 = HEAP16[($18 << 1) + $23 >> 1];
|
|
$2 = $2 >> 16;
|
|
$7 = $11 - $2 << $15;
|
|
if (($7 | 0) >= 1) {
|
|
$2 = $2 << $15;
|
|
$9 = ($2 << 2) + $27 | 0;
|
|
$17 = ($2 + $37 << 2) + $27 | 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = $2 << 2;
|
|
$6 = Math_fround($6 + Math_fround(HEAPF32[$9 + $1 >> 2] * HEAPF32[$1 + $17 >> 2]));
|
|
$2 = $2 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = Math_fround($8 + $6);
|
|
if (($18 | 0) != 8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$41 = Math_fround(Math_min(Math_fround(Math_abs(Math_fround($8 * Math_fround(.125)))), Math_fround(1)));
|
|
$8 = $41;
|
|
if (($12 | 0) >= 9) {
|
|
$11 = HEAPU16[$23 + 16 >> 1];
|
|
$18 = 8;
|
|
$8 = $41;
|
|
while (1) {
|
|
$2 = $11 << 16;
|
|
$6 = Math_fround(0);
|
|
$18 = $18 + 1 | 0;
|
|
$11 = HEAP16[($18 << 1) + $23 >> 1];
|
|
$2 = $2 >> 16;
|
|
$7 = $11 - $2 << $15;
|
|
if (($7 | 0) >= 1) {
|
|
$2 = $2 << $15;
|
|
$9 = ($2 << 2) + $27 | 0;
|
|
$17 = ($2 + $37 << 2) + $27 | 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = $2 << 2;
|
|
$6 = Math_fround($6 + Math_fround(HEAPF32[$9 + $1 >> 2] * HEAPF32[$1 + $17 >> 2]));
|
|
$2 = $2 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = Math_fround(Math_abs($6));
|
|
$8 = $6 > $8 ? $8 : $6;
|
|
if (($12 | 0) != ($18 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$61 = log(+Math_fround(Math_fround(1.0010000467300415) - Math_fround($41 * $41)));
|
|
$6 = Math_fround(Math_min(Math_fround(Math_abs($8)), Math_fround(1)));
|
|
$60 = log(+Math_fround(Math_fround(1.0010000467300415) - Math_fround($6 * $6)));
|
|
$6 = Math_fround(HEAPF32[$0 + 228 >> 2] + Math_fround(.25));
|
|
$8 = Math_fround($61 * 1.4426950408889634);
|
|
$41 = Math_fround($8 * Math_fround(.5));
|
|
$69 = Math_fround($60 * 1.4426950408889634);
|
|
$41 = Math_fround(($41 > $69 ? $41 : $69) * Math_fround(-.5));
|
|
HEAPF32[$0 + 228 >> 2] = $6 < $41 ? $6 : $41;
|
|
$10 = Math_fround($10 + Math_fround(Math_max(Math_fround($8 * Math_fround(.75)), Math_fround(-4))));
|
|
}
|
|
$7 = $14 - 1 | 0;
|
|
$9 = 2 - $14 | 0;
|
|
$6 = Math_fround(0);
|
|
$17 = 0;
|
|
while (1) {
|
|
if (($14 | 0) >= 2) {
|
|
$1 = Math_imul(HEAP32[$19 + 8 >> 2], $17);
|
|
$2 = 0;
|
|
while (1) {
|
|
$6 = Math_fround($6 + Math_fround(HEAPF32[($1 + $2 << 2) + $4 >> 2] * Math_fround(($2 << 1) + $9 | 0)));
|
|
$2 = $2 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$17 = $17 + 1 | 0;
|
|
if (($31 | 0) != ($17 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = Math_fround(Math_fround(Math_fround($6 / Math_fround(Math_imul($7, $13) | 0)) + Math_fround(1)) / Math_fround(6));
|
|
$2 = $6 > Math_fround(2);
|
|
$1 = $6 < Math_fround(-2);
|
|
$8 = $1 ? $2 ? Math_fround(2) : Math_fround(-2) : Math_fround(2);
|
|
$6 = Math_fround(Math_fround(Math_fround($10 - ($1 ? $8 : $2 ? $8 : $6)) - $71) - Math_fround($34 + $34));
|
|
if (HEAP32[$52 >> 2]) {
|
|
$8 = Math_fround(HEAPF32[$0 + 128 >> 2] + Math_fround(.05000000074505806));
|
|
$8 = Math_fround($8 + $8);
|
|
$2 = $8 > Math_fround(2);
|
|
$1 = $8 < Math_fround(-2);
|
|
$10 = $1 ? $2 ? Math_fround(2) : Math_fround(-2) : Math_fround(2);
|
|
$6 = Math_fround($6 - ($1 ? $10 : $2 ? $10 : $8));
|
|
}
|
|
$6 = Math_fround(Math_floor(Math_fround($6 + Math_fround(.5))));
|
|
label$138 : {
|
|
if (Math_fround(Math_abs($6)) < Math_fround(2147483648)) {
|
|
$2 = ~~$6;
|
|
break label$138;
|
|
}
|
|
$2 = -2147483648;
|
|
}
|
|
$2 = ($2 | 0) < 10 ? $2 : 10;
|
|
$9 = ($2 | 0) > 0 ? $2 : 0;
|
|
}
|
|
ec_enc_icdf($22, $9, 42820, 7);
|
|
$7 = ec_tell_frac($5);
|
|
}
|
|
if (($42 | 0) >= 1) {
|
|
$2 = 1275 >>> $48 | 0;
|
|
$4 = HEAP32[$19 + 36 >> 2];
|
|
if ($20) {
|
|
$1 = (Math_imul($13, -72) + $42 | 0) - 32 | 0;
|
|
$1 = ($1 | 0) > 0 ? $1 : 0;
|
|
} else {
|
|
$1 = $42 - ($58 << 3) | 0;
|
|
}
|
|
$11 = ($2 | 0) > ($26 | 0);
|
|
$18 = $4 - $15 | 0;
|
|
$17 = HEAP32[$0 + 52 >> 2];
|
|
$1 = $17 ? (HEAP32[$0 + 216 >> 2] >> $18) + $1 | 0 : $1;
|
|
$2 = $11 ? $26 : $2;
|
|
$44 = $2;
|
|
label$146 : {
|
|
label$147 : {
|
|
label$148 : {
|
|
if (!$20) {
|
|
$23 = HEAP32[$19 + 32 >> 2];
|
|
$4 = HEAP32[$0 + 92 >> 2];
|
|
$26 = HEAP32[$19 + 8 >> 2];
|
|
$12 = $4 ? $4 : $26;
|
|
$11 = HEAP16[$23 + ($12 << 1) >> 1] << $15;
|
|
$29 = HEAP32[$0 + 236 >> 2];
|
|
$25 = HEAP32[$0 + 64 >> 2];
|
|
$8 = HEAPF32[$0 + 228 >> 2];
|
|
$22 = HEAP32[$0 + 232 >> 2];
|
|
$6 = HEAPF32[$16 + 12 >> 2];
|
|
$48 = HEAP32[$16 + 8 >> 2];
|
|
$11 = ($13 | 0) == 2 ? (HEAP16[((($12 | 0) > ($22 | 0) ? $22 : $12) << 1) + $23 >> 1] << $15) + $11 | 0 : $11;
|
|
$47 = HEAP32[$52 >> 2];
|
|
$4 = $1;
|
|
label$151 : {
|
|
if (!$47) {
|
|
break label$151;
|
|
}
|
|
$10 = HEAPF32[$0 + 136 >> 2];
|
|
$4 = $1;
|
|
if (+$10 < .4 ^ 1) {
|
|
break label$151;
|
|
}
|
|
$43 = $1;
|
|
$10 = Math_fround(Math_fround(Math_fround(.4000000059604645) - $10) * Math_fround($11 << 3));
|
|
label$152 : {
|
|
if (Math_fround(Math_abs($10)) < Math_fround(2147483648)) {
|
|
$4 = ~~$10;
|
|
break label$152;
|
|
}
|
|
$4 = -2147483648;
|
|
}
|
|
$4 = $43 - $4 | 0;
|
|
}
|
|
if (($13 | 0) == 2) {
|
|
$43 = $4;
|
|
$12 = ($12 | 0) > ($22 | 0) ? $22 : $12;
|
|
$12 = (HEAP16[($12 << 1) + $23 >> 1] << $15) - $12 | 0;
|
|
$10 = Math_fround(Math_fround(Math_fround(Math_fround($12 | 0) * Math_fround(.800000011920929)) / Math_fround($11 | 0)) * Math_fround($4 | 0));
|
|
$8 = Math_fround(Math_fround(($8 < Math_fround(1) ? $8 : Math_fround(1)) + Math_fround(-.10000000149011612)) * Math_fround($12 << 3));
|
|
$8 = $8 > $10 ? $10 : $8;
|
|
label$157 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$12 = ~~$8;
|
|
break label$157;
|
|
}
|
|
$12 = -2147483648;
|
|
}
|
|
$4 = $43 - $12 | 0;
|
|
}
|
|
$4 = ((-19 << $15) + $48 | 0) + $4 | 0;
|
|
$8 = Math_fround(Math_fround($6 + Math_fround(-.04399999976158142)) * Math_fround($4 | 0));
|
|
label$154 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$12 = ~~$8;
|
|
break label$154;
|
|
}
|
|
$12 = -2147483648;
|
|
}
|
|
$4 = $12 + $4 | 0;
|
|
if (!(!$47 | $25)) {
|
|
$8 = Math_fround($11 << 3);
|
|
$10 = Math_fround(HEAPF32[$0 + 124 >> 2] + Math_fround(-.15000000596046448));
|
|
$10 = Math_fround(Math_fround($8 * Math_fround(1.2000000476837158)) * ($10 < Math_fround(0) ? Math_fround(-.11999999731779099) : Math_fround($10 + Math_fround(-.11999999731779099))));
|
|
label$161 : {
|
|
if (Math_fround(Math_abs($10)) < Math_fround(2147483648)) {
|
|
$12 = ~~$10;
|
|
break label$161;
|
|
}
|
|
$12 = -2147483648;
|
|
}
|
|
$8 = Math_fround($8 * Math_fround(.800000011920929));
|
|
label$163 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$22 = ~~$8;
|
|
break label$163;
|
|
}
|
|
$22 = -2147483648;
|
|
}
|
|
$4 = $12 + (($65 ? $22 : 0) + $4 | 0) | 0;
|
|
}
|
|
$12 = !$29 | ($25 | 0) != 0;
|
|
if (!$12) {
|
|
$22 = ($4 | 0) / 4 | 0;
|
|
$25 = $22;
|
|
$8 = Math_fround($63 * Math_fround($11 << 3));
|
|
label$166 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$11 = ~~$8;
|
|
break label$166;
|
|
}
|
|
$11 = -2147483648;
|
|
}
|
|
$4 = $11 + $4 | 0;
|
|
$4 = ($4 | 0) < ($22 | 0) ? $25 : $4;
|
|
}
|
|
$11 = $4 >> 2;
|
|
$22 = $4;
|
|
$8 = Math_fround($72 * Math_fround(Math_imul(HEAP16[(($26 << 1) + $23 | 0) - 4 >> 1] << $15, $13) << 3));
|
|
label$168 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$23 = ~~$8;
|
|
break label$168;
|
|
}
|
|
$23 = -2147483648;
|
|
}
|
|
$11 = ($11 | 0) < ($23 | 0) ? $23 : $11;
|
|
$4 = ($4 | 0) < ($11 | 0) ? $22 : $11;
|
|
if (!(!$17 | $12 ^ 1)) {
|
|
$8 = Math_fround(Math_fround($4 - $1 | 0) * Math_fround(.6700000166893005));
|
|
label$171 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$4 = ~~$8;
|
|
break label$171;
|
|
}
|
|
$4 = -2147483648;
|
|
}
|
|
$4 = $4 + $1 | 0;
|
|
}
|
|
$12 = $4;
|
|
if ($29 | $6 < Math_fround(.20000000298023224) ^ 1) {
|
|
break label$147;
|
|
}
|
|
$11 = 96e3 - $46 | 0;
|
|
$11 = ($11 | 0) < 32e3 ? $11 : 32e3;
|
|
$6 = Math_fround(Math_fround((($11 | 0) < 0 ? Math_fround(0) : Math_fround(Math_fround($11 | 0) * Math_fround(3099999958067201e-21))) * $68) * Math_fround($4 | 0));
|
|
if (!(Math_fround(Math_abs($6)) < Math_fround(2147483648))) {
|
|
break label$148;
|
|
}
|
|
$12 = ~~$6 + $4 | 0;
|
|
break label$147;
|
|
}
|
|
$4 = HEAP32[$0 + 188 >> 2];
|
|
$1 = ((($4 | 0) < 100 ? 96 >>> $48 | 0 : 0) + $1 | 0) - (($4 | 0) > 100 ? 144 >>> $48 | 0 : 0) | 0;
|
|
$6 = HEAPF32[$16 + 12 >> 2];
|
|
$8 = Math_fround(Math_fround($6 + Math_fround(-.25)) * Math_fround(400));
|
|
label$173 : {
|
|
if (Math_fround(Math_abs($8)) < Math_fround(2147483648)) {
|
|
$4 = ~~$8;
|
|
break label$173;
|
|
}
|
|
$4 = -2147483648;
|
|
}
|
|
$1 = $1 + $4 | 0;
|
|
$4 = $6 > Math_fround(.699999988079071) ? ($1 | 0) > 400 ? $1 : 400 : $1;
|
|
$1 = (($3 + $7 | 0) + 63 >> 6) + 2 | 0;
|
|
$3 = ($3 + $57 | 0) + 359 >> 6;
|
|
$1 = ($1 | 0) > ($3 | 0) ? $1 : $3;
|
|
break label$146;
|
|
}
|
|
$12 = $4 - -2147483648 | 0;
|
|
}
|
|
$4 = $12;
|
|
$1 = $1 << 1;
|
|
$4 = ($1 | 0) < ($4 | 0) ? $1 : $4;
|
|
$1 = (($3 + $7 | 0) + 63 >> 6) + 2 | 0;
|
|
}
|
|
$4 = $4 + $7 | 0;
|
|
$7 = $4 + 32 >> 6;
|
|
$1 = ($1 | 0) > ($7 | 0) ? $1 : $7;
|
|
$7 = ($1 | 0) > ($2 | 0) ? $44 : $1;
|
|
$6 = Math_fround(.0010000000474974513);
|
|
$1 = HEAP32[$0 + 220 >> 2];
|
|
if (($1 | 0) <= 969) {
|
|
HEAP32[$0 + 220 >> 2] = $1 + 1;
|
|
$6 = Math_fround(Math_fround(1) / Math_fround($1 + 21 | 0));
|
|
}
|
|
$1 = $51 ? $7 : 2;
|
|
label$176 : {
|
|
if (!$17) {
|
|
break label$176;
|
|
}
|
|
$7 = HEAP32[$0 + 208 >> 2] + (($51 ? $7 << 6 : 128) - $42 | 0) | 0;
|
|
HEAP32[$0 + 208 >> 2] = $7;
|
|
$12 = $0;
|
|
$3 = (($51 ? $4 - $42 | 0 : 0) << $18) - HEAP32[$0 + 216 >> 2] | 0;
|
|
$4 = HEAP32[$0 + 212 >> 2];
|
|
$6 = Math_fround($6 * Math_fround($3 - $4 | 0));
|
|
label$177 : {
|
|
if (Math_fround(Math_abs($6)) < Math_fround(2147483648)) {
|
|
$3 = ~~$6;
|
|
break label$177;
|
|
}
|
|
$3 = -2147483648;
|
|
}
|
|
$4 = $3 + $4 | 0;
|
|
HEAP32[$12 + 212 >> 2] = $4;
|
|
HEAP32[$0 + 216 >> 2] = 0 - $4;
|
|
if (($7 | 0) > -1) {
|
|
break label$176;
|
|
}
|
|
HEAP32[$0 + 208 >> 2] = 0;
|
|
$1 = ($51 ? ($7 | 0) / -64 | 0 : 0) + $1 | 0;
|
|
}
|
|
$26 = ($1 | 0) > ($2 | 0) ? $2 : $1;
|
|
ec_enc_shrink($5, $26);
|
|
}
|
|
$1 = ($30 << 2) + 15 & -16;
|
|
$2 = $45 - $1 | 0;
|
|
__stack_pointer = $2;
|
|
$4 = $2 - $1 | 0;
|
|
$7 = $4;
|
|
__stack_pointer = $7;
|
|
$3 = $7 - $1 | 0;
|
|
$11 = $3;
|
|
__stack_pointer = $3;
|
|
$23 = $26 << 6;
|
|
$7 = $23 + (ec_tell_frac($5) ^ -1) | 0;
|
|
$17 = 0;
|
|
$22 = $19;
|
|
$29 = $20;
|
|
$25 = $14;
|
|
$55 = $0 + 232 | 0;
|
|
$57 = $16 + 20 | 0;
|
|
$12 = $7;
|
|
$1 = 0;
|
|
label$179 : {
|
|
if ($15 >>> 0 < 2) {
|
|
break label$179;
|
|
}
|
|
$1 = 0;
|
|
if (!$36) {
|
|
break label$179;
|
|
}
|
|
$17 = (($15 << 3) + 16 | 0) <= ($7 | 0);
|
|
$1 = $17 << 3;
|
|
}
|
|
$18 = $12 - $1 | 0;
|
|
$58 = $16 + 80 | 0;
|
|
$45 = $4;
|
|
$44 = $2;
|
|
$43 = $3;
|
|
$47 = $13;
|
|
$65 = $15;
|
|
$42 = $5;
|
|
$59 = HEAP32[$0 + 92 >> 2];
|
|
if (HEAP32[$52 >> 2]) {
|
|
$12 = HEAP32[$0 + 152 >> 2];
|
|
$48 = $12;
|
|
$7 = 13;
|
|
label$181 : {
|
|
if ((Math_imul($13, 32e3) | 0) > ($46 | 0)) {
|
|
break label$181;
|
|
}
|
|
$7 = 16;
|
|
if ((Math_imul($13, 48e3) | 0) > ($46 | 0)) {
|
|
break label$181;
|
|
}
|
|
$7 = 18;
|
|
if ((Math_imul($13, 6e4) | 0) > ($46 | 0)) {
|
|
break label$181;
|
|
}
|
|
$7 = (Math_imul($13, 8e4) | 0) > ($46 | 0) ? 19 : 20;
|
|
}
|
|
$7 = ($7 | 0) < ($12 | 0) ? $48 : $7;
|
|
} else {
|
|
$7 = $14 - 1 | 0;
|
|
}
|
|
$7 = clt_compute_allocation($22, $29, $25, $49, $35, $9, $55, $57, $18, $58, $45, $44, $43, $47, $65, $42, 1, $59, HEAP32[$0 + 64 >> 2] ? 1 : $7);
|
|
$9 = $7;
|
|
$18 = HEAP32[$0 + 92 >> 2];
|
|
if ($18) {
|
|
$9 = $18 + 1 | 0;
|
|
$18 = $18 - 1 | 0;
|
|
$18 = ($7 | 0) < ($18 | 0) ? $18 : $7;
|
|
$9 = ($9 | 0) < ($18 | 0) ? $9 : $18;
|
|
}
|
|
$18 = $26 << 3;
|
|
HEAP32[$0 + 92 >> 2] = $9;
|
|
quant_fine_energy($19, $20, $14, $21, $24, $2, $5, $13);
|
|
$9 = 0;
|
|
$11 = $11 - ($40 + 15 & -16) | 0;
|
|
__stack_pointer = $11;
|
|
quant_all_bands(1, $19, $20, $14, $27, ($13 | 0) == 2 ? ($37 << 2) + $27 | 0 : 0, $11, $38, $4, $56, HEAP32[$0 + 80 >> 2], HEAP32[$16 + 20 >> 2], HEAP32[$0 + 232 >> 2], $33, $23 - $1 | 0, HEAP32[$16 + 80 >> 2], $5, $15, $7, $0 + 76 | 0, HEAP32[$0 + 24 >> 2], HEAP32[$0 + 72 >> 2], HEAP32[$0 + 68 >> 2]);
|
|
if ($17) {
|
|
ec_enc_bits($5, HEAP32[$0 + 116 >> 2] < 2, 1);
|
|
}
|
|
quant_energy_finalise($19, $20, $14, $21, $24, $2, $3, (($18 - HEAP32[$5 + 20 >> 2] | 0) - Math_clz32(HEAP32[$5 + 28 >> 2]) | 0) + 32 | 0, $5, $13);
|
|
$27 = $50 << 2;
|
|
$3 = memset($53, 0, $27);
|
|
while (1) {
|
|
if (!$32) {
|
|
$4 = Math_imul($9, $30);
|
|
$2 = $20;
|
|
while (1) {
|
|
$1 = $2 + $4 << 2;
|
|
$12 = $3 + $1 | 0;
|
|
$6 = HEAPF32[$1 + $24 >> 2];
|
|
$1 = $6 > Math_fround(.5);
|
|
$7 = ($1 ? Math_fround(.5) : $6) < Math_fround(-.5);
|
|
$8 = $7 ? Math_fround(-.5) : Math_fround(.5);
|
|
HEAPF32[$12 >> 2] = $1 ? $8 : $7 ? $8 : $6;
|
|
$2 = $2 + 1 | 0;
|
|
if (($14 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($31 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!(!($51 ^ 1) | ($40 | 0) < 1)) {
|
|
$2 = 0;
|
|
while (1) {
|
|
HEAP32[($2 << 2) + $21 >> 2] = -1042284544;
|
|
$2 = $2 + 1 | 0;
|
|
if (($40 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$2 = HEAP32[$16 + 28 >> 2];
|
|
HEAP32[$0 + 112 >> 2] = $64;
|
|
HEAPF32[$0 + 108 >> 2] = $66;
|
|
HEAP32[$0 + 104 >> 2] = $2;
|
|
if ($70) {
|
|
$2 = $30 << 2;
|
|
memcpy($21 + $2 | 0, $21, $2);
|
|
}
|
|
label$190 : {
|
|
if ($36) {
|
|
$2 = 0;
|
|
if (($50 | 0) <= 0) {
|
|
break label$190;
|
|
}
|
|
while (1) {
|
|
$1 = $2 << 2;
|
|
$7 = $28 + $1 | 0;
|
|
$6 = HEAPF32[$7 >> 2];
|
|
$8 = HEAPF32[$1 + $21 >> 2];
|
|
HEAPF32[$7 >> 2] = $6 < $8 ? $6 : $8;
|
|
$2 = $2 + 1 | 0;
|
|
if (($50 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$190;
|
|
}
|
|
memcpy($39, $28, $27);
|
|
memcpy($28, $21, $27);
|
|
}
|
|
$3 = ($20 | 0) < 1;
|
|
$4 = 0;
|
|
while (1) {
|
|
if (!$3) {
|
|
$7 = Math_imul($4, $30);
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = $2 + $7 << 2;
|
|
HEAP32[$21 + $1 >> 2] = 0;
|
|
HEAP32[$1 + $39 >> 2] = -1042284544;
|
|
HEAP32[$1 + $28 >> 2] = -1042284544;
|
|
$2 = $2 + 1 | 0;
|
|
if (($20 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($14 | 0) < ($30 | 0)) {
|
|
$7 = Math_imul($4, $30);
|
|
$2 = $14;
|
|
while (1) {
|
|
$1 = $2 + $7 << 2;
|
|
HEAP32[$21 + $1 >> 2] = 0;
|
|
HEAP32[$1 + $39 >> 2] = -1042284544;
|
|
HEAP32[$1 + $28 >> 2] = -1042284544;
|
|
$2 = $2 + 1 | 0;
|
|
if (($30 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if (($54 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$2 = 0;
|
|
$2 = !$36 & ($62 ^ -1) ? $2 : HEAP32[$0 + 116 >> 2] + 1 | 0;
|
|
HEAP32[$0 + 116 >> 2] = $2;
|
|
HEAP32[$0 + 76 >> 2] = HEAP32[$5 + 28 >> 2];
|
|
ec_enc_done($5);
|
|
$7 = HEAP32[$5 + 44 >> 2] ? -3 : $26;
|
|
}
|
|
__stack_pointer = $16 + 192 | 0;
|
|
return $7;
|
|
}
|
|
function run_analysis($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) {
|
|
var $12 = Math_fround(0), $13 = Math_fround(0), $14 = 0, $15 = 0, $16 = 0, $17 = Math_fround(0), $18 = Math_fround(0), $19 = Math_fround(0), $20 = Math_fround(0), $21 = Math_fround(0), $22 = 0, $23 = Math_fround(0), $24 = Math_fround(0), $25 = Math_fround(0), $26 = Math_fround(0), $27 = 0, $28 = 0, $29 = Math_fround(0), $30 = Math_fround(0), $31 = Math_fround(0), $32 = 0, $33 = Math_fround(0), $34 = 0, $35 = Math_fround(0), $36 = 0, $37 = Math_fround(0), $38 = Math_fround(0), $39 = Math_fround(0), $40 = Math_fround(0), $41 = Math_fround(0), $42 = Math_fround(0), $43 = Math_fround(0), $44 = Math_fround(0), $45 = Math_fround(0), $46 = Math_fround(0), $47 = Math_fround(0), $48 = 0, $49 = Math_fround(0), $50 = 0, $51 = 0, $52 = Math_fround(0), $53 = 0, $54 = Math_fround(0), $55 = 0, $56 = Math_fround(0), $57 = Math_fround(0), $58 = 0, $59 = Math_fround(0), $60 = Math_fround(0), $61 = Math_fround(0), $62 = Math_fround(0), $63 = 0, $64 = 0, $65 = 0, $66 = 0, $67 = Math_fround(0), $68 = Math_fround(0), $69 = Math_fround(0), $70 = Math_fround(0), $71 = 0, $72 = 0, $73 = Math_fround(0);
|
|
$14 = __stack_pointer - 11360 | 0;
|
|
__stack_pointer = $14;
|
|
if ($2) {
|
|
$15 = (Math_imul($8, 95) | 0) / 50 | 0;
|
|
$3 = $3 & -2;
|
|
$63 = ($3 | 0) > ($15 | 0) ? $15 : $3;
|
|
$50 = HEAP32[$0 + 7440 >> 2];
|
|
$51 = $63 - $50 | 0;
|
|
if (($51 | 0) >= 1) {
|
|
$64 = $0 + 7464 | 0;
|
|
$71 = $0 + 3852 | 0;
|
|
$72 = $0 + 4812 | 0;
|
|
$65 = $0 + 7592 | 0;
|
|
$53 = $0 + 2892 | 0;
|
|
$55 = ($8 | 0) / 50 | 0;
|
|
$12 = Math_fround(Math_fround(.0005699999746866524) / Math_fround(1 << (($9 | 0) > 8 ? $9 : 8) - 8));
|
|
$56 = Math_fround($12 * $12);
|
|
$73 = Math_fround($56 * Math_fround(3));
|
|
while (1) {
|
|
$8 = ($51 | 0) > ($55 | 0);
|
|
if (!HEAP32[$0 + 7460 >> 2]) {
|
|
HEAP32[$0 + 7460 >> 2] = 1;
|
|
HEAP32[$0 + 5772 >> 2] = 240;
|
|
}
|
|
$22 = $8 ? $55 : $51;
|
|
$48 = HEAP32[$0 + 7436 >> 2];
|
|
$8 = HEAP32[$0 + 8 >> 2];
|
|
label$5 : {
|
|
if (($8 | 0) != 16e3) {
|
|
$16 = $50;
|
|
if (($8 | 0) != 48e3) {
|
|
break label$5;
|
|
}
|
|
$22 = ($22 | 0) / 2 | 0;
|
|
$16 = ($50 | 0) / 2 | 0;
|
|
break label$5;
|
|
}
|
|
$22 = (Math_imul($22, 3) | 0) / 2 | 0;
|
|
$16 = (Math_imul($50, 3) | 0) / 2 | 0;
|
|
}
|
|
$28 = HEAP32[$1 + 72 >> 2];
|
|
$3 = HEAP32[$0 + 5772 >> 2];
|
|
$15 = (($3 << 2) + $0 | 0) + 2892 | 0;
|
|
$3 = 720 - $3 | 0;
|
|
$45 = Math_fround(downmix_and_resample($10, $2, $15, $65, ($3 | 0) > ($22 | 0) ? $22 : $3, $16, $5, $6, $7, $8) + HEAPF32[$0 + 7456 >> 2]);
|
|
HEAPF32[$0 + 7456 >> 2] = $45;
|
|
$8 = HEAP32[$0 + 5772 >> 2] + $22 | 0;
|
|
label$7 : {
|
|
if (($8 | 0) <= 719) {
|
|
HEAP32[$0 + 5772 >> 2] = $8;
|
|
break label$7;
|
|
}
|
|
$8 = $48 + 1 | 0;
|
|
$57 = Math_fround(Math_fround(1) / Math_fround((($48 | 0) < 100 ? $8 : 100) | 0));
|
|
$46 = Math_fround(Math_fround(1) / Math_fround((($48 | 0) < 25 ? $8 : 25) | 0));
|
|
$29 = Math_fround(Math_fround(1) / Math_fround((($48 | 0) < 10 ? $8 : 10) | 0));
|
|
$32 = HEAP32[$0 + 7444 >> 2];
|
|
HEAP32[$0 + 7444 >> 2] = $32 + (($32 | 0) > 98 ? -99 : 1);
|
|
$27 = is_digital_silence($53, 720, 1, $9);
|
|
$8 = 0;
|
|
while (1) {
|
|
$3 = ($14 + 5760 | 0) + ($8 << 3) | 0;
|
|
$15 = $8 << 2;
|
|
$12 = HEAPF32[$15 + 48944 >> 2];
|
|
$15 = $15 + $53 | 0;
|
|
HEAPF32[$3 >> 2] = $12 * HEAPF32[$15 >> 2];
|
|
HEAPF32[$3 + 4 >> 2] = $12 * HEAPF32[$15 + 960 >> 2];
|
|
$3 = 479 - $8 | 0;
|
|
$15 = ($14 + 5760 | 0) + ($3 << 3) | 0;
|
|
HEAPF32[$15 >> 2] = $12 * HEAPF32[($3 << 2) + $53 >> 2];
|
|
HEAPF32[$15 + 4 >> 2] = $12 * HEAPF32[(719 - $8 << 2) + $53 >> 2];
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != 240) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
memcpy($53, $72, 960);
|
|
$8 = HEAP32[$0 + 5772 >> 2];
|
|
$3 = $22 + $8 | 0;
|
|
$12 = downmix_and_resample($10, $2, $71, $65, $3 - 720 | 0, ($16 - $8 | 0) + 720 | 0, $5, $6, $7, HEAP32[$0 + 8 >> 2]);
|
|
HEAP32[$0 + 5772 >> 2] = $3 - 480;
|
|
HEAPF32[$0 + 7456 >> 2] = $12;
|
|
$36 = ($32 << 6) + $0 | 0;
|
|
$34 = $36 + 7604 | 0;
|
|
if ($27) {
|
|
$8 = HEAP32[$0 + 7444 >> 2];
|
|
$8 = ($8 + (($8 | 0) < 2 ? 98 : -2) << 6) + $0 | 0;
|
|
$16 = $8 + 7660 | 0;
|
|
$15 = HEAP32[$16 >> 2];
|
|
$3 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $15;
|
|
$15 = $34;
|
|
HEAP32[$15 + 56 >> 2] = $16;
|
|
HEAP32[$15 + 60 >> 2] = $3;
|
|
$16 = $8 + 7652 | 0;
|
|
$3 = HEAP32[$16 >> 2];
|
|
$15 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $3;
|
|
$3 = $34;
|
|
HEAP32[$3 + 48 >> 2] = $16;
|
|
HEAP32[$3 + 52 >> 2] = $15;
|
|
$16 = $8 + 7644 | 0;
|
|
$15 = HEAP32[$16 >> 2];
|
|
$3 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $15;
|
|
$15 = $34;
|
|
HEAP32[$15 + 40 >> 2] = $16;
|
|
HEAP32[$15 + 44 >> 2] = $3;
|
|
$16 = $8 + 7636 | 0;
|
|
$3 = HEAP32[$16 >> 2];
|
|
$15 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $3;
|
|
$3 = $34;
|
|
HEAP32[$3 + 32 >> 2] = $16;
|
|
HEAP32[$3 + 36 >> 2] = $15;
|
|
$16 = $8 + 7628 | 0;
|
|
$15 = HEAP32[$16 >> 2];
|
|
$3 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $15;
|
|
$15 = $34;
|
|
HEAP32[$15 + 24 >> 2] = $16;
|
|
HEAP32[$15 + 28 >> 2] = $3;
|
|
$16 = $8 + 7620 | 0;
|
|
$3 = HEAP32[$16 >> 2];
|
|
$15 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $3;
|
|
$3 = $34;
|
|
HEAP32[$3 + 16 >> 2] = $16;
|
|
HEAP32[$3 + 20 >> 2] = $15;
|
|
$16 = $8 + 7612 | 0;
|
|
$15 = HEAP32[$16 >> 2];
|
|
$3 = HEAP32[$16 + 4 >> 2];
|
|
$16 = $15;
|
|
$15 = $34;
|
|
HEAP32[$15 + 8 >> 2] = $16;
|
|
HEAP32[$15 + 12 >> 2] = $3;
|
|
$16 = $8 + 7604 | 0;
|
|
$3 = HEAP32[$16 >> 2];
|
|
$15 = HEAP32[$16 + 4 >> 2];
|
|
$8 = $3;
|
|
$3 = $34;
|
|
HEAP32[$3 >> 2] = $8;
|
|
HEAP32[$3 + 4 >> 2] = $15;
|
|
break label$7;
|
|
}
|
|
opus_fft_c($28, $14 + 5760 | 0, $14 + 1920 | 0);
|
|
$8 = 1;
|
|
$25 = HEAPF32[$14 + 1920 >> 2];
|
|
if ($25 != $25) {
|
|
HEAP32[$34 >> 2] = 0;
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$3 = ((0 - $8 << 3) + $14 | 0) + 5760 | 0;
|
|
$19 = HEAPF32[$3 >> 2];
|
|
$15 = ($14 + 1920 | 0) + ($8 << 3) | 0;
|
|
$18 = HEAPF32[$15 >> 2];
|
|
$12 = Math_fround($19 - $18);
|
|
$17 = HEAPF32[$15 + 4 >> 2];
|
|
$26 = HEAPF32[$3 + 4 >> 2];
|
|
$13 = Math_fround($17 + $26);
|
|
$20 = Math_fround(0);
|
|
$3 = $8 << 2;
|
|
$15 = $3 + $0 | 0;
|
|
$28 = $15;
|
|
$27 = $15;
|
|
$23 = Math_fround($18 + $19);
|
|
$19 = Math_fround($23 * $23);
|
|
$18 = Math_fround($17 - $26);
|
|
$17 = Math_fround($18 * $18);
|
|
$24 = Math_fround(0);
|
|
label$13 : {
|
|
if (Math_fround($19 + $17) < Math_fround(1.000000045813705e-18)) {
|
|
break label$13;
|
|
}
|
|
$24 = Math_fround(($18 < Math_fround(0) ? Math_fround(-1.5707963705062866) : Math_fround(1.5707963705062866)) - Math_fround(Math_fround(Math_fround($18 * $23) * Math_fround(Math_fround($19 * Math_fround(.43157973885536194)) + $17)) / Math_fround(Math_fround(Math_fround($19 * Math_fround(.6784840226173401)) + $17) * Math_fround(Math_fround($19 * Math_fround(.0859554186463356)) + $17))));
|
|
if (!($19 < $17 ^ 1)) {
|
|
break label$13;
|
|
}
|
|
$24 = $18 < Math_fround(0) ? Math_fround(-1.5707963705062866) : Math_fround(1.5707963705062866);
|
|
$18 = Math_fround($23 * $18);
|
|
$24 = Math_fround(Math_fround($24 + Math_fround(Math_fround($18 * Math_fround($19 + Math_fround($17 * Math_fround(.43157973885536194)))) / Math_fround(Math_fround($19 + Math_fround($17 * Math_fround(.6784840226173401))) * Math_fround($19 + Math_fround($17 * Math_fround(.0859554186463356)))))) - ($18 < Math_fround(0) ? Math_fround(-1.5707963705062866) : Math_fround(1.5707963705062866)));
|
|
}
|
|
$24 = Math_fround($24 * Math_fround(.15915493667125702));
|
|
$22 = $15 + 12 | 0;
|
|
$23 = Math_fround($24 - HEAPF32[$22 >> 2]);
|
|
$16 = $15 + 972 | 0;
|
|
$19 = Math_fround($23 - HEAPF32[$16 >> 2]);
|
|
$18 = Math_fround($12 * $12);
|
|
$17 = Math_fround($13 * $13);
|
|
label$14 : {
|
|
if (Math_fround($18 + $17) < Math_fround(1.000000045813705e-18)) {
|
|
break label$14;
|
|
}
|
|
if (!($18 > $17 ^ 1)) {
|
|
$20 = Math_fround(($12 < Math_fround(0) ? Math_fround(-1.5707963705062866) : Math_fround(1.5707963705062866)) - Math_fround(Math_fround(Math_fround($12 * $13) * Math_fround($18 + Math_fround($17 * Math_fround(.43157973885536194)))) / Math_fround(Math_fround($18 + Math_fround($17 * Math_fround(.6784840226173401))) * Math_fround($18 + Math_fround($17 * Math_fround(.0859554186463356))))));
|
|
break label$14;
|
|
}
|
|
$20 = $12 < Math_fround(0) ? Math_fround(-1.5707963705062866) : Math_fround(1.5707963705062866);
|
|
$12 = Math_fround($12 * $13);
|
|
$20 = Math_fround(Math_fround($20 + Math_fround(Math_fround($12 * Math_fround(Math_fround($18 * Math_fround(.43157973885536194)) + $17)) / Math_fround(Math_fround(Math_fround($18 * Math_fround(.6784840226173401)) + $17) * Math_fround(Math_fround($18 * Math_fround(.0859554186463356)) + $17)))) - ($12 < Math_fround(0) ? Math_fround(-1.5707963705062866) : Math_fround(1.5707963705062866)));
|
|
}
|
|
$18 = Math_fround($20 * Math_fround(.15915493667125702));
|
|
$17 = Math_fround($18 - $24);
|
|
$12 = Math_fround($17 - $23);
|
|
$32 = lrintf($12);
|
|
$16 = $3 + $14 | 0;
|
|
$13 = Math_fround($19 - Math_fround(lrintf($19) | 0));
|
|
$12 = Math_fround($12 - Math_fround($32 | 0));
|
|
HEAPF32[$16 >> 2] = Math_fround(Math_abs($13)) + Math_fround(Math_abs($12));
|
|
$15 = $15 + 1932 | 0;
|
|
$19 = HEAPF32[$15 >> 2];
|
|
$12 = Math_fround($12 * $12);
|
|
$12 = Math_fround($12 * $12);
|
|
HEAPF32[($14 + 1e4 | 0) + $3 >> 2] = Math_fround(Math_fround(1) / Math_fround(Math_fround($12 * Math_fround(62341.81640625)) + Math_fround(1))) + Math_fround(-.014999999664723873);
|
|
$13 = Math_fround($13 * $13);
|
|
HEAPF32[($14 + 960 | 0) + $3 >> 2] = Math_fround(Math_fround(1) / Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($19 + Math_fround($13 * $13)) + Math_fround($12 + $12)) * Math_fround(.25)) * Math_fround(62341.81640625)) + Math_fround(1))) + Math_fround(-.014999999664723873);
|
|
HEAPF32[$28 + 12 >> 2] = $18;
|
|
HEAPF32[$27 + 972 >> 2] = $17;
|
|
HEAPF32[$15 >> 2] = $12;
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != 240) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = 2;
|
|
$12 = HEAPF32[$14 + 10008 >> 2];
|
|
while (1) {
|
|
$3 = $8 << 2;
|
|
$15 = $3 + ($14 + 960 | 0) | 0;
|
|
$19 = HEAPF32[$15 >> 2];
|
|
$18 = HEAPF32[($3 + $14 | 0) + 9996 >> 2];
|
|
$3 = $8 + 1 | 0;
|
|
$13 = HEAPF32[($14 + 1e4 | 0) + ($3 << 2) >> 2];
|
|
$18 = $13 < $18 ? $18 : $13;
|
|
$12 = Math_fround(($12 < $18 ? $12 : $18) + Math_fround(-.10000000149011612));
|
|
HEAPF32[$15 >> 2] = ($12 < $19 ? $19 : $12) * Math_fround(.8999999761581421);
|
|
$12 = $13;
|
|
$8 = $3;
|
|
if (($8 | 0) != 239) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$58 = $36 + 7620 | 0;
|
|
HEAP32[$58 >> 2] = 0;
|
|
$27 = HEAP32[$0 + 7436 >> 2];
|
|
if (!$27) {
|
|
HEAP32[$0 + 7008 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7012 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7080 >> 2] = -803929351;
|
|
HEAP32[$0 + 7084 >> 2] = -803929351;
|
|
HEAP32[$0 + 7088 >> 2] = -803929351;
|
|
HEAP32[$0 + 7092 >> 2] = -803929351;
|
|
HEAP32[$0 + 7016 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7020 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7096 >> 2] = -803929351;
|
|
HEAP32[$0 + 7100 >> 2] = -803929351;
|
|
HEAP32[$0 + 7024 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7028 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7104 >> 2] = -803929351;
|
|
HEAP32[$0 + 7108 >> 2] = -803929351;
|
|
HEAP32[$0 + 7032 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7036 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7112 >> 2] = -803929351;
|
|
HEAP32[$0 + 7116 >> 2] = -803929351;
|
|
HEAP32[$0 + 7040 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7044 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7048 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7052 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7120 >> 2] = -803929351;
|
|
HEAP32[$0 + 7124 >> 2] = -803929351;
|
|
HEAP32[$0 + 7056 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7060 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7136 >> 2] = -803929351;
|
|
HEAP32[$0 + 7140 >> 2] = -803929351;
|
|
HEAP32[$0 + 7128 >> 2] = -803929351;
|
|
HEAP32[$0 + 7132 >> 2] = -803929351;
|
|
HEAP32[$0 + 7064 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7068 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7072 >> 2] = 1343554297;
|
|
HEAP32[$0 + 7144 >> 2] = -803929351;
|
|
HEAP32[$0 + 7148 >> 2] = -803929351;
|
|
HEAP32[$0 + 7076 >> 2] = 1343554297;
|
|
}
|
|
$12 = Math_fround($25 + $25);
|
|
$17 = Math_fround($12 * $12);
|
|
$12 = HEAPF32[$14 + 1924 >> 2];
|
|
$12 = Math_fround($12 + $12);
|
|
$17 = Math_fround($17 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 1928 >> 2];
|
|
$20 = Math_fround($12 * $12);
|
|
$12 = HEAPF32[$14 + 5752 >> 2];
|
|
$20 = Math_fround($20 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 1932 >> 2];
|
|
$20 = Math_fround($20 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 5756 >> 2];
|
|
$17 = Math_fround($17 + Math_fround($20 + Math_fround($12 * $12)));
|
|
$12 = HEAPF32[$14 + 1936 >> 2];
|
|
$20 = Math_fround($12 * $12);
|
|
$12 = HEAPF32[$14 + 5744 >> 2];
|
|
$20 = Math_fround($20 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 1940 >> 2];
|
|
$20 = Math_fround($20 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 5748 >> 2];
|
|
$17 = Math_fround($17 + Math_fround($20 + Math_fround($12 * $12)));
|
|
$12 = HEAPF32[$14 + 1944 >> 2];
|
|
$20 = Math_fround($12 * $12);
|
|
$12 = HEAPF32[$14 + 5736 >> 2];
|
|
$20 = Math_fround($20 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 1948 >> 2];
|
|
$20 = Math_fround($20 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$14 + 5740 >> 2];
|
|
$23 = Math_fround(Math_fround(log(+Math_fround(Math_fround($17 + Math_fround($20 + Math_fround($12 * $12))) + Math_fround(1.000000013351432e-10)))) * Math_fround(.7213475108146667));
|
|
HEAPF32[$14 + 9888 >> 2] = $23;
|
|
$24 = Math_fround(0);
|
|
$16 = 0;
|
|
$8 = 4;
|
|
$35 = Math_fround(0);
|
|
$30 = Math_fround(0);
|
|
$31 = Math_fround(0);
|
|
$49 = Math_fround(0);
|
|
$37 = Math_fround(0);
|
|
$38 = Math_fround(0);
|
|
while (1) {
|
|
$19 = Math_fround(0);
|
|
$18 = Math_fround(0);
|
|
$13 = Math_fround(0);
|
|
$32 = $16 + 1 | 0;
|
|
$28 = $32 << 2;
|
|
$22 = HEAP32[$28 + 49904 >> 2];
|
|
if (($22 | 0) > ($8 | 0)) {
|
|
while (1) {
|
|
$3 = ($14 + 1920 | 0) + ($8 << 3) | 0;
|
|
$12 = HEAPF32[$3 >> 2];
|
|
$17 = Math_fround($12 * $12);
|
|
$15 = ((0 - $8 << 3) + $14 | 0) + 5760 | 0;
|
|
$12 = HEAPF32[$15 >> 2];
|
|
$17 = Math_fround($17 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$3 + 4 >> 2];
|
|
$17 = Math_fround($17 + Math_fround($12 * $12));
|
|
$12 = HEAPF32[$15 + 4 >> 2];
|
|
$12 = Math_fround($17 + Math_fround($12 * $12));
|
|
$13 = Math_fround($13 + $12);
|
|
$3 = $8 << 2;
|
|
$18 = Math_fround($18 + Math_fround($12 * Math_fround(Math_max(HEAPF32[$3 + ($14 + 960 | 0) >> 2], Math_fround(0)))));
|
|
$19 = Math_fround($19 + Math_fround(Math_fround($12 + $12) * Math_fround(Math_fround(.5) - HEAPF32[$3 + $14 >> 2])));
|
|
$8 = $8 + 1 | 0;
|
|
if (($22 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!($13 == $13 ? !($13 < Math_fround(1e9) ^ 1) : 0)) {
|
|
HEAP32[$34 >> 2] = 0;
|
|
break label$7;
|
|
}
|
|
$3 = $16 << 2;
|
|
$8 = $3 + (Math_imul(HEAP32[$0 + 7432 >> 2], 72) + $0 | 0) | 0;
|
|
HEAPF32[$8 + 5856 >> 2] = $13;
|
|
$15 = ($14 + 9888 | 0) + $28 | 0;
|
|
$26 = Math_fround($13 + Math_fround(1.000000013351432e-10));
|
|
$12 = Math_fround(log(+$26));
|
|
HEAPF32[$15 >> 2] = $12 * Math_fround(.7213475108146667);
|
|
HEAPF32[($14 + 11200 | 0) + $3 >> 2] = $12;
|
|
HEAPF32[$8 + 6432 >> 2] = $12;
|
|
label$22 : {
|
|
if ($27) {
|
|
$8 = $0 + $3 | 0;
|
|
$17 = HEAPF32[$8 + 7008 >> 2];
|
|
$20 = HEAPF32[$8 + 7080 >> 2];
|
|
break label$22;
|
|
}
|
|
$8 = $0 + $3 | 0;
|
|
HEAPF32[$8 + 7080 >> 2] = $12;
|
|
HEAPF32[$8 + 7008 >> 2] = $12;
|
|
$17 = $12;
|
|
$20 = $12;
|
|
}
|
|
$8 = $0 + $3 | 0;
|
|
$15 = $8 + 7008 | 0;
|
|
$28 = $8 + 7080 | 0;
|
|
label$24 : {
|
|
if (+$20 > +$17 + 7.5 ^ 1) {
|
|
break label$24;
|
|
}
|
|
if (!(Math_fround($20 - $12) > Math_fround($12 - $17) ^ 1)) {
|
|
$20 = Math_fround($20 + Math_fround(-.009999999776482582));
|
|
HEAPF32[$28 >> 2] = $20;
|
|
break label$24;
|
|
}
|
|
$17 = Math_fround($17 + Math_fround(.009999999776482582));
|
|
HEAPF32[$15 >> 2] = $17;
|
|
}
|
|
$13 = Math_fround($13 + Math_fround(1.0000000036274937e-15));
|
|
label$26 : {
|
|
if (!($12 > $20 ^ 1)) {
|
|
HEAPF32[$28 >> 2] = $12;
|
|
$20 = Math_fround($12 + Math_fround(-15));
|
|
$17 = $17 < $20 ? $20 : $17;
|
|
HEAPF32[$15 >> 2] = $17;
|
|
$20 = $12;
|
|
break label$26;
|
|
}
|
|
if ($12 < $17 ^ 1) {
|
|
break label$26;
|
|
}
|
|
HEAPF32[$15 >> 2] = $12;
|
|
$17 = Math_fround($12 + Math_fround(15));
|
|
$20 = $17 < $20 ? $17 : $20;
|
|
HEAPF32[$28 >> 2] = $20;
|
|
$17 = $12;
|
|
}
|
|
$26 = Math_fround(Math_sqrt($26));
|
|
$19 = Math_fround($19 / $13);
|
|
$13 = Math_fround($18 / $13);
|
|
$15 = $8 + 5776 | 0;
|
|
$18 = HEAPF32[$8 + 5856 >> 2];
|
|
$25 = HEAPF32[$8 + 5928 >> 2];
|
|
$33 = HEAPF32[$8 + 6e3 >> 2];
|
|
$39 = HEAPF32[$8 + 6072 >> 2];
|
|
$40 = HEAPF32[$8 + 6144 >> 2];
|
|
$41 = HEAPF32[$8 + 6216 >> 2];
|
|
$42 = HEAPF32[$8 + 6288 >> 2];
|
|
$43 = HEAPF32[$8 + 6360 >> 2];
|
|
$18 = Math_fround(Math_min(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_sqrt($18)) + Math_fround(0)) + Math_fround(Math_sqrt($25))) + Math_fround(Math_sqrt($33))) + Math_fround(Math_sqrt($39))) + Math_fround(Math_sqrt($40))) + Math_fround(Math_sqrt($41))) + Math_fround(Math_sqrt($42))) + Math_fround(Math_sqrt($43))) / Math_fround(Math_sqrt(+Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($18 + Math_fround(0)) + $25) + $33) + $39) + $40) + $41) + $42) + $43) * Math_fround(8)) + 1e-15))), Math_fround(.9900000095367432)));
|
|
$18 = Math_fround($18 * $18);
|
|
$18 = Math_fround($18 * $18);
|
|
$25 = Math_fround(HEAPF32[$15 >> 2] * $18);
|
|
$13 = $13 > $25 ? $13 : $25;
|
|
HEAPF32[($14 + 11280 | 0) + $3 >> 2] = $13;
|
|
$24 = Math_fround($24 + $13);
|
|
$12 = Math_fround(Math_fround($12 - $17) / Math_fround(Math_fround($20 - $17) + Math_fround(9999999747378752e-21)));
|
|
$24 = $16 >>> 0 >= 9 ? Math_fround($24 - HEAPF32[($3 + $14 | 0) + 11244 >> 2]) : $24;
|
|
$38 = Math_fround($38 + $26);
|
|
$30 = Math_fround($30 + $19);
|
|
$49 = Math_fround($49 + $18);
|
|
$37 = Math_fround($37 + $12);
|
|
HEAPF32[$15 >> 2] = $13;
|
|
$12 = Math_fround(Math_fround(Math_fround(Math_fround($16 - 18 | 0) * Math_fround(.029999999329447746)) + Math_fround(1)) * $24);
|
|
$35 = $12 < $35 ? $35 : $12;
|
|
$31 = Math_fround($31 + Math_fround($13 * Math_fround($16 - 8 | 0)));
|
|
$8 = $22;
|
|
$16 = $32;
|
|
if (($16 | 0) != 18) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$14 + 9808 >> 2] = $23;
|
|
$13 = Math_fround($23 + Math_fround(-2.5));
|
|
HEAPF32[$14 + 9728 >> 2] = $13;
|
|
$3 = 1;
|
|
$15 = 4;
|
|
$19 = $23;
|
|
while (1) {
|
|
$8 = $3 << 2;
|
|
$22 = HEAP32[$8 + 49904 >> 2];
|
|
$12 = Math_fround($22 - $15 | 0);
|
|
$18 = Math_fround(Math_fround($12 + $12) * Math_fround(.25));
|
|
$19 = Math_fround($19 + $18);
|
|
$12 = HEAPF32[($14 + 9888 | 0) + $8 >> 2];
|
|
$19 = $12 > $19 ? $19 : $12;
|
|
HEAPF32[($14 + 9808 | 0) + $8 >> 2] = $19;
|
|
$13 = Math_fround($13 - $18);
|
|
$12 = Math_fround($12 + Math_fround(-2.5));
|
|
$13 = $12 < $13 ? $13 : $12;
|
|
HEAPF32[($14 + 9728 | 0) + $8 >> 2] = $13;
|
|
$15 = $22;
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != 19) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = 16;
|
|
$15 = 192;
|
|
$12 = HEAPF32[$14 + 9796 >> 2];
|
|
$13 = HEAPF32[$14 + 9876 >> 2];
|
|
while (1) {
|
|
$8 = $3;
|
|
$3 = $8 << 2;
|
|
$22 = $3 + ($14 + 9808 | 0) | 0;
|
|
$16 = HEAP32[$3 + 49904 >> 2];
|
|
$19 = Math_fround($15 - $16 | 0);
|
|
$19 = Math_fround(Math_fround($19 + $19) * Math_fround(.25));
|
|
$13 = Math_fround($13 + $19);
|
|
$18 = HEAPF32[$22 >> 2];
|
|
$13 = $13 < $18 ? $13 : $18;
|
|
HEAPF32[$22 >> 2] = $13;
|
|
$12 = Math_fround($12 - $19);
|
|
$3 = ($14 + 9728 | 0) + $3 | 0;
|
|
$19 = HEAPF32[$3 >> 2];
|
|
$12 = $12 > $19 ? $12 : $19;
|
|
HEAPF32[$3 >> 2] = $12;
|
|
$3 = $8 - 1 | 0;
|
|
$15 = $16;
|
|
if ($8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = 0;
|
|
while (1) {
|
|
$44 = Math_fround(0);
|
|
$15 = ($8 + $36 | 0) + 7648 | 0;
|
|
$3 = $8 << 2;
|
|
$66 = Math_floor(+Math_fround(Math_fround(Math_fround(Math_max(Math_fround(HEAPF32[$3 + ($14 + 9728 | 0) >> 2] - $23), Math_fround(0))) + Math_fround(Math_max(Math_fround($23 - Math_fround(HEAPF32[($14 + 9808 | 0) + $3 >> 2] + Math_fround(2.5))), Math_fround(0)))) * Math_fround(64)) + .5);
|
|
label$32 : {
|
|
if (Math_abs($66) < 2147483648) {
|
|
$3 = ~~$66;
|
|
break label$32;
|
|
}
|
|
$3 = -2147483648;
|
|
}
|
|
HEAP8[$15 | 0] = ($3 | 0) < 255 ? $3 : 255;
|
|
$15 = 0;
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != 19) {
|
|
$23 = HEAPF32[($14 + 9888 | 0) + ($8 << 2) >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
while (1) {
|
|
$8 = Math_imul($15, 72) + $0 | 0;
|
|
$19 = HEAPF32[$8 + 6500 >> 2];
|
|
$18 = HEAPF32[$8 + 6496 >> 2];
|
|
$17 = HEAPF32[$8 + 6448 >> 2];
|
|
$20 = HEAPF32[$8 + 6444 >> 2];
|
|
$24 = HEAPF32[$8 + 6440 >> 2];
|
|
$23 = HEAPF32[$8 + 6436 >> 2];
|
|
$26 = HEAPF32[$8 + 6432 >> 2];
|
|
$25 = HEAPF32[$8 + 6492 >> 2];
|
|
$33 = HEAPF32[$8 + 6488 >> 2];
|
|
$39 = HEAPF32[$8 + 6484 >> 2];
|
|
$40 = HEAPF32[$8 + 6480 >> 2];
|
|
$41 = HEAPF32[$8 + 6476 >> 2];
|
|
$42 = HEAPF32[$8 + 6472 >> 2];
|
|
$43 = HEAPF32[$8 + 6468 >> 2];
|
|
$54 = HEAPF32[$8 + 6464 >> 2];
|
|
$47 = HEAPF32[$8 + 6460 >> 2];
|
|
$59 = HEAPF32[$8 + 6456 >> 2];
|
|
$52 = HEAPF32[$8 + 6452 >> 2];
|
|
$12 = Math_fround(999999986991104);
|
|
$3 = 0;
|
|
while (1) {
|
|
$8 = Math_imul($3, 72) + $0 | 0;
|
|
$13 = Math_fround($26 - HEAPF32[$8 + 6432 >> 2]);
|
|
$21 = Math_fround(Math_fround($13 * $13) + Math_fround(0));
|
|
$13 = Math_fround($23 - HEAPF32[$8 + 6436 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($24 - HEAPF32[$8 + 6440 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($20 - HEAPF32[$8 + 6444 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($17 - HEAPF32[$8 + 6448 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($52 - HEAPF32[$8 + 6452 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($59 - HEAPF32[$8 + 6456 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($47 - HEAPF32[$8 + 6460 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($54 - HEAPF32[$8 + 6464 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($43 - HEAPF32[$8 + 6468 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($42 - HEAPF32[$8 + 6472 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($41 - HEAPF32[$8 + 6476 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($40 - HEAPF32[$8 + 6480 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($39 - HEAPF32[$8 + 6484 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($33 - HEAPF32[$8 + 6488 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($25 - HEAPF32[$8 + 6492 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($18 - HEAPF32[$8 + 6496 >> 2]);
|
|
$21 = Math_fround($21 + Math_fround($13 * $13));
|
|
$13 = Math_fround($19 - HEAPF32[$8 + 6500 >> 2]);
|
|
$13 = Math_fround($21 + Math_fround($13 * $13));
|
|
$12 = ($3 | 0) == ($15 | 0) ? $12 : $12 < $13 ? $12 : $13;
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != 8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$44 = Math_fround($44 + $12);
|
|
$15 = $15 + 1 | 0;
|
|
if (($15 | 0) != 8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$17 = Math_fround(0);
|
|
$26 = ($48 | 0) < 2 ? Math_fround(0) : Math_fround(Math_fround(1) - $57);
|
|
$25 = Math_fround($44 * Math_fround(.125));
|
|
$48 = HEAP32[$0 + 5852 >> 2];
|
|
$16 = 0;
|
|
$28 = 4;
|
|
$27 = 0;
|
|
$20 = Math_fround(0);
|
|
$18 = Math_fround(0);
|
|
$19 = Math_fround(0);
|
|
while (1) {
|
|
$12 = Math_fround(0);
|
|
$8 = $28;
|
|
$32 = $16 + 1 | 0;
|
|
$22 = HEAP32[($32 << 2) + 49904 >> 2];
|
|
if (($8 | 0) < ($22 | 0)) {
|
|
while (1) {
|
|
$3 = ($14 + 1920 | 0) + ($8 << 3) | 0;
|
|
$13 = HEAPF32[$3 >> 2];
|
|
$23 = Math_fround($13 * $13);
|
|
$15 = ((0 - $8 << 3) + $14 | 0) + 5760 | 0;
|
|
$13 = HEAPF32[$15 >> 2];
|
|
$23 = Math_fround($23 + Math_fround($13 * $13));
|
|
$13 = HEAPF32[$3 + 4 >> 2];
|
|
$23 = Math_fround($23 + Math_fround($13 * $13));
|
|
$13 = HEAPF32[$15 + 4 >> 2];
|
|
$12 = Math_fround($12 + Math_fround($23 + Math_fround($13 * $13)));
|
|
$8 = $8 + 1 | 0;
|
|
if (($22 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $16 << 2;
|
|
$8 = ($3 + $0 | 0) + 7152 | 0;
|
|
$13 = Math_fround($26 * HEAPF32[$8 >> 2]);
|
|
$13 = $12 < $13 ? $13 : $12;
|
|
HEAPF32[$8 >> 2] = $13;
|
|
$8 = $16 >>> 0 < 11;
|
|
$24 = Math_fround($18 + $12);
|
|
$23 = Math_fround($19 + $12);
|
|
$20 = $12 < $20 ? $20 : $12;
|
|
if (!($20 < Math_fround($12 * Math_fround(1e9)) ^ 1)) {
|
|
$33 = $12 > $13 ? $12 : $13;
|
|
$13 = Math_fround($22 - $28 | 0);
|
|
$27 = Math_fround($56 * $13) < $12 ? $32 : $33 > Math_fround($73 * $13) ? $32 : $27;
|
|
}
|
|
$18 = $8 ? $24 : $18;
|
|
$19 = $8 ? $19 : $23;
|
|
HEAP32[($14 + 10960 | 0) + $3 >> 2] = Math_fround($17 * (($16 | 0) < ($48 | 0) ? Math_fround(.009999999776482582) : Math_fround(.05000000074505806))) > $12;
|
|
$13 = Math_fround($17 * Math_fround(.05000000074505806));
|
|
$17 = $12 < $13 ? $13 : $12;
|
|
$28 = $22;
|
|
$16 = $32;
|
|
if (($16 | 0) != 18) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (HEAP32[$0 + 8 >> 2] == 48e3) {
|
|
$13 = Math_fround($26 * HEAPF32[$0 + 7224 >> 2]);
|
|
$12 = Math_fround($45 * Math_fround(.00027777778450399637));
|
|
$13 = $12 < $13 ? $13 : $12;
|
|
HEAPF32[$0 + 7224 >> 2] = $13;
|
|
$20 = $12 > $13 ? $12 : $13;
|
|
$8 = ($48 | 0) == 20;
|
|
$13 = $8 ? Math_fround(10) : Math_fround(30);
|
|
$27 = (Math_fround(Math_fround($56 * $13) * Math_fround(160)) < $12 ^ 1 ? !($20 > Math_fround(Math_fround($56 * Math_fround($13 * Math_fround(3))) * Math_fround(160))) : 0) ? $27 : 20;
|
|
HEAP32[$14 + 11032 >> 2] = Math_fround(($8 ? Math_fround(.009999999776482582) : Math_fround(.05000000074505806)) * $17) > $12;
|
|
$19 = Math_fround($12 + $19);
|
|
}
|
|
$12 = Math_fround($25 / Math_fround(18));
|
|
HEAPF32[$36 + 7644 >> 2] = $19 > $18 ? Math_fround($18 / $19) : Math_fround(1);
|
|
label$44 : {
|
|
if (($27 | 0) == 20) {
|
|
$27 = HEAP32[$14 + 11032 >> 2] ? 18 : 20;
|
|
break label$44;
|
|
}
|
|
$8 = $27 - 1 | 0;
|
|
if ($8 >>> 0 > 17) {
|
|
break label$44;
|
|
}
|
|
$27 = HEAP32[($14 + 10960 | 0) + ($8 << 2) >> 2] ? $8 : $27;
|
|
}
|
|
$59 = Math_fround(Math_sqrt($12));
|
|
$13 = Math_fround(HEAPF32[$0 + 7424 >> 2] + Math_fround(-.003000000026077032));
|
|
$12 = Math_fround(Math_fround(log10(+$38)) * Math_fround(20));
|
|
$13 = $12 < $13 ? $13 : $12;
|
|
HEAPF32[$0 + 7424 >> 2] = $13;
|
|
$19 = Math_fround(Math_fround(Math_fround(1) - $46) * HEAPF32[$0 + 7428 >> 2]);
|
|
HEAPF32[$0 + 7428 >> 2] = Math_fround($13 + Math_fround(-30)) > $12 ? Math_fround($46 + $19) : $19;
|
|
$16 = HEAP32[$0 + 7436 >> 2];
|
|
$3 = 0;
|
|
$12 = HEAPF32[$14 + 11204 >> 2];
|
|
$13 = HEAPF32[$14 + 11200 >> 2];
|
|
$19 = HEAPF32[$14 + 11260 >> 2];
|
|
$18 = HEAPF32[$14 + 11256 >> 2];
|
|
$17 = HEAPF32[$14 + 11252 >> 2];
|
|
$20 = HEAPF32[$14 + 11248 >> 2];
|
|
$24 = HEAPF32[$14 + 11244 >> 2];
|
|
$23 = HEAPF32[$14 + 11240 >> 2];
|
|
$26 = HEAPF32[$14 + 11236 >> 2];
|
|
$25 = HEAPF32[$14 + 11232 >> 2];
|
|
$33 = HEAPF32[$14 + 11228 >> 2];
|
|
$39 = HEAPF32[$14 + 11224 >> 2];
|
|
$40 = HEAPF32[$14 + 11220 >> 2];
|
|
$41 = HEAPF32[$14 + 11216 >> 2];
|
|
$42 = HEAPF32[$14 + 11212 >> 2];
|
|
$43 = HEAPF32[$14 + 11208 >> 2];
|
|
while (1) {
|
|
$8 = $3 << 6;
|
|
HEAPF32[($14 + 11168 | 0) + ($3 << 2) >> 2] = Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($13 * HEAPF32[$8 + 49984 >> 2]) + Math_fround(0)) + Math_fround($12 * HEAPF32[($8 | 4) + 49984 >> 2])) + Math_fround($43 * HEAPF32[($8 | 8) + 49984 >> 2])) + Math_fround($42 * HEAPF32[($8 | 12) + 49984 >> 2])) + Math_fround($41 * HEAPF32[($8 | 16) + 49984 >> 2])) + Math_fround($40 * HEAPF32[($8 | 20) + 49984 >> 2])) + Math_fround($39 * HEAPF32[($8 | 24) + 49984 >> 2])) + Math_fround($33 * HEAPF32[($8 | 28) + 49984 >> 2])) + Math_fround($25 * HEAPF32[($8 | 32) + 49984 >> 2])) + Math_fround($26 * HEAPF32[($8 | 36) + 49984 >> 2])) + Math_fround($23 * HEAPF32[($8 | 40) + 49984 >> 2])) + Math_fround($24 * HEAPF32[($8 | 44) + 49984 >> 2])) + Math_fround($20 * HEAPF32[($8 | 48) + 49984 >> 2])) + Math_fround($17 * HEAPF32[($8 | 52) + 49984 >> 2])) + Math_fround($18 * HEAPF32[($8 | 56) + 49984 >> 2])) + Math_fround($19 * HEAPF32[($8 | 60) + 49984 >> 2]);
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != 8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$22 = 0;
|
|
while (1) {
|
|
$15 = $22 << 4;
|
|
$12 = Math_fround(0);
|
|
$8 = 0;
|
|
while (1) {
|
|
$3 = ($8 << 2) + $0 | 0;
|
|
$12 = Math_fround($12 + Math_fround(Math_fround(HEAPF32[($8 + $15 << 2) + 49984 >> 2] * Math_fround(.5)) * Math_fround(HEAPF32[$3 + 7080 >> 2] + HEAPF32[$3 + 7008 >> 2])));
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != 16) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[($14 + 9968 | 0) + ($22 << 2) >> 2] = $12;
|
|
$22 = $22 + 1 | 0;
|
|
if (($22 | 0) != 8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$20 = Math_fround($30 / Math_fround(18));
|
|
HEAPF32[$58 >> 2] = $20 + Math_fround(Math_fround(Math_fround(1) - $20) * (($16 | 0) < 10 ? Math_fround(.5) : Math_fround($37 / Math_fround(18))));
|
|
$12 = Math_fround($35 / Math_fround(9));
|
|
$13 = Math_fround(HEAPF32[$0 + 5848 >> 2] * Math_fround(.800000011920929));
|
|
$12 = $12 > $13 ? $12 : $13;
|
|
HEAPF32[$0 + 5848 >> 2] = $12;
|
|
$3 = $36 + 7612 | 0;
|
|
HEAPF32[$3 >> 2] = $31 * Math_fround(.015625);
|
|
$15 = ($16 | 0) < 9999 ? $16 + 1 | 0 : 1e4;
|
|
HEAP32[$0 + 7436 >> 2] = $15;
|
|
HEAP32[$0 + 7432 >> 2] = (HEAP32[$0 + 7432 >> 2] + 1 | 0) % 8;
|
|
$22 = $36 + 7608 | 0;
|
|
HEAPF32[$22 >> 2] = $12;
|
|
$24 = HEAPF32[$0 + 7260 >> 2];
|
|
$23 = HEAPF32[$0 + 7228 >> 2];
|
|
$26 = HEAPF32[$0 + 7292 >> 2];
|
|
$47 = Math_fround($23 + $26);
|
|
$13 = HEAPF32[$14 + 11168 >> 2];
|
|
$52 = HEAPF32[$0 + 7324 >> 2];
|
|
$35 = Math_fround($13 + $52);
|
|
$44 = HEAPF32[$0 + 7356 >> 2];
|
|
$21 = Math_fround(Math_fround(Math_fround($24 * Math_fround(.6969299912452698)) + Math_fround(Math_fround($47 * Math_fround(.49195000529289246)) - Math_fround($35 * Math_fround(.12298999726772308)))) - Math_fround($44 * Math_fround(1.4349000453948975)));
|
|
HEAPF32[$14 + 11056 >> 2] = $21;
|
|
$25 = HEAPF32[$0 + 7264 >> 2];
|
|
$33 = HEAPF32[$0 + 7232 >> 2];
|
|
$39 = HEAPF32[$0 + 7296 >> 2];
|
|
$30 = Math_fround($33 + $39);
|
|
$19 = HEAPF32[$14 + 11172 >> 2];
|
|
$31 = HEAPF32[$0 + 7328 >> 2];
|
|
$37 = Math_fround($19 + $31);
|
|
$38 = HEAPF32[$0 + 7360 >> 2];
|
|
$60 = Math_fround(Math_fround(Math_fround($25 * Math_fround(.6969299912452698)) + Math_fround(Math_fround($30 * Math_fround(.49195000529289246)) - Math_fround($37 * Math_fround(.12298999726772308)))) - Math_fround($38 * Math_fround(1.4349000453948975)));
|
|
HEAPF32[$14 + 11060 >> 2] = $60;
|
|
$40 = HEAPF32[$0 + 7268 >> 2];
|
|
$41 = HEAPF32[$0 + 7236 >> 2];
|
|
$42 = HEAPF32[$0 + 7300 >> 2];
|
|
$45 = Math_fround($41 + $42);
|
|
$18 = HEAPF32[$14 + 11176 >> 2];
|
|
$46 = HEAPF32[$0 + 7332 >> 2];
|
|
$57 = Math_fround($18 + $46);
|
|
$67 = HEAPF32[$0 + 7364 >> 2];
|
|
$61 = Math_fround(Math_fround(Math_fround($40 * Math_fround(.6969299912452698)) + Math_fround(Math_fround($45 * Math_fround(.49195000529289246)) - Math_fround($57 * Math_fround(.12298999726772308)))) - Math_fround($67 * Math_fround(1.4349000453948975)));
|
|
HEAPF32[$14 + 11064 >> 2] = $61;
|
|
$68 = HEAPF32[$0 + 7272 >> 2];
|
|
$43 = HEAPF32[$0 + 7240 >> 2];
|
|
$54 = HEAPF32[$0 + 7304 >> 2];
|
|
$17 = HEAPF32[$14 + 11180 >> 2];
|
|
$69 = HEAPF32[$0 + 7336 >> 2];
|
|
$70 = HEAPF32[$0 + 7368 >> 2];
|
|
$62 = Math_fround(Math_fround(Math_fround($68 * Math_fround(.6969299912452698)) + Math_fround(Math_fround(Math_fround($43 + $54) * Math_fround(.49195000529289246)) - Math_fround(Math_fround($17 + $69) * Math_fround(.12298999726772308)))) - Math_fround($70 * Math_fround(1.4349000453948975)));
|
|
HEAPF32[$14 + 11068 >> 2] = $62;
|
|
$12 = Math_fround(Math_fround(1) - $29);
|
|
HEAPF32[$0 + 7368 >> 2] = Math_fround($29 * $17) + Math_fround($70 * $12);
|
|
HEAPF32[$0 + 7364 >> 2] = Math_fround($29 * $18) + Math_fround($12 * $67);
|
|
HEAPF32[$0 + 7360 >> 2] = Math_fround($29 * $19) + Math_fround($12 * $38);
|
|
HEAPF32[$0 + 7356 >> 2] = Math_fround($29 * $13) + Math_fround($12 * $44);
|
|
HEAPF32[$14 + 11096 >> 2] = Math_fround(Math_fround($57 * Math_fround(.5345199704170227)) - Math_fround($45 * Math_fround(.26725998520851135))) - Math_fround($40 * Math_fround(.5345199704170227));
|
|
HEAPF32[$14 + 11092 >> 2] = Math_fround(Math_fround($37 * Math_fround(.5345199704170227)) - Math_fround($30 * Math_fround(.26725998520851135))) - Math_fround($25 * Math_fround(.5345199704170227));
|
|
$35 = Math_fround(Math_fround(Math_fround($35 * Math_fround(.5345199704170227)) - Math_fround($47 * Math_fround(.26725998520851135))) - Math_fround($24 * Math_fround(.5345199704170227)));
|
|
HEAPF32[$14 + 11088 >> 2] = $35;
|
|
$44 = Math_fround(Math_fround(Math_fround($17 - $69) * Math_fround(.6324599981307983)) + Math_fround(Math_fround($43 - $54) * Math_fround(.31622999906539917)));
|
|
HEAPF32[$14 + 11084 >> 2] = $44;
|
|
$30 = Math_fround(Math_fround(Math_fround($18 - $46) * Math_fround(.6324599981307983)) + Math_fround(Math_fround($41 - $42) * Math_fround(.31622999906539917)));
|
|
HEAPF32[$14 + 11080 >> 2] = $30;
|
|
$31 = Math_fround(Math_fround(Math_fround($19 - $31) * Math_fround(.6324599981307983)) + Math_fround(Math_fround($33 - $39) * Math_fround(.31622999906539917)));
|
|
HEAPF32[$14 + 11076 >> 2] = $31;
|
|
$37 = Math_fround(Math_fround(Math_fround($13 - $52) * Math_fround(.6324599981307983)) + Math_fround(Math_fround($23 - $26) * Math_fround(.31622999906539917)));
|
|
HEAPF32[$14 + 11072 >> 2] = $37;
|
|
$8 = ($16 | 0) < 3 ? 20 : $27;
|
|
$52 = Math_fround($49 / Math_fround(18));
|
|
$47 = HEAPF32[$0 + 7388 >> 2];
|
|
label$49 : {
|
|
if (($15 | 0) <= 5) {
|
|
$12 = HEAPF32[$0 + 7420 >> 2];
|
|
$30 = HEAPF32[$0 + 7412 >> 2];
|
|
$31 = HEAPF32[$0 + 7408 >> 2];
|
|
$49 = HEAPF32[$0 + 7404 >> 2];
|
|
$38 = HEAPF32[$0 + 7400 >> 2];
|
|
$45 = HEAPF32[$0 + 7396 >> 2];
|
|
$46 = HEAPF32[$0 + 7392 >> 2];
|
|
break label$49;
|
|
}
|
|
$47 = Math_fround(Math_fround($21 * Math_fround($29 * $21)) + Math_fround($12 * $47));
|
|
HEAPF32[$0 + 7388 >> 2] = $47;
|
|
$46 = Math_fround(Math_fround($60 * Math_fround($29 * $60)) + Math_fround($12 * HEAPF32[$0 + 7392 >> 2]));
|
|
HEAPF32[$0 + 7392 >> 2] = $46;
|
|
$45 = Math_fround(Math_fround($61 * Math_fround($29 * $61)) + Math_fround($12 * HEAPF32[$0 + 7396 >> 2]));
|
|
HEAPF32[$0 + 7396 >> 2] = $45;
|
|
$38 = Math_fround(Math_fround($62 * Math_fround($29 * $62)) + Math_fround($12 * HEAPF32[$0 + 7400 >> 2]));
|
|
HEAPF32[$0 + 7400 >> 2] = $38;
|
|
$49 = Math_fround(Math_fround($37 * Math_fround($29 * $37)) + Math_fround($12 * HEAPF32[$0 + 7404 >> 2]));
|
|
HEAPF32[$0 + 7404 >> 2] = $49;
|
|
$31 = Math_fround(Math_fround($31 * Math_fround($29 * $31)) + Math_fround($12 * HEAPF32[$0 + 7408 >> 2]));
|
|
HEAPF32[$0 + 7408 >> 2] = $31;
|
|
$30 = Math_fround(Math_fround($30 * Math_fround($29 * $30)) + Math_fround($12 * HEAPF32[$0 + 7412 >> 2]));
|
|
HEAPF32[$0 + 7412 >> 2] = $30;
|
|
HEAPF32[$0 + 7416 >> 2] = Math_fround($44 * Math_fround($29 * $44)) + Math_fround($12 * HEAPF32[$0 + 7416 >> 2]);
|
|
$12 = Math_fround(Math_fround($35 * Math_fround($29 * $35)) + Math_fround($12 * HEAPF32[$0 + 7420 >> 2]));
|
|
HEAPF32[$0 + 7420 >> 2] = $12;
|
|
}
|
|
HEAPF32[$14 + 11056 >> 2] = $13 - HEAPF32[$14 + 9968 >> 2];
|
|
HEAPF32[$14 + 11060 >> 2] = $19 - HEAPF32[$14 + 9972 >> 2];
|
|
HEAPF32[$14 + 11064 >> 2] = $18 - HEAPF32[$14 + 9976 >> 2];
|
|
HEAPF32[$14 + 11068 >> 2] = $17 - HEAPF32[$14 + 9980 >> 2];
|
|
HEAPF32[$0 + 7260 >> 2] = $23;
|
|
HEAPF32[$0 + 7328 >> 2] = $39;
|
|
HEAPF32[$0 + 7228 >> 2] = $13;
|
|
HEAPF32[$0 + 7296 >> 2] = $25;
|
|
HEAPF32[$0 + 7264 >> 2] = $33;
|
|
HEAPF32[$0 + 7332 >> 2] = $42;
|
|
HEAPF32[$0 + 7232 >> 2] = $19;
|
|
HEAPF32[$0 + 7300 >> 2] = $40;
|
|
HEAPF32[$0 + 7268 >> 2] = $41;
|
|
HEAPF32[$0 + 7336 >> 2] = $54;
|
|
HEAPF32[$0 + 7236 >> 2] = $18;
|
|
HEAPF32[$0 + 7304 >> 2] = $68;
|
|
HEAPF32[$0 + 7272 >> 2] = $43;
|
|
HEAPF32[$0 + 7240 >> 2] = $17;
|
|
HEAPF32[$0 + 7324 >> 2] = $26;
|
|
HEAPF32[$0 + 7292 >> 2] = $24;
|
|
$15 = HEAP32[$0 + 7308 >> 2];
|
|
HEAP32[$0 + 7308 >> 2] = HEAP32[$0 + 7276 >> 2];
|
|
HEAP32[$0 + 7340 >> 2] = $15;
|
|
HEAP32[$0 + 7276 >> 2] = HEAP32[$0 + 7244 >> 2];
|
|
HEAP32[$0 + 7244 >> 2] = HEAP32[$14 + 11184 >> 2];
|
|
HEAP32[$0 + 7344 >> 2] = HEAP32[$0 + 7312 >> 2];
|
|
HEAP32[$0 + 7312 >> 2] = HEAP32[$0 + 7280 >> 2];
|
|
HEAP32[$0 + 7280 >> 2] = HEAP32[$0 + 7248 >> 2];
|
|
HEAP32[$0 + 7248 >> 2] = HEAP32[$14 + 11188 >> 2];
|
|
HEAP32[$0 + 7348 >> 2] = HEAP32[$0 + 7316 >> 2];
|
|
HEAP32[$0 + 7316 >> 2] = HEAP32[$0 + 7284 >> 2];
|
|
HEAP32[$0 + 7284 >> 2] = HEAP32[$0 + 7252 >> 2];
|
|
HEAP32[$0 + 7252 >> 2] = HEAP32[$14 + 11192 >> 2];
|
|
HEAP32[$0 + 7352 >> 2] = HEAP32[$0 + 7320 >> 2];
|
|
HEAP32[$0 + 7320 >> 2] = HEAP32[$0 + 7288 >> 2];
|
|
HEAP32[$0 + 7288 >> 2] = HEAP32[$0 + 7256 >> 2];
|
|
HEAP32[$0 + 7256 >> 2] = HEAP32[$14 + 11196 >> 2];
|
|
HEAPF32[$14 + 11132 >> 2] = Math_fround(Math_sqrt($12)) + Math_fround(-1.9187949895858765);
|
|
HEAPF32[$14 + 11124 >> 2] = Math_fround(Math_sqrt($30)) + Math_fround(-1.260756015777588);
|
|
HEAPF32[$14 + 11120 >> 2] = Math_fround(Math_sqrt($31)) + Math_fround(-2.1633129119873047);
|
|
HEAPF32[$14 + 11116 >> 2] = Math_fround(Math_sqrt($49)) + Math_fround(-3.7732150554656982);
|
|
HEAPF32[$14 + 11112 >> 2] = Math_fround(Math_sqrt($38)) + Math_fround(-1.599784016609192);
|
|
HEAPF32[$14 + 11108 >> 2] = Math_fround(Math_sqrt($45)) + Math_fround(-1.7706340551376343);
|
|
HEAPF32[$14 + 11104 >> 2] = Math_fround(Math_sqrt($46)) + Math_fround(-3.475287914276123);
|
|
HEAPF32[$14 + 11100 >> 2] = Math_fround(Math_sqrt($47)) + Math_fround(-5.6849470138549805);
|
|
HEAPF32[$14 + 11128 >> 2] = $59 + Math_fround(-.7799999713897705);
|
|
HEAPF32[$14 + 11136 >> 2] = HEAPF32[$22 >> 2] + Math_fround(-.15472300350666046);
|
|
$12 = HEAPF32[$58 >> 2];
|
|
HEAPF32[$14 + 11144 >> 2] = $52 + Math_fround(-.7437170147895813);
|
|
HEAPF32[$14 + 11140 >> 2] = $12 + Math_fround(-.7246429920196533);
|
|
HEAPF32[$14 + 11148 >> 2] = HEAPF32[$3 >> 2] + Math_fround(.06921599805355072);
|
|
HEAPF32[$14 + 11152 >> 2] = HEAPF32[$0 + 7428 >> 2] + Math_fround(-.06792999804019928);
|
|
compute_dense(43872, $14 + 9600 | 0, $14 + 11056 | 0);
|
|
compute_gru(48016, $64, $14 + 9600 | 0);
|
|
compute_dense(48096, $14 + 11048 | 0, $64);
|
|
HEAP32[$36 + 7640 >> 2] = HEAP32[$14 + 11052 >> 2];
|
|
$3 = HEAP32[$14 + 11048 >> 2];
|
|
HEAP32[$36 + 7636 >> 2] = $8;
|
|
HEAP32[$36 + 7624 >> 2] = $3;
|
|
HEAP32[$0 + 5852 >> 2] = $8;
|
|
HEAPF32[$36 + 7616 >> 2] = $20;
|
|
HEAP32[$34 >> 2] = 1;
|
|
}
|
|
$50 = $50 + $55 | 0;
|
|
$51 = $51 - $55 | 0;
|
|
if (($51 | 0) > 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 7440 >> 2] = $63 - $4;
|
|
}
|
|
tonality_get_info($0, $11, $4);
|
|
__stack_pointer = $14 + 11360 | 0;
|
|
}
|
|
function dlmalloc($0) {
|
|
$0 = $0 | 0;
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
$12 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $12;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
label$10 : {
|
|
label$11 : {
|
|
label$12 : {
|
|
if ($0 >>> 0 <= 244) {
|
|
$6 = HEAP32[13232];
|
|
$4 = $0 >>> 0 < 11 ? 16 : $0 + 11 & -8;
|
|
$2 = $4 >>> 3 | 0;
|
|
$0 = $6 >>> $2 | 0;
|
|
if ($0 & 3) {
|
|
$4 = (($0 ^ -1) & 1) + $2 | 0;
|
|
$3 = $4 << 3;
|
|
$2 = HEAP32[$3 + 52976 >> 2];
|
|
$0 = $2 + 8 | 0;
|
|
$1 = HEAP32[$2 + 8 >> 2];
|
|
$3 = $3 + 52968 | 0;
|
|
label$15 : {
|
|
if (($1 | 0) == ($3 | 0)) {
|
|
HEAP32[13232] = __wasm_rotl_i32(-2, $4) & $6;
|
|
break label$15;
|
|
}
|
|
HEAP32[$1 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $1;
|
|
}
|
|
$1 = $4 << 3;
|
|
HEAP32[$2 + 4 >> 2] = $1 | 3;
|
|
$2 = $2 + $1 | 0;
|
|
HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] | 1;
|
|
break label$1;
|
|
}
|
|
$9 = HEAP32[13234];
|
|
if ($9 >>> 0 >= $4 >>> 0) {
|
|
break label$12;
|
|
}
|
|
if ($0) {
|
|
$1 = $0 << $2;
|
|
$0 = 2 << $2;
|
|
$0 = $1 & ($0 | 0 - $0);
|
|
$0 = ($0 & 0 - $0) - 1 | 0;
|
|
$1 = $0;
|
|
$0 = $0 >>> 12 & 16;
|
|
$2 = $1 >>> $0 | 0;
|
|
$1 = $2 >>> 5 & 8;
|
|
$3 = $0 | $1;
|
|
$0 = $2 >>> $1 | 0;
|
|
$2 = $0 >>> 2 & 4;
|
|
$1 = $3 | $2;
|
|
$0 = $0 >>> $2 | 0;
|
|
$2 = $0 >>> 1 & 2;
|
|
$1 = $1 | $2;
|
|
$0 = $0 >>> $2 | 0;
|
|
$2 = $0 >>> 1 & 1;
|
|
$1 = ($1 | $2) + ($0 >>> $2 | 0) | 0;
|
|
$3 = $1 << 3;
|
|
$2 = HEAP32[$3 + 52976 >> 2];
|
|
$0 = HEAP32[$2 + 8 >> 2];
|
|
$3 = $3 + 52968 | 0;
|
|
label$18 : {
|
|
if (($0 | 0) == ($3 | 0)) {
|
|
$6 = __wasm_rotl_i32(-2, $1) & $6;
|
|
HEAP32[13232] = $6;
|
|
break label$18;
|
|
}
|
|
HEAP32[$0 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $0;
|
|
}
|
|
$0 = $2 + 8 | 0;
|
|
HEAP32[$2 + 4 >> 2] = $4 | 3;
|
|
$3 = $2 + $4 | 0;
|
|
$5 = $1 << 3;
|
|
$1 = $5 - $4 | 0;
|
|
HEAP32[$3 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$2 + $5 >> 2] = $1;
|
|
if ($9) {
|
|
$5 = $9 >>> 3 | 0;
|
|
$4 = ($5 << 3) + 52968 | 0;
|
|
$2 = HEAP32[13237];
|
|
$5 = 1 << $5;
|
|
label$21 : {
|
|
if (!($6 & $5)) {
|
|
HEAP32[13232] = $5 | $6;
|
|
$5 = $4;
|
|
break label$21;
|
|
}
|
|
$5 = HEAP32[$4 + 8 >> 2];
|
|
}
|
|
HEAP32[$4 + 8 >> 2] = $2;
|
|
HEAP32[$5 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 12 >> 2] = $4;
|
|
HEAP32[$2 + 8 >> 2] = $5;
|
|
}
|
|
HEAP32[13237] = $3;
|
|
HEAP32[13234] = $1;
|
|
break label$1;
|
|
}
|
|
$8 = HEAP32[13233];
|
|
if (!$8) {
|
|
break label$12;
|
|
}
|
|
$0 = (0 - $8 & $8) - 1 | 0;
|
|
$1 = $0;
|
|
$0 = $0 >>> 12 & 16;
|
|
$2 = $1 >>> $0 | 0;
|
|
$1 = $2 >>> 5 & 8;
|
|
$3 = $0 | $1;
|
|
$0 = $2 >>> $1 | 0;
|
|
$2 = $0 >>> 2 & 4;
|
|
$1 = $3 | $2;
|
|
$0 = $0 >>> $2 | 0;
|
|
$2 = $0 >>> 1 & 2;
|
|
$1 = $1 | $2;
|
|
$0 = $0 >>> $2 | 0;
|
|
$2 = $0 >>> 1 & 1;
|
|
$3 = HEAP32[(($1 | $2) + ($0 >>> $2 | 0) << 2) + 53232 >> 2];
|
|
$2 = (HEAP32[$3 + 4 >> 2] & -8) - $4 | 0;
|
|
$1 = $3;
|
|
while (1) {
|
|
label$24 : {
|
|
$0 = HEAP32[$1 + 16 >> 2];
|
|
if (!$0) {
|
|
$0 = HEAP32[$1 + 20 >> 2];
|
|
if (!$0) {
|
|
break label$24;
|
|
}
|
|
}
|
|
$1 = (HEAP32[$0 + 4 >> 2] & -8) - $4 | 0;
|
|
$5 = $1;
|
|
$1 = $2 >>> 0 > $1 >>> 0;
|
|
$2 = $1 ? $5 : $2;
|
|
$3 = $1 ? $0 : $3;
|
|
$1 = $0;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$10 = $3 + $4 | 0;
|
|
if ($10 >>> 0 <= $3 >>> 0) {
|
|
break label$11;
|
|
}
|
|
$11 = HEAP32[$3 + 24 >> 2];
|
|
$5 = HEAP32[$3 + 12 >> 2];
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
$0 = HEAP32[$3 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $5;
|
|
HEAP32[$5 + 8 >> 2] = $0;
|
|
break label$2;
|
|
}
|
|
$1 = $3 + 20 | 0;
|
|
$0 = HEAP32[$1 >> 2];
|
|
if (!$0) {
|
|
$0 = HEAP32[$3 + 16 >> 2];
|
|
if (!$0) {
|
|
break label$10;
|
|
}
|
|
$1 = $3 + 16 | 0;
|
|
}
|
|
while (1) {
|
|
$7 = $1;
|
|
$5 = $0;
|
|
$1 = $0 + 20 | 0;
|
|
$0 = HEAP32[$1 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
$1 = $5 + 16 | 0;
|
|
$0 = HEAP32[$5 + 16 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$7 >> 2] = 0;
|
|
break label$2;
|
|
}
|
|
$4 = -1;
|
|
if ($0 >>> 0 > 4294967231) {
|
|
break label$12;
|
|
}
|
|
$0 = $0 + 11 | 0;
|
|
$4 = $0 & -8;
|
|
$9 = HEAP32[13233];
|
|
if (!$9) {
|
|
break label$12;
|
|
}
|
|
$7 = 31;
|
|
if ($4 >>> 0 <= 16777215) {
|
|
$0 = $0 >>> 8 | 0;
|
|
$1 = $0;
|
|
$0 = $0 + 1048320 >>> 16 & 8;
|
|
$2 = $1 << $0;
|
|
$1 = $2;
|
|
$2 = $2 + 520192 >>> 16 & 4;
|
|
$1 = $1 << $2;
|
|
$3 = $1;
|
|
$1 = $1 + 245760 >>> 16 & 2;
|
|
$0 = ($3 << $1 >>> 15 | 0) - ($0 | $2 | $1) | 0;
|
|
$7 = ($0 << 1 | $4 >>> $0 + 21 & 1) + 28 | 0;
|
|
}
|
|
$2 = 0 - $4 | 0;
|
|
$1 = HEAP32[($7 << 2) + 53232 >> 2];
|
|
label$31 : {
|
|
label$32 : {
|
|
label$33 : {
|
|
if (!$1) {
|
|
$0 = 0;
|
|
break label$33;
|
|
}
|
|
$0 = 0;
|
|
$3 = $4 << (($7 | 0) == 31 ? 0 : 25 - ($7 >>> 1 | 0) | 0);
|
|
while (1) {
|
|
label$36 : {
|
|
$6 = (HEAP32[$1 + 4 >> 2] & -8) - $4 | 0;
|
|
if ($6 >>> 0 >= $2 >>> 0) {
|
|
break label$36;
|
|
}
|
|
$5 = $1;
|
|
$2 = $6;
|
|
if ($2) {
|
|
break label$36;
|
|
}
|
|
$2 = 0;
|
|
$0 = $1;
|
|
break label$32;
|
|
}
|
|
$6 = HEAP32[$1 + 20 >> 2];
|
|
$1 = HEAP32[(($3 >>> 29 & 4) + $1 | 0) + 16 >> 2];
|
|
$0 = $6 ? ($6 | 0) == ($1 | 0) ? $0 : $6 : $0;
|
|
$3 = $3 << 1;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!($0 | $5)) {
|
|
$0 = 2 << $7;
|
|
$0 = ($0 | 0 - $0) & $9;
|
|
if (!$0) {
|
|
break label$12;
|
|
}
|
|
$0 = (0 - $0 & $0) - 1 | 0;
|
|
$1 = $0;
|
|
$0 = $0 >>> 12 & 16;
|
|
$1 = $1 >>> $0 | 0;
|
|
$3 = $1 >>> 5 & 8;
|
|
$6 = $0 | $3;
|
|
$0 = $1 >>> $3 | 0;
|
|
$1 = $0 >>> 2 & 4;
|
|
$3 = $6 | $1;
|
|
$0 = $0 >>> $1 | 0;
|
|
$1 = $0 >>> 1 & 2;
|
|
$3 = $3 | $1;
|
|
$0 = $0 >>> $1 | 0;
|
|
$1 = $0 >>> 1 & 1;
|
|
$0 = HEAP32[(($3 | $1) + ($0 >>> $1 | 0) << 2) + 53232 >> 2];
|
|
}
|
|
if (!$0) {
|
|
break label$31;
|
|
}
|
|
}
|
|
while (1) {
|
|
$6 = (HEAP32[$0 + 4 >> 2] & -8) - $4 | 0;
|
|
$3 = $6 >>> 0 < $2 >>> 0;
|
|
$2 = $3 ? $6 : $2;
|
|
$5 = $3 ? $0 : $5;
|
|
$1 = HEAP32[$0 + 16 >> 2];
|
|
if (!$1) {
|
|
$1 = HEAP32[$0 + 20 >> 2];
|
|
}
|
|
$0 = $1;
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$5 | HEAP32[13234] - $4 >>> 0 <= $2 >>> 0) {
|
|
break label$12;
|
|
}
|
|
$7 = $4 + $5 | 0;
|
|
if ($7 >>> 0 <= $5 >>> 0) {
|
|
break label$11;
|
|
}
|
|
$8 = HEAP32[$5 + 24 >> 2];
|
|
$3 = HEAP32[$5 + 12 >> 2];
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
$0 = HEAP32[$5 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $0;
|
|
break label$3;
|
|
}
|
|
$1 = $5 + 20 | 0;
|
|
$0 = HEAP32[$1 >> 2];
|
|
if (!$0) {
|
|
$0 = HEAP32[$5 + 16 >> 2];
|
|
if (!$0) {
|
|
break label$9;
|
|
}
|
|
$1 = $5 + 16 | 0;
|
|
}
|
|
while (1) {
|
|
$6 = $1;
|
|
$3 = $0;
|
|
$1 = $0 + 20 | 0;
|
|
$0 = HEAP32[$1 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
$1 = $3 + 16 | 0;
|
|
$0 = HEAP32[$3 + 16 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$6 >> 2] = 0;
|
|
break label$3;
|
|
}
|
|
$0 = HEAP32[13234];
|
|
if ($4 >>> 0 <= $0 >>> 0) {
|
|
$2 = HEAP32[13237];
|
|
$1 = $0 - $4 | 0;
|
|
label$45 : {
|
|
if ($1 >>> 0 >= 16) {
|
|
HEAP32[13234] = $1;
|
|
$3 = $2 + $4 | 0;
|
|
HEAP32[13237] = $3;
|
|
HEAP32[$3 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$0 + $2 >> 2] = $1;
|
|
HEAP32[$2 + 4 >> 2] = $4 | 3;
|
|
break label$45;
|
|
}
|
|
HEAP32[13237] = 0;
|
|
HEAP32[13234] = 0;
|
|
HEAP32[$2 + 4 >> 2] = $0 | 3;
|
|
$0 = $0 + $2 | 0;
|
|
HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1;
|
|
}
|
|
$0 = $2 + 8 | 0;
|
|
break label$1;
|
|
}
|
|
$3 = HEAP32[13235];
|
|
if ($4 >>> 0 < $3 >>> 0) {
|
|
$2 = $3 - $4 | 0;
|
|
HEAP32[13235] = $2;
|
|
$0 = HEAP32[13238];
|
|
$1 = $4 + $0 | 0;
|
|
HEAP32[13238] = $1;
|
|
HEAP32[$1 + 4 >> 2] = $2 | 1;
|
|
HEAP32[$0 + 4 >> 2] = $4 | 3;
|
|
$0 = $0 + 8 | 0;
|
|
break label$1;
|
|
}
|
|
$0 = 0;
|
|
$9 = $4 + 47 | 0;
|
|
$1 = $9;
|
|
if (HEAP32[13350]) {
|
|
$2 = HEAP32[13352];
|
|
} else {
|
|
HEAP32[13353] = -1;
|
|
HEAP32[13354] = -1;
|
|
HEAP32[13351] = 4096;
|
|
HEAP32[13352] = 4096;
|
|
HEAP32[13350] = $12 + 12 & -16 ^ 1431655768;
|
|
HEAP32[13355] = 0;
|
|
HEAP32[13343] = 0;
|
|
$2 = 4096;
|
|
}
|
|
$6 = $1 + $2 | 0;
|
|
$7 = 0 - $2 | 0;
|
|
$5 = $6 & $7;
|
|
if ($5 >>> 0 <= $4 >>> 0) {
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[13342];
|
|
if ($2) {
|
|
$1 = HEAP32[13340];
|
|
$8 = $5 + $1 | 0;
|
|
if ($2 >>> 0 < $8 >>> 0 | $1 >>> 0 >= $8 >>> 0) {
|
|
break label$1;
|
|
}
|
|
}
|
|
if (HEAPU8[53372] & 4) {
|
|
break label$6;
|
|
}
|
|
label$51 : {
|
|
label$52 : {
|
|
$2 = HEAP32[13238];
|
|
if ($2) {
|
|
$0 = 53376;
|
|
while (1) {
|
|
$1 = HEAP32[$0 >> 2];
|
|
if (HEAP32[$0 + 4 >> 2] + $1 >>> 0 > $2 >>> 0 ? $1 >>> 0 <= $2 >>> 0 : 0) {
|
|
break label$52;
|
|
}
|
|
$0 = HEAP32[$0 + 8 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = sbrk(0);
|
|
if (($3 | 0) == -1) {
|
|
break label$7;
|
|
}
|
|
$6 = $5;
|
|
$0 = HEAP32[13351];
|
|
$2 = $0 - 1 | 0;
|
|
if ($3 & $2) {
|
|
$6 = ($5 - $3 | 0) + ($2 + $3 & 0 - $0) | 0;
|
|
}
|
|
if ($6 >>> 0 > 2147483646 | $4 >>> 0 >= $6 >>> 0) {
|
|
break label$7;
|
|
}
|
|
$0 = HEAP32[13342];
|
|
if ($0) {
|
|
$2 = HEAP32[13340];
|
|
$1 = $6 + $2 | 0;
|
|
if ($0 >>> 0 < $1 >>> 0 | $2 >>> 0 >= $1 >>> 0) {
|
|
break label$7;
|
|
}
|
|
}
|
|
$0 = sbrk($6);
|
|
if (($3 | 0) != ($0 | 0)) {
|
|
break label$51;
|
|
}
|
|
break label$5;
|
|
}
|
|
$6 = $6 - $3 & $7;
|
|
if ($6 >>> 0 > 2147483646) {
|
|
break label$7;
|
|
}
|
|
$3 = sbrk($6);
|
|
if (($3 | 0) == (HEAP32[$0 >> 2] + HEAP32[$0 + 4 >> 2] | 0)) {
|
|
break label$8;
|
|
}
|
|
$0 = $3;
|
|
}
|
|
if (!(($0 | 0) == -1 | $4 + 48 >>> 0 <= $6 >>> 0)) {
|
|
$2 = HEAP32[13352];
|
|
$2 = $2 + ($9 - $6 | 0) & 0 - $2;
|
|
if ($2 >>> 0 > 2147483646) {
|
|
$3 = $0;
|
|
break label$5;
|
|
}
|
|
if ((sbrk($2) | 0) != -1) {
|
|
$6 = $2 + $6 | 0;
|
|
$3 = $0;
|
|
break label$5;
|
|
}
|
|
sbrk(0 - $6 | 0);
|
|
break label$7;
|
|
}
|
|
$3 = $0;
|
|
if (($0 | 0) != -1) {
|
|
break label$5;
|
|
}
|
|
break label$7;
|
|
}
|
|
abort();
|
|
}
|
|
$5 = 0;
|
|
break label$2;
|
|
}
|
|
$3 = 0;
|
|
break label$3;
|
|
}
|
|
if (($3 | 0) != -1) {
|
|
break label$5;
|
|
}
|
|
}
|
|
HEAP32[13343] = HEAP32[13343] | 4;
|
|
}
|
|
if ($5 >>> 0 > 2147483646) {
|
|
break label$4;
|
|
}
|
|
$3 = sbrk($5);
|
|
$1 = ($3 | 0) == -1;
|
|
$0 = sbrk(0);
|
|
if ($1 | $3 >>> 0 >= $0 >>> 0 | ($0 | 0) == -1) {
|
|
break label$4;
|
|
}
|
|
$6 = $0 - $3 | 0;
|
|
if ($6 >>> 0 <= $4 + 40 >>> 0) {
|
|
break label$4;
|
|
}
|
|
}
|
|
$0 = HEAP32[13340] + $6 | 0;
|
|
HEAP32[13340] = $0;
|
|
if (HEAPU32[13341] < $0 >>> 0) {
|
|
HEAP32[13341] = $0;
|
|
}
|
|
label$62 : {
|
|
label$63 : {
|
|
label$64 : {
|
|
$2 = HEAP32[13238];
|
|
if ($2) {
|
|
$0 = 53376;
|
|
while (1) {
|
|
$1 = HEAP32[$0 >> 2];
|
|
$5 = HEAP32[$0 + 4 >> 2];
|
|
if (($1 + $5 | 0) == ($3 | 0)) {
|
|
break label$64;
|
|
}
|
|
$0 = HEAP32[$0 + 8 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$63;
|
|
}
|
|
$0 = HEAP32[13236];
|
|
if (!($0 >>> 0 <= $3 >>> 0 ? $0 : 0)) {
|
|
HEAP32[13236] = $3;
|
|
}
|
|
$0 = 0;
|
|
HEAP32[13345] = $6;
|
|
HEAP32[13344] = $3;
|
|
HEAP32[13240] = -1;
|
|
HEAP32[13241] = HEAP32[13350];
|
|
HEAP32[13347] = 0;
|
|
while (1) {
|
|
$2 = $0 << 3;
|
|
$1 = $2 + 52968 | 0;
|
|
HEAP32[$2 + 52976 >> 2] = $1;
|
|
HEAP32[$2 + 52980 >> 2] = $1;
|
|
$0 = $0 + 1 | 0;
|
|
if (($0 | 0) != 32) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$0 = $6 - 40 | 0;
|
|
$2 = $3 + 8 & 7 ? -8 - $3 & 7 : 0;
|
|
$1 = $0 - $2 | 0;
|
|
HEAP32[13235] = $1;
|
|
$2 = $2 + $3 | 0;
|
|
HEAP32[13238] = $2;
|
|
HEAP32[$2 + 4 >> 2] = $1 | 1;
|
|
HEAP32[($0 + $3 | 0) + 4 >> 2] = 40;
|
|
HEAP32[13239] = HEAP32[13354];
|
|
break label$62;
|
|
}
|
|
if (HEAP32[$0 + 12 >> 2] & 8 | ($2 >>> 0 < $1 >>> 0 | $2 >>> 0 >= $3 >>> 0)) {
|
|
break label$63;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $5 + $6;
|
|
$0 = $2 + 8 & 7 ? -8 - $2 & 7 : 0;
|
|
$1 = $2 + $0 | 0;
|
|
HEAP32[13238] = $1;
|
|
$3 = HEAP32[13235] + $6 | 0;
|
|
$0 = $3 - $0 | 0;
|
|
HEAP32[13235] = $0;
|
|
HEAP32[$1 + 4 >> 2] = $0 | 1;
|
|
HEAP32[($2 + $3 | 0) + 4 >> 2] = 40;
|
|
HEAP32[13239] = HEAP32[13354];
|
|
break label$62;
|
|
}
|
|
$5 = HEAP32[13236];
|
|
if ($5 >>> 0 > $3 >>> 0) {
|
|
HEAP32[13236] = $3;
|
|
}
|
|
$1 = $3 + $6 | 0;
|
|
$0 = 53376;
|
|
label$70 : {
|
|
label$71 : {
|
|
label$72 : {
|
|
label$73 : {
|
|
label$74 : {
|
|
label$75 : {
|
|
while (1) {
|
|
if (HEAP32[$0 >> 2] != ($1 | 0)) {
|
|
$0 = HEAP32[$0 + 8 >> 2];
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break label$75;
|
|
}
|
|
break;
|
|
}
|
|
if (!(HEAPU8[$0 + 12 | 0] & 8)) {
|
|
break label$74;
|
|
}
|
|
}
|
|
$0 = 53376;
|
|
while (1) {
|
|
$1 = HEAP32[$0 >> 2];
|
|
if ($1 >>> 0 <= $2 >>> 0) {
|
|
$1 = HEAP32[$0 + 4 >> 2] + $1 | 0;
|
|
if ($1 >>> 0 > $2 >>> 0) {
|
|
break label$73;
|
|
}
|
|
}
|
|
$0 = HEAP32[$0 + 8 >> 2];
|
|
continue;
|
|
}
|
|
}
|
|
HEAP32[$0 >> 2] = $3;
|
|
HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + $6;
|
|
$7 = ($3 + 8 & 7 ? -8 - $3 & 7 : 0) + $3 | 0;
|
|
HEAP32[$7 + 4 >> 2] = $4 | 3;
|
|
$6 = ($1 + 8 & 7 ? -8 - $1 & 7 : 0) + $1 | 0;
|
|
$1 = ($6 - $7 | 0) - $4 | 0;
|
|
$4 = $4 + $7 | 0;
|
|
if (($2 | 0) == ($6 | 0)) {
|
|
HEAP32[13238] = $4;
|
|
$0 = HEAP32[13235] + $1 | 0;
|
|
HEAP32[13235] = $0;
|
|
HEAP32[$4 + 4 >> 2] = $0 | 1;
|
|
break label$71;
|
|
}
|
|
if (HEAP32[13237] == ($6 | 0)) {
|
|
HEAP32[13237] = $4;
|
|
$0 = HEAP32[13234] + $1 | 0;
|
|
HEAP32[13234] = $0;
|
|
HEAP32[$4 + 4 >> 2] = $0 | 1;
|
|
HEAP32[$0 + $4 >> 2] = $0;
|
|
break label$71;
|
|
}
|
|
$0 = HEAP32[$6 + 4 >> 2];
|
|
if (($0 & 3) == 1) {
|
|
$9 = $0 & -8;
|
|
label$83 : {
|
|
if ($0 >>> 0 <= 255) {
|
|
$8 = $0 >>> 3 | 0;
|
|
$0 = ($8 << 3) + 52968 | 0;
|
|
$3 = HEAP32[$6 + 8 >> 2];
|
|
$2 = HEAP32[$6 + 12 >> 2];
|
|
if (($3 | 0) == ($2 | 0)) {
|
|
HEAP32[13232] = HEAP32[13232] & __wasm_rotl_i32(-2, $8);
|
|
break label$83;
|
|
}
|
|
HEAP32[$3 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 8 >> 2] = $3;
|
|
break label$83;
|
|
}
|
|
$8 = HEAP32[$6 + 24 >> 2];
|
|
$3 = HEAP32[$6 + 12 >> 2];
|
|
label$86 : {
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
$0 = HEAP32[$6 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $0;
|
|
break label$86;
|
|
}
|
|
label$89 : {
|
|
$0 = $6 + 20 | 0;
|
|
$2 = HEAP32[$0 >> 2];
|
|
if ($2) {
|
|
break label$89;
|
|
}
|
|
$0 = $6 + 16 | 0;
|
|
$2 = HEAP32[$0 >> 2];
|
|
if ($2) {
|
|
break label$89;
|
|
}
|
|
$3 = 0;
|
|
break label$86;
|
|
}
|
|
while (1) {
|
|
$5 = $0;
|
|
$3 = $2;
|
|
$0 = $2 + 20 | 0;
|
|
$2 = HEAP32[$0 >> 2];
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
$0 = $3 + 16 | 0;
|
|
$2 = HEAP32[$3 + 16 >> 2];
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$5 >> 2] = 0;
|
|
}
|
|
if (!$8) {
|
|
break label$83;
|
|
}
|
|
$2 = HEAP32[$6 + 28 >> 2];
|
|
$0 = ($2 << 2) + 53232 | 0;
|
|
label$91 : {
|
|
if (HEAP32[$0 >> 2] == ($6 | 0)) {
|
|
HEAP32[$0 >> 2] = $3;
|
|
if ($3) {
|
|
break label$91;
|
|
}
|
|
HEAP32[13233] = HEAP32[13233] & __wasm_rotl_i32(-2, $2);
|
|
break label$83;
|
|
}
|
|
HEAP32[(HEAP32[$8 + 16 >> 2] == ($6 | 0) ? 16 : 20) + $8 >> 2] = $3;
|
|
if (!$3) {
|
|
break label$83;
|
|
}
|
|
}
|
|
HEAP32[$3 + 24 >> 2] = $8;
|
|
$0 = HEAP32[$6 + 16 >> 2];
|
|
if ($0) {
|
|
HEAP32[$3 + 16 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = $3;
|
|
}
|
|
$0 = HEAP32[$6 + 20 >> 2];
|
|
if (!$0) {
|
|
break label$83;
|
|
}
|
|
HEAP32[$3 + 20 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = $3;
|
|
}
|
|
$6 = $6 + $9 | 0;
|
|
$1 = $1 + $9 | 0;
|
|
}
|
|
HEAP32[$6 + 4 >> 2] = HEAP32[$6 + 4 >> 2] & -2;
|
|
HEAP32[$4 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$1 + $4 >> 2] = $1;
|
|
if ($1 >>> 0 <= 255) {
|
|
$2 = $1 >>> 3 | 0;
|
|
$0 = ($2 << 3) + 52968 | 0;
|
|
$2 = 1 << $2;
|
|
$1 = HEAP32[13232];
|
|
label$95 : {
|
|
if (!($2 & $1)) {
|
|
HEAP32[13232] = $2 | $1;
|
|
$2 = $0;
|
|
break label$95;
|
|
}
|
|
$2 = HEAP32[$0 + 8 >> 2];
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $4;
|
|
HEAP32[$2 + 12 >> 2] = $4;
|
|
HEAP32[$4 + 12 >> 2] = $0;
|
|
HEAP32[$4 + 8 >> 2] = $2;
|
|
break label$71;
|
|
}
|
|
$0 = 31;
|
|
if ($1 >>> 0 <= 16777215) {
|
|
$0 = $1 >>> 8 | 0;
|
|
$3 = $0;
|
|
$0 = $0 + 1048320 >>> 16 & 8;
|
|
$2 = $3 << $0;
|
|
$3 = $2;
|
|
$2 = $2 + 520192 >>> 16 & 4;
|
|
$3 = $3 << $2;
|
|
$5 = $3;
|
|
$3 = $3 + 245760 >>> 16 & 2;
|
|
$0 = ($5 << $3 >>> 15 | 0) - ($0 | $2 | $3) | 0;
|
|
$0 = ($0 << 1 | $1 >>> $0 + 21 & 1) + 28 | 0;
|
|
}
|
|
HEAP32[$4 + 28 >> 2] = $0;
|
|
HEAP32[$4 + 16 >> 2] = 0;
|
|
HEAP32[$4 + 20 >> 2] = 0;
|
|
$2 = ($0 << 2) + 53232 | 0;
|
|
$3 = HEAP32[13233];
|
|
$5 = 1 << $0;
|
|
label$98 : {
|
|
if (!($3 & $5)) {
|
|
HEAP32[13233] = $3 | $5;
|
|
HEAP32[$2 >> 2] = $4;
|
|
break label$98;
|
|
}
|
|
$0 = $1 << (($0 | 0) == 31 ? 0 : 25 - ($0 >>> 1 | 0) | 0);
|
|
$3 = HEAP32[$2 >> 2];
|
|
while (1) {
|
|
$2 = $3;
|
|
if ((HEAP32[$2 + 4 >> 2] & -8) == ($1 | 0)) {
|
|
break label$72;
|
|
}
|
|
$3 = $0 >>> 29 | 0;
|
|
$0 = $0 << 1;
|
|
$6 = ($3 & 4) + $2 | 0;
|
|
$5 = $6 + 16 | 0;
|
|
$3 = HEAP32[$5 >> 2];
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$6 + 16 >> 2] = $4;
|
|
}
|
|
HEAP32[$4 + 24 >> 2] = $2;
|
|
HEAP32[$4 + 12 >> 2] = $4;
|
|
HEAP32[$4 + 8 >> 2] = $4;
|
|
break label$71;
|
|
}
|
|
$0 = $6 - 40 | 0;
|
|
$5 = $3 + 8 & 7 ? -8 - $3 & 7 : 0;
|
|
$7 = $0 - $5 | 0;
|
|
HEAP32[13235] = $7;
|
|
$5 = $3 + $5 | 0;
|
|
HEAP32[13238] = $5;
|
|
HEAP32[$5 + 4 >> 2] = $7 | 1;
|
|
HEAP32[($0 + $3 | 0) + 4 >> 2] = 40;
|
|
HEAP32[13239] = HEAP32[13354];
|
|
$0 = (($1 - 39 & 7 ? 39 - $1 & 7 : 0) + $1 | 0) - 47 | 0;
|
|
$5 = $2 + 16 >>> 0 > $0 >>> 0 ? $2 : $0;
|
|
HEAP32[$5 + 4 >> 2] = 27;
|
|
$0 = HEAP32[13347];
|
|
$7 = HEAP32[13346];
|
|
HEAP32[$5 + 16 >> 2] = $7;
|
|
HEAP32[$5 + 20 >> 2] = $0;
|
|
$7 = HEAP32[13345];
|
|
$0 = HEAP32[13344];
|
|
HEAP32[$5 + 8 >> 2] = $0;
|
|
HEAP32[$5 + 12 >> 2] = $7;
|
|
HEAP32[13346] = $5 + 8;
|
|
HEAP32[13345] = $6;
|
|
HEAP32[13344] = $3;
|
|
HEAP32[13347] = 0;
|
|
$0 = $5 + 24 | 0;
|
|
while (1) {
|
|
HEAP32[$0 + 4 >> 2] = 7;
|
|
$3 = $0 + 8 | 0;
|
|
$0 = $0 + 4 | 0;
|
|
if ($1 >>> 0 > $3 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($2 | 0) == ($5 | 0)) {
|
|
break label$62;
|
|
}
|
|
HEAP32[$5 + 4 >> 2] = HEAP32[$5 + 4 >> 2] & -2;
|
|
$6 = $5 - $2 | 0;
|
|
HEAP32[$2 + 4 >> 2] = $6 | 1;
|
|
HEAP32[$5 >> 2] = $6;
|
|
if ($6 >>> 0 <= 255) {
|
|
$1 = $6 >>> 3 | 0;
|
|
$0 = ($1 << 3) + 52968 | 0;
|
|
$1 = 1 << $1;
|
|
$3 = HEAP32[13232];
|
|
label$103 : {
|
|
if (!($1 & $3)) {
|
|
HEAP32[13232] = $1 | $3;
|
|
$1 = $0;
|
|
break label$103;
|
|
}
|
|
$1 = HEAP32[$0 + 8 >> 2];
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $2;
|
|
HEAP32[$1 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 12 >> 2] = $0;
|
|
HEAP32[$2 + 8 >> 2] = $1;
|
|
break label$62;
|
|
}
|
|
$0 = 31;
|
|
HEAP32[$2 + 16 >> 2] = 0;
|
|
HEAP32[$2 + 20 >> 2] = 0;
|
|
if ($6 >>> 0 <= 16777215) {
|
|
$0 = $6 >>> 8 | 0;
|
|
$1 = $0;
|
|
$0 = $0 + 1048320 >>> 16 & 8;
|
|
$1 = $1 << $0;
|
|
$3 = $1;
|
|
$1 = $1 + 520192 >>> 16 & 4;
|
|
$3 = $3 << $1;
|
|
$5 = $3;
|
|
$3 = $3 + 245760 >>> 16 & 2;
|
|
$0 = ($5 << $3 >>> 15 | 0) - ($0 | $1 | $3) | 0;
|
|
$0 = ($0 << 1 | $6 >>> $0 + 21 & 1) + 28 | 0;
|
|
}
|
|
HEAP32[$2 + 28 >> 2] = $0;
|
|
$1 = ($0 << 2) + 53232 | 0;
|
|
$3 = HEAP32[13233];
|
|
$5 = 1 << $0;
|
|
label$106 : {
|
|
if (!($3 & $5)) {
|
|
HEAP32[13233] = $3 | $5;
|
|
HEAP32[$1 >> 2] = $2;
|
|
break label$106;
|
|
}
|
|
$0 = $6 << (($0 | 0) == 31 ? 0 : 25 - ($0 >>> 1 | 0) | 0);
|
|
$3 = HEAP32[$1 >> 2];
|
|
while (1) {
|
|
$1 = $3;
|
|
if ((HEAP32[$1 + 4 >> 2] & -8) == ($6 | 0)) {
|
|
break label$70;
|
|
}
|
|
$3 = $0 >>> 29 | 0;
|
|
$0 = $0 << 1;
|
|
$7 = ($3 & 4) + $1 | 0;
|
|
$5 = $7 + 16 | 0;
|
|
$3 = HEAP32[$5 >> 2];
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$7 + 16 >> 2] = $2;
|
|
}
|
|
HEAP32[$2 + 24 >> 2] = $1;
|
|
HEAP32[$2 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 8 >> 2] = $2;
|
|
break label$62;
|
|
}
|
|
$0 = HEAP32[$2 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $4;
|
|
HEAP32[$2 + 8 >> 2] = $4;
|
|
HEAP32[$4 + 24 >> 2] = 0;
|
|
HEAP32[$4 + 12 >> 2] = $2;
|
|
HEAP32[$4 + 8 >> 2] = $0;
|
|
}
|
|
$0 = $7 + 8 | 0;
|
|
break label$1;
|
|
}
|
|
$0 = HEAP32[$1 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $2;
|
|
HEAP32[$1 + 8 >> 2] = $2;
|
|
HEAP32[$2 + 24 >> 2] = 0;
|
|
HEAP32[$2 + 12 >> 2] = $1;
|
|
HEAP32[$2 + 8 >> 2] = $0;
|
|
}
|
|
$0 = HEAP32[13235];
|
|
if ($4 >>> 0 >= $0 >>> 0) {
|
|
break label$4;
|
|
}
|
|
$2 = $0 - $4 | 0;
|
|
HEAP32[13235] = $2;
|
|
$0 = HEAP32[13238];
|
|
$1 = $4 + $0 | 0;
|
|
HEAP32[13238] = $1;
|
|
HEAP32[$1 + 4 >> 2] = $2 | 1;
|
|
HEAP32[$0 + 4 >> 2] = $4 | 3;
|
|
$0 = $0 + 8 | 0;
|
|
break label$1;
|
|
}
|
|
HEAP32[__errno_location() >> 2] = 48;
|
|
$0 = 0;
|
|
break label$1;
|
|
}
|
|
label$109 : {
|
|
if (!$8) {
|
|
break label$109;
|
|
}
|
|
$1 = HEAP32[$5 + 28 >> 2];
|
|
$0 = ($1 << 2) + 53232 | 0;
|
|
label$110 : {
|
|
if (HEAP32[$0 >> 2] == ($5 | 0)) {
|
|
HEAP32[$0 >> 2] = $3;
|
|
if ($3) {
|
|
break label$110;
|
|
}
|
|
$9 = __wasm_rotl_i32(-2, $1) & $9;
|
|
HEAP32[13233] = $9;
|
|
break label$109;
|
|
}
|
|
HEAP32[(HEAP32[$8 + 16 >> 2] == ($5 | 0) ? 16 : 20) + $8 >> 2] = $3;
|
|
if (!$3) {
|
|
break label$109;
|
|
}
|
|
}
|
|
HEAP32[$3 + 24 >> 2] = $8;
|
|
$0 = HEAP32[$5 + 16 >> 2];
|
|
if ($0) {
|
|
HEAP32[$3 + 16 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = $3;
|
|
}
|
|
$0 = HEAP32[$5 + 20 >> 2];
|
|
if (!$0) {
|
|
break label$109;
|
|
}
|
|
HEAP32[$3 + 20 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = $3;
|
|
}
|
|
label$113 : {
|
|
if ($2 >>> 0 <= 15) {
|
|
$0 = $2 + $4 | 0;
|
|
HEAP32[$5 + 4 >> 2] = $0 | 3;
|
|
$0 = $0 + $5 | 0;
|
|
HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1;
|
|
break label$113;
|
|
}
|
|
HEAP32[$5 + 4 >> 2] = $4 | 3;
|
|
HEAP32[$7 + 4 >> 2] = $2 | 1;
|
|
HEAP32[$2 + $7 >> 2] = $2;
|
|
if ($2 >>> 0 <= 255) {
|
|
$2 = $2 >>> 3 | 0;
|
|
$0 = ($2 << 3) + 52968 | 0;
|
|
$2 = 1 << $2;
|
|
$1 = HEAP32[13232];
|
|
label$116 : {
|
|
if (!($2 & $1)) {
|
|
HEAP32[13232] = $2 | $1;
|
|
$2 = $0;
|
|
break label$116;
|
|
}
|
|
$2 = HEAP32[$0 + 8 >> 2];
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $7;
|
|
HEAP32[$2 + 12 >> 2] = $7;
|
|
HEAP32[$7 + 12 >> 2] = $0;
|
|
HEAP32[$7 + 8 >> 2] = $2;
|
|
break label$113;
|
|
}
|
|
$0 = 31;
|
|
if ($2 >>> 0 <= 16777215) {
|
|
$0 = $2 >>> 8 | 0;
|
|
$1 = $0;
|
|
$0 = $0 + 1048320 >>> 16 & 8;
|
|
$1 = $1 << $0;
|
|
$3 = $1;
|
|
$1 = $1 + 520192 >>> 16 & 4;
|
|
$4 = $3 << $1;
|
|
$3 = $4;
|
|
$4 = $4 + 245760 >>> 16 & 2;
|
|
$0 = ($3 << $4 >>> 15 | 0) - ($0 | $1 | $4) | 0;
|
|
$0 = ($0 << 1 | $2 >>> $0 + 21 & 1) + 28 | 0;
|
|
}
|
|
HEAP32[$7 + 28 >> 2] = $0;
|
|
HEAP32[$7 + 16 >> 2] = 0;
|
|
HEAP32[$7 + 20 >> 2] = 0;
|
|
$1 = ($0 << 2) + 53232 | 0;
|
|
label$119 : {
|
|
$4 = 1 << $0;
|
|
label$120 : {
|
|
if (!($9 & $4)) {
|
|
HEAP32[13233] = $4 | $9;
|
|
HEAP32[$1 >> 2] = $7;
|
|
break label$120;
|
|
}
|
|
$0 = $2 << (($0 | 0) == 31 ? 0 : 25 - ($0 >>> 1 | 0) | 0);
|
|
$4 = HEAP32[$1 >> 2];
|
|
while (1) {
|
|
$1 = $4;
|
|
if ((HEAP32[$1 + 4 >> 2] & -8) == ($2 | 0)) {
|
|
break label$119;
|
|
}
|
|
$4 = $0 >>> 29 | 0;
|
|
$0 = $0 << 1;
|
|
$6 = ($4 & 4) + $1 | 0;
|
|
$3 = $6 + 16 | 0;
|
|
$4 = HEAP32[$3 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$6 + 16 >> 2] = $7;
|
|
}
|
|
HEAP32[$7 + 24 >> 2] = $1;
|
|
HEAP32[$7 + 12 >> 2] = $7;
|
|
HEAP32[$7 + 8 >> 2] = $7;
|
|
break label$113;
|
|
}
|
|
$0 = HEAP32[$1 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $7;
|
|
HEAP32[$1 + 8 >> 2] = $7;
|
|
HEAP32[$7 + 24 >> 2] = 0;
|
|
HEAP32[$7 + 12 >> 2] = $1;
|
|
HEAP32[$7 + 8 >> 2] = $0;
|
|
}
|
|
$0 = $5 + 8 | 0;
|
|
break label$1;
|
|
}
|
|
label$123 : {
|
|
if (!$11) {
|
|
break label$123;
|
|
}
|
|
$1 = HEAP32[$3 + 28 >> 2];
|
|
$0 = ($1 << 2) + 53232 | 0;
|
|
label$124 : {
|
|
if (HEAP32[$0 >> 2] == ($3 | 0)) {
|
|
HEAP32[$0 >> 2] = $5;
|
|
if ($5) {
|
|
break label$124;
|
|
}
|
|
HEAP32[13233] = __wasm_rotl_i32(-2, $1) & $8;
|
|
break label$123;
|
|
}
|
|
HEAP32[(HEAP32[$11 + 16 >> 2] == ($3 | 0) ? 16 : 20) + $11 >> 2] = $5;
|
|
if (!$5) {
|
|
break label$123;
|
|
}
|
|
}
|
|
HEAP32[$5 + 24 >> 2] = $11;
|
|
$0 = HEAP32[$3 + 16 >> 2];
|
|
if ($0) {
|
|
HEAP32[$5 + 16 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = $5;
|
|
}
|
|
$0 = HEAP32[$3 + 20 >> 2];
|
|
if (!$0) {
|
|
break label$123;
|
|
}
|
|
HEAP32[$5 + 20 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = $5;
|
|
}
|
|
label$127 : {
|
|
if ($2 >>> 0 <= 15) {
|
|
$0 = $2 + $4 | 0;
|
|
HEAP32[$3 + 4 >> 2] = $0 | 3;
|
|
$0 = $0 + $3 | 0;
|
|
HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] | 1;
|
|
break label$127;
|
|
}
|
|
HEAP32[$3 + 4 >> 2] = $4 | 3;
|
|
HEAP32[$10 + 4 >> 2] = $2 | 1;
|
|
HEAP32[$2 + $10 >> 2] = $2;
|
|
if ($9) {
|
|
$4 = $9 >>> 3 | 0;
|
|
$1 = ($4 << 3) + 52968 | 0;
|
|
$0 = HEAP32[13237];
|
|
$4 = 1 << $4;
|
|
label$130 : {
|
|
if (!($6 & $4)) {
|
|
HEAP32[13232] = $4 | $6;
|
|
$4 = $1;
|
|
break label$130;
|
|
}
|
|
$4 = HEAP32[$1 + 8 >> 2];
|
|
}
|
|
HEAP32[$1 + 8 >> 2] = $0;
|
|
HEAP32[$4 + 12 >> 2] = $0;
|
|
HEAP32[$0 + 12 >> 2] = $1;
|
|
HEAP32[$0 + 8 >> 2] = $4;
|
|
}
|
|
HEAP32[13237] = $10;
|
|
HEAP32[13234] = $2;
|
|
}
|
|
$0 = $3 + 8 | 0;
|
|
}
|
|
__stack_pointer = $12 + 16 | 0;
|
|
return $0 | 0;
|
|
}
|
|
function silk_pitch_analysis_core_FLP($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) {
|
|
var $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = Math_fround(0), $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = Math_fround(0), $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = Math_fround(0), $33 = 0, $34 = 0, $35 = 0, $36 = Math_fround(0), $37 = 0, $38 = Math_fround(0), $39 = 0, $40 = Math_fround(0), $41 = Math_fround(0), $42 = Math_fround(0), $43 = 0;
|
|
$15 = __stack_pointer - 11552 | 0;
|
|
__stack_pointer = $15;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
if (!(!(1 << $8 & 69888) | $8 >>> 0 > 16)) {
|
|
if (($9 | 0) <= -1) {
|
|
break label$8;
|
|
}
|
|
if (($9 | 0) >= 3) {
|
|
break label$7;
|
|
}
|
|
$16 = Math_imul($10, 5);
|
|
$17 = $16 + 20 | 0;
|
|
$19 = $17 << 3;
|
|
$20 = Math_imul($8, $17);
|
|
label$10 : {
|
|
if (($8 | 0) == 16) {
|
|
if (($20 | 0) >= 1) {
|
|
$12 = $20;
|
|
while (1) {
|
|
$13 = $12 - 1 | 0;
|
|
$22 = ($15 + 2720 | 0) + ($13 << 1) | 0;
|
|
$14 = lrintf(HEAPF32[($13 << 2) + $0 >> 2]);
|
|
$14 = ($14 | 0) > -32768 ? $14 : -32768;
|
|
HEAP16[$22 >> 1] = ($14 | 0) < 32767 ? $14 : 32767;
|
|
$14 = ($12 | 0) > 1;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$15 + 8544 >> 2] = 0;
|
|
HEAP32[$15 + 8548 >> 2] = 0;
|
|
silk_resampler_down2($15 + 8544 | 0, $15 + 8896 | 0, $15 + 2720 | 0, $20);
|
|
if (($16 | 0) < -19) {
|
|
break label$10;
|
|
}
|
|
$12 = $19;
|
|
while (1) {
|
|
$13 = $12 - 1 | 0;
|
|
HEAPF32[($15 + 10176 | 0) + ($13 << 2) >> 2] = HEAP16[($15 + 8896 | 0) + ($13 << 1) >> 1];
|
|
$14 = ($12 | 0) > 1;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$10;
|
|
}
|
|
if (($8 | 0) == 12) {
|
|
if (($20 | 0) >= 1) {
|
|
$12 = $20;
|
|
while (1) {
|
|
$13 = $12 - 1 | 0;
|
|
$22 = ($15 + 2720 | 0) + ($13 << 1) | 0;
|
|
$14 = lrintf(HEAPF32[($13 << 2) + $0 >> 2]);
|
|
$14 = ($14 | 0) > -32768 ? $14 : -32768;
|
|
HEAP16[$22 >> 1] = ($14 | 0) < 32767 ? $14 : 32767;
|
|
$14 = ($12 | 0) > 1;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$22 = $15 + 8560 | 0;
|
|
HEAP32[$22 >> 2] = 0;
|
|
HEAP32[$22 + 4 >> 2] = 0;
|
|
HEAP32[$15 + 8552 >> 2] = 0;
|
|
HEAP32[$15 + 8556 >> 2] = 0;
|
|
HEAP32[$15 + 8544 >> 2] = 0;
|
|
HEAP32[$15 + 8548 >> 2] = 0;
|
|
silk_resampler_down2_3($15 + 8544 | 0, $15 + 8896 | 0, $15 + 2720 | 0, $20);
|
|
if (($16 | 0) < -19) {
|
|
break label$10;
|
|
}
|
|
$12 = $19;
|
|
while (1) {
|
|
$13 = $12 - 1 | 0;
|
|
HEAPF32[($15 + 10176 | 0) + ($13 << 2) >> 2] = HEAP16[($15 + 8896 | 0) + ($13 << 1) >> 1];
|
|
$14 = ($12 | 0) > 1;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$10;
|
|
}
|
|
if (($8 | 0) != 8) {
|
|
break label$6;
|
|
}
|
|
if (($16 | 0) < -19) {
|
|
break label$10;
|
|
}
|
|
$12 = $19;
|
|
while (1) {
|
|
$13 = $12 - 1 | 0;
|
|
$22 = ($15 + 8896 | 0) + ($13 << 1) | 0;
|
|
$14 = lrintf(HEAPF32[($13 << 2) + $0 >> 2]);
|
|
$14 = ($14 | 0) > -32768 ? $14 : -32768;
|
|
HEAP16[$22 >> 1] = ($14 | 0) < 32767 ? $14 : 32767;
|
|
$14 = ($12 | 0) > 1;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$17 = $17 << 2;
|
|
HEAP32[$15 + 8544 >> 2] = 0;
|
|
HEAP32[$15 + 8548 >> 2] = 0;
|
|
silk_resampler_down2($15 + 8544 | 0, $15 + 8576 | 0, $15 + 8896 | 0, $19);
|
|
label$20 : {
|
|
if (($16 | 0) < -19) {
|
|
break label$20;
|
|
}
|
|
$12 = $17;
|
|
while (1) {
|
|
$13 = $12 - 1 | 0;
|
|
HEAPF32[($15 + 9536 | 0) + ($13 << 2) >> 2] = HEAP16[($15 + 8576 | 0) + ($13 << 1) >> 1];
|
|
$14 = ($12 | 0) > 1;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($16 | 0) < -19) {
|
|
break label$20;
|
|
}
|
|
$12 = $17;
|
|
while (1) {
|
|
$25 = HEAPF32[(($12 << 2) + $15 | 0) + 9528 >> 2];
|
|
$13 = $12 - 1 | 0;
|
|
$14 = ($15 + 9536 | 0) + ($13 << 2) | 0;
|
|
$18 = HEAPF32[$14 >> 2];
|
|
label$23 : {
|
|
if (Math_fround(Math_abs($18)) < Math_fround(2147483648)) {
|
|
$16 = ~~$18;
|
|
break label$23;
|
|
}
|
|
$16 = -2147483648;
|
|
}
|
|
$25 = Math_fround($25 + Math_fround($16 | 0));
|
|
$18 = Math_fround(32767);
|
|
label$26 : {
|
|
if ($25 > Math_fround(32767)) {
|
|
break label$26;
|
|
}
|
|
$18 = Math_fround(-32768);
|
|
if ($25 < Math_fround(-32768)) {
|
|
break label$26;
|
|
}
|
|
$18 = $25;
|
|
}
|
|
label$25 : {
|
|
if (Math_fround(Math_abs($18)) < Math_fround(2147483648)) {
|
|
$16 = ~~$18;
|
|
break label$25;
|
|
}
|
|
$16 = -2147483648;
|
|
}
|
|
HEAPF32[$14 >> 2] = $16 | 0;
|
|
$14 = ($12 | 0) > 2;
|
|
$12 = $13;
|
|
if ($14) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$16 = 0;
|
|
memset($15 + 6160 | 0, 0, Math_imul($10, 596));
|
|
if (($10 | 0) >= 2) {
|
|
$12 = $10 >> 1;
|
|
$19 = ($12 | 0) > 1 ? $12 : 1;
|
|
$17 = ($15 + 9536 | 0) + ($17 << 2) | 0;
|
|
$12 = $15 + 9856 | 0;
|
|
while (1) {
|
|
$20 = $12 + 160 | 0;
|
|
if ($20 >>> 0 > $17 >>> 0) {
|
|
break label$5;
|
|
}
|
|
$13 = $12 - 32 | 0;
|
|
if ($13 >>> 0 < $15 + 9536 >>> 0) {
|
|
break label$4;
|
|
}
|
|
if ($12 + 128 >>> 0 > $17 >>> 0) {
|
|
break label$3;
|
|
}
|
|
celt_pitch_xcorr_c($12, $12 - 288 | 0, $15 + 5888 | 0, 40, 65, $11);
|
|
$18 = HEAPF32[$15 + 6144 >> 2];
|
|
$21 = silk_energy_FLP($12, 40);
|
|
$23 = silk_energy_FLP($13, 40);
|
|
$34 = +$18;
|
|
$21 = $21 + $23 + 16e4;
|
|
HEAPF32[$15 + 6192 >> 2] = HEAPF32[$15 + 6192 >> 2] + Math_fround(($34 + $34) / $21);
|
|
$12 = 9;
|
|
while (1) {
|
|
$14 = ($15 + 6160 | 0) + ($12 << 2) | 0;
|
|
$22 = $14;
|
|
$18 = HEAPF32[$14 >> 2];
|
|
$23 = +HEAPF32[((0 - $12 << 2) + $15 | 0) + 6176 >> 2];
|
|
$34 = $23 + $23;
|
|
$14 = $13 - 4 | 0;
|
|
$23 = +HEAPF32[$14 >> 2];
|
|
$39 = $23 * $23;
|
|
$23 = +HEAPF32[$13 + 156 >> 2];
|
|
$21 = $21 + ($39 - $23 * $23);
|
|
HEAPF32[$22 >> 2] = $18 + Math_fround($34 / $21);
|
|
$13 = $14;
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != 73) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = $20;
|
|
$16 = $16 + 1 | 0;
|
|
if (($19 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$27 = $8 << 1;
|
|
$35 = Math_imul($8, 5);
|
|
$30 = Math_imul($8, 18);
|
|
$31 = $30 - 1 | 0;
|
|
$14 = $10 << 2;
|
|
$12 = 72;
|
|
while (1) {
|
|
$13 = ($15 + 6160 | 0) + ($12 << 2) | 0;
|
|
$18 = HEAPF32[$13 >> 2];
|
|
HEAPF32[$13 >> 2] = $18 + Math_fround(Math_fround($18 * Math_fround($12 | 0)) * Math_fround(-.000244140625));
|
|
$13 = $12 >>> 0 > 8;
|
|
$12 = $12 - 1 | 0;
|
|
if ($13) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = ($9 << 1) + 4 | 0;
|
|
silk_insertion_sort_decreasing_FLP($15 + 6192 | 0, $15 + 5744 | 0, 65, $13);
|
|
label$32 : {
|
|
$18 = HEAPF32[$15 + 6192 >> 2];
|
|
label$33 : {
|
|
if (!($18 < Math_fround(.20000000298023224) ^ 1)) {
|
|
memset($1, 0, $14);
|
|
break label$33;
|
|
}
|
|
label$35 : {
|
|
if (($9 | 0) < -1) {
|
|
break label$35;
|
|
}
|
|
$18 = Math_fround($18 * $6);
|
|
$16 = ($13 | 0) > 1 ? $13 : 1;
|
|
$12 = 0;
|
|
while (1) {
|
|
$14 = $12 << 2;
|
|
if (HEAPF32[($14 + $15 | 0) + 6192 >> 2] > $18 ^ 1) {
|
|
$13 = $12;
|
|
break label$35;
|
|
}
|
|
$14 = ($15 + 5744 | 0) + $14 | 0;
|
|
HEAP32[$14 >> 2] = (HEAP32[$14 >> 2] << 1) + 16;
|
|
$12 = $12 + 1 | 0;
|
|
if (($16 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = 0;
|
|
if (($13 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
memset($15 + 5462 | 0, 0, 274);
|
|
while (1) {
|
|
HEAP16[($15 + 5440 | 0) + (HEAP32[($15 + 5744 | 0) + ($12 << 2) >> 2] << 1) >> 1] = 1;
|
|
$12 = $12 + 1 | 0;
|
|
if (($13 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = 146;
|
|
$14 = HEAPU16[$15 + 5730 >> 1];
|
|
while (1) {
|
|
$13 = ($15 + 5440 | 0) + ($12 << 1) | 0;
|
|
$16 = HEAPU16[$13 - 4 >> 1];
|
|
HEAP16[$13 >> 1] = HEAPU16[$13 >> 1] + ($14 + $16 | 0);
|
|
$13 = 16;
|
|
$17 = $12 >>> 0 > 16;
|
|
$14 = $16;
|
|
$12 = $12 - 1 | 0;
|
|
if ($17) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
while (1) {
|
|
$12 = $13 + 1 | 0;
|
|
if (HEAP16[($15 + 5440 | 0) + ($12 << 1) >> 1] >= 1) {
|
|
HEAP32[($15 + 5744 | 0) + ($28 << 2) >> 2] = $13;
|
|
$28 = $28 + 1 | 0;
|
|
}
|
|
$13 = $12;
|
|
if (($12 | 0) != 144) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = 146;
|
|
$14 = HEAPU16[$15 + 5728 >> 1];
|
|
$16 = HEAPU16[$15 + 5730 >> 1];
|
|
while (1) {
|
|
$17 = $14;
|
|
$22 = $14 + $16 | 0;
|
|
$12 = ($15 + 5440 | 0) + ($13 << 1) | 0;
|
|
$14 = HEAPU16[$12 - 6 >> 1];
|
|
HEAP16[$12 >> 1] = HEAPU16[$12 >> 1] + ($14 + $22 | 0);
|
|
$12 = 16;
|
|
$20 = $13 >>> 0 > 16;
|
|
$16 = $17;
|
|
$13 = $13 - 1 | 0;
|
|
if ($20) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$17 = 0;
|
|
while (1) {
|
|
if (HEAP16[($15 + 5440 | 0) + ($12 << 1) >> 1] >= 1) {
|
|
HEAP16[($15 + 5440 | 0) + ($17 << 1) >> 1] = $12 - 2;
|
|
$17 = $17 + 1 | 0;
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != 147) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$20 = 0;
|
|
memset($15 + 6160 | 0, 0, 2384);
|
|
if (($10 | 0) >= 1) {
|
|
$13 = ($8 | 0) == 8 ? $0 + 640 | 0 : $15 + 10816 | 0;
|
|
$19 = ($17 | 0) < 1;
|
|
while (1) {
|
|
$21 = silk_energy_FLP($13, 40);
|
|
if (!$19) {
|
|
$23 = $21 + 1;
|
|
$12 = 0;
|
|
while (1) {
|
|
$18 = Math_fround(0);
|
|
$14 = HEAP16[($15 + 5440 | 0) + ($12 << 1) >> 1] << 2;
|
|
$16 = $13 - $14 | 0;
|
|
$21 = silk_inner_product_FLP($16, $13, 40);
|
|
if (!($21 > 0 ^ 1)) {
|
|
$18 = Math_fround(($21 + $21) / ($23 + silk_energy_FLP($16, 40)));
|
|
}
|
|
HEAPF32[(($15 + 6160 | 0) + Math_imul($20, 596) | 0) + $14 >> 2] = $18;
|
|
$12 = $12 + 1 | 0;
|
|
if (($17 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = $13 + 160 | 0;
|
|
$20 = $20 + 1 | 0;
|
|
if (($20 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($5 | 0) < 1) {
|
|
$6 = Math_fround(0);
|
|
} else {
|
|
$5 = ($8 | 0) == 12 ? ($5 << 1) / 3 | 0 : $5 >>> (($8 | 0) == 16) | 0;
|
|
$6 = Math_fround(log10(+Math_fround($5 | 0)) * 3.32192809488736);
|
|
}
|
|
$40 = $6;
|
|
if (($28 | 0) >= 1) {
|
|
$12 = ($10 | 0) == 4;
|
|
$20 = $12 ? ($8 | 0) == 8 ? ($9 | 0) > 0 ? 11 : 3 : 3 : 3;
|
|
$16 = $12 ? 10048 : 10007;
|
|
$17 = $12 ? 11 : 3;
|
|
$36 = Math_fround($10 | 0);
|
|
$41 = Math_fround($36 * $7);
|
|
$38 = Math_fround($36 * Math_fround(.20000000298023224));
|
|
$24 = -1;
|
|
$7 = Math_fround(-1e3);
|
|
$6 = Math_fround(0);
|
|
$29 = ($10 | 0) < 1;
|
|
$37 = ($5 | 0) < 1;
|
|
$5 = 0;
|
|
while (1) {
|
|
$14 = HEAP32[($15 + 5744 | 0) + ($26 << 2) >> 2];
|
|
$13 = 0;
|
|
while (1) {
|
|
$19 = ($15 + 5840 | 0) + ($13 << 2) | 0;
|
|
HEAP32[$19 >> 2] = 0;
|
|
$18 = Math_fround(0);
|
|
$12 = 0;
|
|
if (!$29) {
|
|
while (1) {
|
|
$18 = Math_fround(HEAPF32[(($15 + 6160 | 0) + Math_imul($12, 596) | 0) + (HEAP8[(Math_imul($12, $17) + $13 | 0) + $16 | 0] + $14 << 2) >> 2] + $18);
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$19 >> 2] = $18;
|
|
}
|
|
$13 = $13 + 1 | 0;
|
|
if (($20 | 0) != ($13 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$18 = Math_fround(-1e3);
|
|
$12 = 0;
|
|
$13 = 0;
|
|
while (1) {
|
|
$25 = HEAPF32[($15 + 5840 | 0) + ($12 << 2) >> 2];
|
|
$19 = $25 > $18;
|
|
$18 = $19 ? $25 : $18;
|
|
$13 = $19 ? $12 : $13;
|
|
$12 = $12 + 1 | 0;
|
|
if (($20 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$32 = Math_fround(log10(+Math_fround($14 | 0)) * 3.32192809488736);
|
|
$25 = Math_fround($18 - Math_fround($38 * $32));
|
|
$42 = $18;
|
|
if (!$37) {
|
|
$32 = Math_fround($32 - $40);
|
|
$32 = Math_fround($32 * $32);
|
|
$25 = Math_fround($25 - Math_fround(Math_fround($32 * Math_fround($38 * HEAPF32[$4 >> 2])) / Math_fround($32 + Math_fround(.5))));
|
|
}
|
|
$12 = $7 < $25 & $18 > $41;
|
|
$6 = $12 ? $42 : $6;
|
|
$7 = $12 ? $25 : $7;
|
|
$24 = $12 ? $14 : $24;
|
|
$5 = $12 ? $13 : $5;
|
|
$26 = $26 + 1 | 0;
|
|
if (($26 | 0) != ($28 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($24 | 0) != -1) {
|
|
break label$32;
|
|
}
|
|
}
|
|
$22 = $1;
|
|
HEAP32[$22 >> 2] = 0;
|
|
HEAP32[$22 + 4 >> 2] = 0;
|
|
HEAP32[$22 + 8 >> 2] = 0;
|
|
HEAP32[$22 + 12 >> 2] = 0;
|
|
}
|
|
HEAP32[$4 >> 2] = 0;
|
|
HEAP16[$2 >> 1] = 0;
|
|
HEAP8[$3 | 0] = 0;
|
|
$12 = 1;
|
|
break label$1;
|
|
}
|
|
HEAPF32[$4 >> 2] = $6 / $36;
|
|
$43 = $2;
|
|
label$62 : {
|
|
if (($8 | 0) <= 8) {
|
|
$12 = 0;
|
|
if (($10 | 0) > 0) {
|
|
while (1) {
|
|
$13 = HEAP8[(Math_imul($12, $17) + $5 | 0) + $16 | 0] + $24 | 0;
|
|
$13 = ($13 | 0) > 16 ? $13 : 16;
|
|
HEAP32[($12 << 2) + $1 >> 2] = ($13 | 0) < 144 ? $13 : 144;
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = $24 - 16 | 0;
|
|
break label$62;
|
|
}
|
|
label$66 : {
|
|
if (($8 | 0) == 12) {
|
|
$12 = Math_imul($24 << 16 >> 16, 3);
|
|
$12 = ($12 >> 1) + ($12 & 1) | 0;
|
|
break label$66;
|
|
}
|
|
$12 = $24 << 1;
|
|
}
|
|
label$68 : {
|
|
if (($27 | 0) >= ($30 | 0)) {
|
|
$26 = $27;
|
|
if (($12 | 0) > ($27 | 0)) {
|
|
break label$68;
|
|
}
|
|
$26 = ($12 | 0) < ($31 | 0) ? $31 : $12;
|
|
break label$68;
|
|
}
|
|
$26 = $31;
|
|
if (($12 | 0) >= ($30 | 0)) {
|
|
break label$68;
|
|
}
|
|
$26 = ($12 | 0) < ($27 | 0) ? $27 : $12;
|
|
}
|
|
$29 = 10016;
|
|
$24 = 10040;
|
|
$17 = 12;
|
|
$4 = 12;
|
|
label$70 : {
|
|
switch ($10 - 2 | 0) {
|
|
default:
|
|
celt_fatal(10770, 10329, 518);
|
|
abort();
|
|
case 2:
|
|
$24 = ($9 << 3) + 10240 | 0;
|
|
$17 = HEAP8[$9 + 10264 | 0];
|
|
$29 = 10096;
|
|
$4 = 34;
|
|
break;
|
|
case 0:
|
|
break label$70;
|
|
}
|
|
}
|
|
$12 = $26 + 2 | 0;
|
|
$31 = ($12 | 0) < ($31 | 0) ? $12 : $31;
|
|
$12 = $26 - 2 | 0;
|
|
$28 = ($12 | 0) > ($27 | 0) ? $12 : $27;
|
|
$37 = 0 - $28 << 2;
|
|
$8 = Math_imul($8, 80) + $0 | 0;
|
|
$5 = $8;
|
|
$16 = 0;
|
|
while (1) {
|
|
$12 = $16 << 1;
|
|
$14 = HEAP8[($12 | 1) + $24 | 0];
|
|
$19 = HEAP8[$12 + $24 | 0];
|
|
$12 = 1 - $19 | 0;
|
|
celt_pitch_xcorr_c($5, ($5 + $37 | 0) - ($14 << 2) | 0, $15 + 2720 | 0, $35, $14 + $12 | 0, $11);
|
|
$13 = ($14 | 0) < ($19 | 0);
|
|
if (!$13) {
|
|
$20 = ($13 ? $19 : $14) + $12 | 0;
|
|
$12 = 0;
|
|
$13 = $19;
|
|
while (1) {
|
|
HEAP32[($15 + 11456 | 0) + ($12 << 2) >> 2] = HEAP32[($15 + 2720 | 0) + ($14 - $13 << 2) >> 2];
|
|
$13 = $13 + 1 | 0;
|
|
$12 = $12 + 1 | 0;
|
|
if (($20 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($17 | 0) >= 1) {
|
|
$20 = Math_imul($4, $16);
|
|
$19 = ($15 + 11456 | 0) + (0 - $19 << 2) | 0;
|
|
$12 = 0;
|
|
while (1) {
|
|
$14 = (HEAP8[($12 + $20 | 0) + $29 | 0] << 2) + $19 | 0;
|
|
$33 = HEAP32[$14 >> 2];
|
|
$22 = HEAP32[$14 + 4 >> 2];
|
|
$13 = (Math_imul($16, 680) + $15 | 0) + Math_imul($12, 20) | 0;
|
|
HEAP32[$13 >> 2] = $33;
|
|
HEAP32[$13 + 4 >> 2] = $22;
|
|
HEAP32[$13 + 16 >> 2] = HEAP32[$14 + 16 >> 2];
|
|
$33 = HEAP32[$14 + 12 >> 2];
|
|
$22 = HEAP32[$14 + 8 >> 2];
|
|
HEAP32[$13 + 8 >> 2] = $22;
|
|
HEAP32[$13 + 12 >> 2] = $33;
|
|
$12 = $12 + 1 | 0;
|
|
if (($17 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = ($35 << 2) + $5 | 0;
|
|
$16 = $16 + 1 | 0;
|
|
if (($16 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$29 = 10016;
|
|
$24 = 10040;
|
|
$17 = 12;
|
|
$0 = 12;
|
|
label$78 : {
|
|
switch ($10 - 2 | 0) {
|
|
default:
|
|
celt_fatal(10770, 10329, 584);
|
|
abort();
|
|
case 2:
|
|
$24 = ($9 << 3) + 10240 | 0;
|
|
$17 = HEAP8[$9 + 10264 | 0];
|
|
$29 = 10096;
|
|
$0 = 34;
|
|
break;
|
|
case 0:
|
|
break label$78;
|
|
}
|
|
}
|
|
$5 = $8;
|
|
$16 = 0;
|
|
while (1) {
|
|
$12 = $16 << 1;
|
|
$19 = HEAP8[$24 + $12 | 0];
|
|
$13 = $5 - ($28 + $19 << 2) | 0;
|
|
$21 = silk_energy_FLP($13, $35) + .001;
|
|
HEAPF32[$15 + 11456 >> 2] = $21;
|
|
$14 = HEAP8[($12 | 1) + $24 | 0];
|
|
if (($19 | 0) < ($14 | 0)) {
|
|
$12 = 1;
|
|
$20 = ($14 - $19 | 0) + 1 | 0;
|
|
while (1) {
|
|
$23 = +HEAPF32[($35 - $12 << 2) + $13 >> 2];
|
|
$23 = $21 - $23 * $23;
|
|
$14 = $12 << 2;
|
|
$21 = +HEAPF32[$13 - $14 >> 2];
|
|
$21 = $23 + $21 * $21;
|
|
HEAPF32[($15 + 11456 | 0) + $14 >> 2] = $21;
|
|
$12 = $12 + 1 | 0;
|
|
if (($20 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($17 | 0) >= 1) {
|
|
$20 = Math_imul($0, $16);
|
|
$19 = ($15 + 11456 | 0) + (0 - $19 << 2) | 0;
|
|
$12 = 0;
|
|
while (1) {
|
|
$14 = (HEAP8[($12 + $20 | 0) + $29 | 0] << 2) + $19 | 0;
|
|
$33 = HEAP32[$14 >> 2];
|
|
$22 = HEAP32[$14 + 4 >> 2];
|
|
$13 = (($15 + 2720 | 0) + Math_imul($16, 680) | 0) + Math_imul($12, 20) | 0;
|
|
HEAP32[$13 >> 2] = $33;
|
|
HEAP32[$13 + 4 >> 2] = $22;
|
|
HEAP32[$13 + 16 >> 2] = HEAP32[$14 + 16 >> 2];
|
|
$33 = HEAP32[$14 + 12 >> 2];
|
|
$22 = HEAP32[$14 + 8 >> 2];
|
|
HEAP32[$13 + 8 >> 2] = $22;
|
|
HEAP32[$13 + 12 >> 2] = $33;
|
|
$12 = $12 + 1 | 0;
|
|
if (($17 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = ($35 << 2) + $5 | 0;
|
|
$16 = $16 + 1 | 0;
|
|
if (($16 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
label$86 : {
|
|
if (($10 | 0) != 4) {
|
|
$24 = 10016;
|
|
$0 = 12;
|
|
$19 = 12;
|
|
break label$86;
|
|
}
|
|
$24 = 10096;
|
|
$0 = 34;
|
|
$19 = HEAP8[$9 + 10264 | 0];
|
|
}
|
|
$21 = silk_energy_FLP($8, Math_imul($10, $35));
|
|
$5 = 0;
|
|
if (($28 | 0) <= ($31 | 0)) {
|
|
$7 = Math_fround(Math_fround(.05000000074505806) / Math_fround($26 | 0));
|
|
$34 = $21 + 1;
|
|
$25 = Math_fround(-1e3);
|
|
$29 = ($10 | 0) < 1;
|
|
$20 = 0;
|
|
while (1) {
|
|
$17 = 0;
|
|
if (($19 | 0) > 0) {
|
|
while (1) {
|
|
$18 = Math_fround(0);
|
|
label$92 : {
|
|
if ($29) {
|
|
break label$92;
|
|
}
|
|
$21 = 0;
|
|
$12 = 0;
|
|
$23 = $34;
|
|
while (1) {
|
|
$16 = $20 << 2;
|
|
$14 = Math_imul($17, 20);
|
|
$13 = Math_imul($12, 680);
|
|
$23 = $23 + +HEAPF32[$16 + ($14 + ($13 + ($15 + 2720 | 0) | 0) | 0) >> 2];
|
|
$21 = $21 + +HEAPF32[(($13 + $15 | 0) + $14 | 0) + $16 >> 2];
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($21 > 0 ^ 1) {
|
|
break label$92;
|
|
}
|
|
$18 = Math_fround(Math_fround(Math_fround(1) - Math_fround($7 * Math_fround($17 | 0))) * Math_fround(($21 + $21) / $23));
|
|
}
|
|
if (!($18 > $25 ^ 1)) {
|
|
$12 = (HEAP8[$17 + 10096 | 0] + $28 | 0) < ($30 | 0);
|
|
$26 = $12 ? $28 : $26;
|
|
$25 = $12 ? $18 : $25;
|
|
$5 = $12 ? $17 : $5;
|
|
}
|
|
$17 = $17 + 1 | 0;
|
|
if (($19 | 0) != ($17 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$20 = $20 + 1 | 0;
|
|
$12 = ($28 | 0) < ($31 | 0);
|
|
$28 = $28 + 1 | 0;
|
|
if ($12) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($10 | 0) >= 1) {
|
|
$12 = 0;
|
|
while (1) {
|
|
$16 = ($12 << 2) + $1 | 0;
|
|
$13 = HEAP8[(Math_imul($0, $12) + $5 | 0) + $24 | 0] + $26 | 0;
|
|
HEAP32[$16 >> 2] = $13;
|
|
label$97 : {
|
|
if (($27 | 0) > ($30 | 0)) {
|
|
$14 = $27;
|
|
if (($14 | 0) < ($13 | 0)) {
|
|
break label$97;
|
|
}
|
|
$14 = ($13 | 0) < ($30 | 0) ? $30 : $13;
|
|
break label$97;
|
|
}
|
|
$14 = $30;
|
|
if (($14 | 0) < ($13 | 0)) {
|
|
break label$97;
|
|
}
|
|
$14 = ($13 | 0) < ($27 | 0) ? $27 : $13;
|
|
}
|
|
HEAP32[$16 >> 2] = $14;
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = $26 - $27 | 0;
|
|
}
|
|
HEAP16[$43 >> 1] = $12;
|
|
HEAP8[$3 | 0] = $5;
|
|
$12 = 0;
|
|
if (HEAP16[$2 >> 1] > -1) {
|
|
break label$1;
|
|
}
|
|
celt_fatal(10737, 10329, 474);
|
|
abort();
|
|
}
|
|
celt_fatal(10267, 10329, 112);
|
|
abort();
|
|
}
|
|
celt_fatal(10366, 10329, 115);
|
|
abort();
|
|
}
|
|
celt_fatal(10418, 10329, 116);
|
|
abort();
|
|
}
|
|
celt_fatal(10470, 10329, 151);
|
|
abort();
|
|
}
|
|
celt_fatal(10500, 10329, 173);
|
|
abort();
|
|
}
|
|
celt_fatal(10580, 10329, 178);
|
|
abort();
|
|
}
|
|
celt_fatal(10622, 10329, 179);
|
|
abort();
|
|
}
|
|
celt_fatal(10701, 10329, 241);
|
|
abort();
|
|
}
|
|
__stack_pointer = $15 + 11552 | 0;
|
|
return $12;
|
|
}
|
|
function opus_encoder_ctl($0, $1, $2) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
$3 = __stack_pointer - 208 | 0;
|
|
__stack_pointer = $3;
|
|
HEAP32[$3 + 204 >> 2] = $2;
|
|
$4 = HEAP32[$0 >> 2] + $0 | 0;
|
|
$2 = -5;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
label$10 : {
|
|
label$11 : {
|
|
label$12 : {
|
|
label$13 : {
|
|
label$14 : {
|
|
label$15 : {
|
|
label$16 : {
|
|
label$17 : {
|
|
label$18 : {
|
|
label$19 : {
|
|
label$20 : {
|
|
label$21 : {
|
|
label$22 : {
|
|
label$23 : {
|
|
label$24 : {
|
|
label$25 : {
|
|
switch ($1 - 4e3 | 0) {
|
|
default:
|
|
label$46 : {
|
|
switch ($1 - 10015 | 0) {
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 10:
|
|
break label$1;
|
|
case 0:
|
|
break label$2;
|
|
case 11:
|
|
break label$4;
|
|
case 9:
|
|
break label$5;
|
|
default:
|
|
break label$46;
|
|
}
|
|
}
|
|
switch ($1 - 11002 | 0) {
|
|
case 17:
|
|
break label$23;
|
|
case 16:
|
|
break label$24;
|
|
case 0:
|
|
break label$6;
|
|
default:
|
|
break label$1;
|
|
}
|
|
case 0:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
$4 = $1 - 2048 | 0;
|
|
if ($4 >>> 0 > 3 | ($4 | 0) == 2 | (HEAP32[$0 + 108 >> 2] != ($1 | 0) ? !HEAP32[$0 + 14252 >> 2] : 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 108 >> 2] = $1;
|
|
HEAP32[$0 + 192 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 1:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 108 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 2:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$4 = $0;
|
|
$1 = HEAP32[$2 >> 2];
|
|
label$49 : {
|
|
if (($1 | 0) == -1e3) {
|
|
$5 = $1;
|
|
break label$49;
|
|
}
|
|
$2 = -1;
|
|
$5 = $1;
|
|
if (($1 | 0) == -1) {
|
|
break label$49;
|
|
}
|
|
if (($1 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = 500;
|
|
if (($1 | 0) < 501) {
|
|
break label$49;
|
|
}
|
|
$2 = Math_imul(HEAP32[$0 + 112 >> 2], 3e5);
|
|
$5 = ($1 | 0) > ($2 | 0) ? $2 : $1;
|
|
}
|
|
$2 = $5;
|
|
HEAP32[$4 + 164 >> 2] = $2;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 3:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
if (!$1) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
$4 = HEAP32[$0 + 14236 >> 2];
|
|
if (!$4) {
|
|
$4 = HEAP32[$0 + 144 >> 2] / 400 | 0;
|
|
}
|
|
$2 = HEAP32[$0 + 164 >> 2];
|
|
label$53 : {
|
|
if (($2 | 0) != -1) {
|
|
if (($2 | 0) != -1e3) {
|
|
break label$53;
|
|
}
|
|
$2 = HEAP32[$0 + 112 >> 2];
|
|
$0 = HEAP32[$0 + 144 >> 2];
|
|
$2 = Math_imul($2, $0) + ((Math_imul($0, 60) | 0) / ($4 | 0) | 0) | 0;
|
|
break label$53;
|
|
}
|
|
$2 = (Math_imul(HEAP32[$0 + 144 >> 2], 10208) | 0) / ($4 | 0) | 0;
|
|
}
|
|
HEAP32[$1 >> 2] = $2;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 22:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
label$55 : {
|
|
if (($1 | 0) >= 1) {
|
|
$2 = -1;
|
|
if (HEAP32[$0 + 112 >> 2] >= ($1 | 0)) {
|
|
break label$55;
|
|
}
|
|
break label$1;
|
|
}
|
|
$2 = -1;
|
|
if (($1 | 0) != -1e3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
HEAP32[$0 + 120 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 23:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 120 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 4:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 - 1101 >>> 0 > 4) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 132 >> 2] = $1;
|
|
if (($1 | 0) == 1101) {
|
|
HEAP32[$0 + 20 >> 2] = 8e3;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) == 1102) {
|
|
HEAP32[$0 + 20 >> 2] = 12e3;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 20 >> 2] = 16e3;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 5:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 132 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 8:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
if ($1 - 1101 >>> 0 >= 5) {
|
|
$2 = -1;
|
|
if (($1 | 0) != -1e3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
HEAP32[$0 + 128 >> 2] = $1;
|
|
if (($1 | 0) == 1101) {
|
|
HEAP32[$0 + 20 >> 2] = 8e3;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) == 1102) {
|
|
HEAP32[$0 + 20 >> 2] = 12e3;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 20 >> 2] = 16e3;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 9:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 14240 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 16:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 184 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 17:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 184 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 10:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 10) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = $1;
|
|
HEAP32[$3 >> 2] = $1;
|
|
opus_custom_encoder_ctl($4, 4010, $3);
|
|
$2 = 0;
|
|
break label$1;
|
|
case 11:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 44 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 12:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 48 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 13:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 48 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 14:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 100) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $1;
|
|
HEAP32[$3 + 16 >> 2] = $1;
|
|
opus_custom_encoder_ctl($4, 4014, $3 + 16 | 0);
|
|
$2 = 0;
|
|
break label$1;
|
|
case 15:
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 40 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
case 6:
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 148 >> 2] = $1;
|
|
HEAP32[$0 + 60 >> 2] = 1 - $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
case 18:
|
|
case 19:
|
|
case 26:
|
|
case 30:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 38:
|
|
case 39:
|
|
case 44:
|
|
case 45:
|
|
case 48:
|
|
break label$1;
|
|
case 43:
|
|
break label$10;
|
|
case 42:
|
|
break label$11;
|
|
case 41:
|
|
break label$12;
|
|
case 40:
|
|
break label$13;
|
|
case 37:
|
|
break label$14;
|
|
case 36:
|
|
break label$15;
|
|
case 31:
|
|
break label$16;
|
|
case 29:
|
|
break label$17;
|
|
case 27:
|
|
break label$18;
|
|
case 25:
|
|
break label$19;
|
|
case 24:
|
|
break label$20;
|
|
case 21:
|
|
break label$21;
|
|
case 20:
|
|
break label$22;
|
|
case 7:
|
|
break label$25;
|
|
case 49:
|
|
break label$3;
|
|
case 28:
|
|
break label$7;
|
|
case 47:
|
|
break label$8;
|
|
case 46:
|
|
break label$9;
|
|
}
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 148 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 + 1 >>> 0 > 101) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 140 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 140 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 152 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 152 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
if ($1 - 3001 >>> 0 >= 2) {
|
|
$2 = -1;
|
|
if (($1 | 0) != -1e3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
HEAP32[$0 + 124 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 124 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
if (!$1) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
$4 = HEAP32[$0 + 144 >> 2] / 400 | 0;
|
|
HEAP32[$1 >> 2] = $4;
|
|
$2 = 0;
|
|
if (HEAP32[$0 + 108 >> 2] == 2051) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$1 >> 2] = HEAP32[$0 + 116 >> 2] + $4;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 144 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 18136 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 - 8 >>> 0 > 16) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 168 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 168 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 - 5e3 >>> 0 > 9) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 156 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 156 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 76 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 76 >> 2];
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$0 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $0 + 4;
|
|
$2 = -1;
|
|
$0 = HEAP32[$0 >> 2];
|
|
if ($0 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 + 32 >> 2] = $0;
|
|
opus_custom_encoder_ctl($4, 4046, $3 + 32 | 0);
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$0 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $0 + 4;
|
|
$0 = HEAP32[$0 >> 2];
|
|
if (!$0) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 + 48 >> 2] = $0;
|
|
opus_custom_encoder_ctl($4, 4047, $3 + 48 | 0);
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$0 + 4 >> 2];
|
|
tonality_analysis_reset($0 + 188 | 0);
|
|
$2 = 0;
|
|
memset($0 + 14192 | 0, 0, 3948);
|
|
opus_custom_encoder_ctl($4, 4028, 0);
|
|
silk_InitEncoder($0 + $1 | 0, HEAP32[$0 + 180 >> 2], $3 + 104 | 0);
|
|
HEAP32[$0 + 14252 >> 2] = 1;
|
|
HEAP32[$0 + 14204 >> 2] = 1065353216;
|
|
HEAP16[$0 + 14196 >> 1] = 16384;
|
|
HEAP32[$0 + 14240 >> 2] = 1105;
|
|
HEAP32[$0 + 14224 >> 2] = 1001;
|
|
HEAP32[$0 + 14192 >> 2] = HEAP32[$0 + 112 >> 2];
|
|
HEAP32[$0 + 14200 >> 2] = silk_lin2log(60) << 8;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
if ($1 - 1e3 >>> 0 >= 3) {
|
|
$2 = -1;
|
|
if (($1 | 0) != -1e3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
HEAP32[$0 + 136 >> 2] = $1;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
HEAP32[$0 + 176 >> 2] = $2;
|
|
HEAP32[$3 + 64 >> 2] = $2;
|
|
$2 = opus_custom_encoder_ctl($4, 10024, $3 - -64 | 0);
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
HEAP32[$0 + 14256 >> 2] = $2;
|
|
HEAP32[$3 + 80 >> 2] = $2;
|
|
$2 = opus_custom_encoder_ctl($4, 10026, $3 + 80 | 0);
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $2 + 4;
|
|
$6 = HEAP32[$2 >> 2];
|
|
if (!$6) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
if (!(!HEAP32[$0 + 56 >> 2] | (HEAP32[$0 + 14228 >> 2] & -2) != 1e3)) {
|
|
$2 = HEAP32[$0 + 4 >> 2];
|
|
HEAP32[$6 >> 2] = 1;
|
|
if (HEAP32[$0 + 12 >> 2] < 1) {
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$7 = $0 + $2 | 0;
|
|
$4 = 0;
|
|
$5 = 1;
|
|
while (1) {
|
|
$1 = 0;
|
|
$1 = $5 ? HEAP32[(Math_imul($4, 10064) + $7 | 0) + 6084 >> 2] > 9 : $1;
|
|
HEAP32[$6 >> 2] = $1;
|
|
$2 = 0;
|
|
$5 = $1;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) < HEAP32[$0 + 12 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (HEAP32[$0 + 184 >> 2]) {
|
|
HEAP32[$6 >> 2] = HEAP32[$0 + 18124 >> 2] > 9;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
$2 = 0;
|
|
HEAP32[$6 >> 2] = 0;
|
|
break label$1;
|
|
}
|
|
$0 = HEAP32[$3 + 204 >> 2];
|
|
HEAP32[$3 + 204 >> 2] = $0 + 4;
|
|
$0 = HEAP32[$0 >> 2];
|
|
if (!$0) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 + 96 >> 2] = $0;
|
|
$2 = opus_custom_encoder_ctl($4, 10015, $3 + 96 | 0);
|
|
}
|
|
__stack_pointer = $3 + 208 | 0;
|
|
return $2 | 0;
|
|
}
|
|
function silk_Encode($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0;
|
|
$16 = __stack_pointer - 32 | 0;
|
|
$15 = $16;
|
|
__stack_pointer = $15;
|
|
if (HEAP32[$1 + 68 >> 2]) {
|
|
HEAP32[$0 + 14728 >> 2] = 1;
|
|
HEAP32[$0 + 4664 >> 2] = 1;
|
|
}
|
|
HEAP32[$0 + 5748 >> 2] = 0;
|
|
HEAP32[$0 + 15812 >> 2] = 0;
|
|
if (!check_control_input($1)) {
|
|
$34 = $0 + 10064 | 0;
|
|
HEAP32[$1 + 88 >> 2] = 0;
|
|
label$3 : {
|
|
if (HEAP32[$1 + 4 >> 2] <= HEAP32[$0 + 20196 >> 2]) {
|
|
break label$3;
|
|
}
|
|
$14 = silk_init_encoder($34, HEAP32[$0 + 5092 >> 2]);
|
|
HEAP32[$0 + 20144 >> 2] = 1;
|
|
HEAP32[$0 + 20148 >> 2] = 0;
|
|
HEAP32[$0 + 20136 >> 2] = 0;
|
|
HEAP32[$0 + 20140 >> 2] = 0;
|
|
HEAP32[$0 + 20128 >> 2] = 0;
|
|
HEAP32[$0 + 20152 >> 2] = 1;
|
|
HEAP32[$0 + 20156 >> 2] = 16384;
|
|
if (HEAP32[$0 + 20192 >> 2] != 2) {
|
|
break label$3;
|
|
}
|
|
memcpy($0 + 15840 | 0, $0 + 5776 | 0, 300);
|
|
$20 = HEAP32[$0 + 4 >> 2];
|
|
$12 = HEAP32[$0 >> 2];
|
|
HEAP32[$0 + 10064 >> 2] = $12;
|
|
HEAP32[$0 + 10068 >> 2] = $20;
|
|
}
|
|
$24 = HEAP32[$1 + 24 >> 2];
|
|
label$4 : {
|
|
if (($24 | 0) != HEAP32[$0 + 4612 >> 2]) {
|
|
$8 = HEAP32[$1 + 4 >> 2];
|
|
$21 = 1;
|
|
break label$4;
|
|
}
|
|
$8 = HEAP32[$1 + 4 >> 2];
|
|
$21 = ($8 | 0) != HEAP32[$0 + 20196 >> 2];
|
|
}
|
|
$9 = HEAP32[$1 >> 2];
|
|
HEAP32[$0 + 20196 >> 2] = $8;
|
|
HEAP32[$0 + 20192 >> 2] = $9;
|
|
$10 = Math_imul($3, 100);
|
|
$9 = HEAP32[$1 + 8 >> 2];
|
|
$18 = ($10 | 0) / ($9 | 0) | 0;
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
if ($6) {
|
|
if (($18 | 0) != 1) {
|
|
break label$6;
|
|
}
|
|
if (($6 | 0) == 2) {
|
|
$12 = HEAP32[$0 + 28 >> 2];
|
|
$20 = HEAP32[$0 + 24 >> 2];
|
|
HEAP32[$15 + 24 >> 2] = $20;
|
|
HEAP32[$15 + 28 >> 2] = $12;
|
|
$20 = HEAP32[$0 + 20 >> 2];
|
|
$12 = HEAP32[$0 + 16 >> 2];
|
|
HEAP32[$15 + 16 >> 2] = $12;
|
|
HEAP32[$15 + 20 >> 2] = $20;
|
|
$13 = HEAP32[$0 + 4576 >> 2];
|
|
}
|
|
$9 = 0;
|
|
label$12 : {
|
|
if (($8 | 0) > 0) {
|
|
$11 = ($6 | 0) != 2;
|
|
$23 = $15;
|
|
break label$12;
|
|
}
|
|
HEAP32[$1 + 24 >> 2] = 10;
|
|
$35 = HEAP32[$1 + 36 >> 2];
|
|
HEAP32[$1 + 36 >> 2] = 0;
|
|
break label$9;
|
|
}
|
|
label$14 : {
|
|
while (1) {
|
|
$8 = Math_imul($9, 10064) + $0 | 0;
|
|
$10 = silk_init_encoder($8, HEAP32[$8 + 5092 >> 2]);
|
|
if (!$11) {
|
|
$12 = HEAP32[$15 + 20 >> 2];
|
|
$20 = HEAP32[$15 + 16 >> 2];
|
|
HEAP32[$8 + 16 >> 2] = $20;
|
|
HEAP32[$8 + 20 >> 2] = $12;
|
|
$20 = HEAP32[$23 + 28 >> 2];
|
|
$12 = HEAP32[$23 + 24 >> 2];
|
|
HEAP32[$8 + 24 >> 2] = $12;
|
|
HEAP32[$8 + 28 >> 2] = $20;
|
|
HEAP32[$8 + 32 >> 2] = $13;
|
|
}
|
|
if (!$10) {
|
|
$8 = HEAP32[$1 + 4 >> 2];
|
|
$9 = $9 + 1 | 0;
|
|
if (($8 | 0) <= ($9 | 0)) {
|
|
break label$14;
|
|
}
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
celt_fatal(17522, 17507, 222);
|
|
abort();
|
|
}
|
|
$24 = HEAP32[$1 + 24 >> 2];
|
|
HEAP32[$1 + 24 >> 2] = 10;
|
|
$35 = HEAP32[$1 + 36 >> 2];
|
|
$14 = 0;
|
|
HEAP32[$1 + 36 >> 2] = 0;
|
|
if (($8 | 0) < 1) {
|
|
break label$9;
|
|
}
|
|
while (1) {
|
|
$9 = Math_imul($14, 10064) + $0 | 0;
|
|
HEAP32[$9 + 4680 >> 2] = 1;
|
|
HEAP32[$9 + 4668 >> 2] = 0;
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$14 = 0;
|
|
break label$9;
|
|
}
|
|
if ((Math_imul($9, $18) | 0) != ($10 | 0) | ($3 | 0) < 0) {
|
|
break label$7;
|
|
}
|
|
$9 = Math_imul($9, $24);
|
|
$24 = 0;
|
|
if ((Math_imul($3, 1e3) | 0) > ($9 | 0)) {
|
|
break label$8;
|
|
}
|
|
}
|
|
label$19 : {
|
|
label$20 : {
|
|
label$21 : {
|
|
label$22 : {
|
|
if (($8 | 0) < 1) {
|
|
break label$22;
|
|
}
|
|
$11 = $21 ^ -1;
|
|
$10 = 0;
|
|
while (1) {
|
|
$8 = 0;
|
|
$9 = Math_imul($10, 10064) + $0 | 0;
|
|
$8 = ($10 | 0) == 1 ? HEAP32[$0 + 4576 >> 2] : $8;
|
|
$14 = silk_control_encoder($9, $1, HEAP32[$0 + 20208 >> 2], $10, $8);
|
|
if ($14) {
|
|
break label$20;
|
|
}
|
|
label$26 : {
|
|
if (!HEAP32[$9 + 4664 >> 2] & $11) {
|
|
break label$26;
|
|
}
|
|
$8 = 0;
|
|
if (HEAP32[$0 + 5744 >> 2] < 1) {
|
|
break label$26;
|
|
}
|
|
while (1) {
|
|
HEAP32[(($8 << 2) + $9 | 0) + 4724 >> 2] = 0;
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) < HEAP32[$0 + 5744 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$9 + 6080 >> 2] = HEAP32[$9 + 6076 >> 2];
|
|
$8 = HEAP32[$1 + 4 >> 2];
|
|
$10 = $10 + 1 | 0;
|
|
if (($8 | 0) > ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$14 = 0;
|
|
if (($8 | 0) != 1) {
|
|
break label$22;
|
|
}
|
|
$8 = HEAP32[$0 + 4576 >> 2];
|
|
break label$21;
|
|
}
|
|
$8 = HEAP32[$0 + 4576 >> 2];
|
|
if (($8 | 0) != HEAP32[$0 + 14640 >> 2]) {
|
|
break label$19;
|
|
}
|
|
}
|
|
$27 = ($18 | 0) > 1 ? $18 >> 1 : 1;
|
|
$39 = $27 << 1;
|
|
$40 = $27 - 1 | 0;
|
|
$41 = $0 + 10212 | 0;
|
|
$20 = $0 + 17232 | 0;
|
|
$36 = $0 + 14784 | 0;
|
|
$42 = $0 + 15164 | 0;
|
|
$43 = $0 + 5100 | 0;
|
|
$44 = $0 + 20128 | 0;
|
|
$25 = $0 + 20180 | 0;
|
|
$45 = $0 + 14788 | 0;
|
|
$29 = $0 + 20162 | 0;
|
|
$30 = $0 + 15160 | 0;
|
|
$31 = $0 + 15840 | 0;
|
|
$26 = $0 + 5096 | 0;
|
|
$28 = $0 + 5776 | 0;
|
|
$37 = Math_imul($18, 10);
|
|
$32 = Math_imul($37, $8);
|
|
$22 = $16 - (((Math_imul($32, HEAP32[$0 + 4556 >> 2]) | 0) / (Math_imul($8, 1e3) | 0) << 1) + 15 & -16) | 0;
|
|
__stack_pointer = $22;
|
|
$21 = 0;
|
|
label$28 : {
|
|
while (1) {
|
|
$10 = HEAP32[$0 + 5740 >> 2];
|
|
$8 = HEAP32[$0 + 4584 >> 2] - $10 | 0;
|
|
$11 = ($8 | 0) < ($32 | 0) ? $8 : $32;
|
|
$19 = (Math_imul($11, HEAP32[$0 + 4556 >> 2]) | 0) / (Math_imul(HEAP32[$0 + 4576 >> 2], 1e3) | 0) | 0;
|
|
label$30 : {
|
|
label$31 : {
|
|
label$32 : {
|
|
label$33 : {
|
|
label$34 : {
|
|
label$35 : {
|
|
label$36 : {
|
|
switch (HEAP32[$1 >> 2] - 1 | 0) {
|
|
case 1:
|
|
label$38 : {
|
|
switch (HEAP32[$1 + 4 >> 2] - 1 | 0) {
|
|
case 1:
|
|
$9 = HEAP32[$0 + 5748 >> 2];
|
|
$8 = 0;
|
|
$13 = ($19 | 0) < 1;
|
|
if (!$13) {
|
|
while (1) {
|
|
HEAP16[($8 << 1) + $22 >> 1] = HEAPU16[($8 << 2) + $2 >> 1];
|
|
$8 = $8 + 1 | 0;
|
|
if (($19 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!(HEAP32[$0 + 20200 >> 2] != 1 | $9)) {
|
|
memcpy($31, $28, 300);
|
|
}
|
|
$8 = silk_resampler($28, (($10 << 1) + $26 | 0) + 4 | 0, $22, $19);
|
|
HEAP32[$0 + 5740 >> 2] = HEAP32[$0 + 5740 >> 2] + $11;
|
|
$9 = HEAP32[$0 + 15804 >> 2];
|
|
$10 = HEAP32[$0 + 14648 >> 2] - $9 | 0;
|
|
$11 = Math_imul(HEAP32[$0 + 14640 >> 2], $37);
|
|
$10 = ($10 | 0) < ($11 | 0) ? $10 : $11;
|
|
$11 = $8 + $14 | 0;
|
|
$8 = 0;
|
|
if (!$13) {
|
|
while (1) {
|
|
HEAP16[($8 << 1) + $22 >> 1] = HEAPU16[($8 << 2 | 2) + $2 >> 1];
|
|
$8 = $8 + 1 | 0;
|
|
if (($19 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = silk_resampler($31, (($9 << 1) + $30 | 0) + 4 | 0, $22, $19);
|
|
HEAP32[$0 + 15804 >> 2] = HEAP32[$0 + 15804 >> 2] + $10;
|
|
$14 = $8 + $11 | 0;
|
|
$8 = HEAP32[$0 + 5740 >> 2];
|
|
break label$35;
|
|
case 0:
|
|
break label$38;
|
|
default:
|
|
break label$34;
|
|
}
|
|
}
|
|
$8 = 0;
|
|
if (($19 | 0) >= 1) {
|
|
while (1) {
|
|
$9 = $8 << 2;
|
|
$9 = HEAP16[($9 | 2) + $2 >> 1] + HEAP16[$2 + $9 >> 1] | 0;
|
|
HEAP16[($8 << 1) + $22 >> 1] = ($9 >>> 1 | 0) + ($9 & 1);
|
|
$8 = $8 + 1 | 0;
|
|
if (($19 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$14 = silk_resampler($28, (($10 << 1) + $26 | 0) + 4 | 0, $22, $19) + $14 | 0;
|
|
label$47 : {
|
|
if (HEAP32[$0 + 5748 >> 2] | HEAP32[$0 + 20200 >> 2] != 2) {
|
|
break label$47;
|
|
}
|
|
$14 = silk_resampler($31, ((HEAP32[$0 + 15804 >> 2] << 1) + $30 | 0) + 4 | 0, $22, $19) + $14 | 0;
|
|
$13 = HEAP32[$0 + 4584 >> 2];
|
|
if (($13 | 0) < 1) {
|
|
break label$47;
|
|
}
|
|
$17 = HEAP32[$0 + 15804 >> 2];
|
|
$18 = HEAP32[$0 + 5740 >> 2];
|
|
$8 = 0;
|
|
while (1) {
|
|
$9 = $8 + 2 | 0;
|
|
$10 = ($18 + $9 << 1) + $26 | 0;
|
|
HEAP16[$10 >> 1] = HEAP16[($9 + $17 << 1) + $30 >> 1] + HEAP16[$10 >> 1] >>> 1;
|
|
$8 = $8 + 1 | 0;
|
|
if (($13 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = HEAP32[$0 + 5740 >> 2] + $11 | 0;
|
|
HEAP32[$0 + 5740 >> 2] = $8;
|
|
break label$35;
|
|
case 0:
|
|
break label$36;
|
|
default:
|
|
break label$34;
|
|
}
|
|
}
|
|
if (HEAP32[$1 + 4 >> 2] != 1) {
|
|
break label$34;
|
|
}
|
|
$9 = silk_resampler($28, (($10 << 1) + $26 | 0) + 4 | 0, memcpy($22, $2, $19 << 1), $19);
|
|
$8 = HEAP32[$0 + 5740 >> 2] + $11 | 0;
|
|
HEAP32[$0 + 5740 >> 2] = $8;
|
|
$14 = $9 + $14 | 0;
|
|
}
|
|
$46 = HEAP32[$1 >> 2];
|
|
HEAP32[$0 + 20208 >> 2] = 0;
|
|
$9 = HEAP32[$0 + 4584 >> 2];
|
|
$12 = 0;
|
|
if (($9 | 0) > ($8 | 0)) {
|
|
break label$28;
|
|
}
|
|
if (($8 | 0) != ($9 | 0)) {
|
|
break label$33;
|
|
}
|
|
$8 = HEAP32[$1 + 4 >> 2];
|
|
if (HEAP32[$0 + 15804 >> 2] != HEAP32[$0 + 14648 >> 2] ? ($8 | 0) != 1 : 0) {
|
|
break label$32;
|
|
}
|
|
if (HEAP32[$0 + 5748 >> 2] | $6) {
|
|
break label$30;
|
|
}
|
|
$17 = 0;
|
|
HEAP16[$15 + 14 >> 1] = 0;
|
|
HEAP8[$15 + 14 | 0] = 0 - (256 >>> Math_imul(HEAP32[$0 + 5744 >> 2] + 1 | 0, $8) | 0);
|
|
ec_enc_icdf($4, 0, $15 + 14 | 0, 8);
|
|
$11 = HEAP32[$1 + 4 >> 2];
|
|
if (($11 | 0) <= 0) {
|
|
break label$31;
|
|
}
|
|
while (1) {
|
|
$8 = 0;
|
|
$9 = 0;
|
|
$13 = Math_imul($17, 10064) + $0 | 0;
|
|
$10 = HEAP32[$13 + 5744 >> 2];
|
|
if (($10 | 0) >= 1) {
|
|
while (1) {
|
|
$9 = HEAP32[(($8 << 2) + $13 | 0) + 4724 >> 2] << $8 | $9;
|
|
$8 = $8 + 1 | 0;
|
|
if (($10 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP8[$13 + 4723 | 0] = ($9 | 0) > 0;
|
|
if (!(!$9 | ($10 | 0) < 2)) {
|
|
ec_enc_icdf($4, $9 - 1 | 0, HEAP32[($10 << 2) + 5808 >> 2], 8);
|
|
$11 = HEAP32[$1 + 4 >> 2];
|
|
}
|
|
$17 = $17 + 1 | 0;
|
|
if (($17 | 0) < ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$31;
|
|
}
|
|
celt_fatal(17672, 17507, 320);
|
|
abort();
|
|
}
|
|
celt_fatal(17758, 17507, 336);
|
|
abort();
|
|
}
|
|
celt_fatal(17857, 17507, 337);
|
|
abort();
|
|
}
|
|
$10 = 0;
|
|
if (HEAP32[$0 + 5744 >> 2] > 0) {
|
|
while (1) {
|
|
if (($11 | 0) >= 1) {
|
|
$17 = $10 - 1 | 0;
|
|
$33 = $10 + $25 | 0;
|
|
$13 = $10 << 2;
|
|
$18 = $45 + $13 | 0;
|
|
$16 = Math_imul($10, 6) + $29 | 0;
|
|
$9 = 0;
|
|
while (1) {
|
|
$8 = Math_imul($9, 10064) + $0 | 0;
|
|
if (HEAP32[($13 + $8 | 0) + 4724 >> 2]) {
|
|
label$59 : {
|
|
if (($11 | 0) != 2 | $9) {
|
|
break label$59;
|
|
}
|
|
silk_stereo_encode_pred($4, $16);
|
|
if (HEAP32[$18 >> 2]) {
|
|
break label$59;
|
|
}
|
|
silk_stereo_encode_mid_only($4, HEAP8[$33 | 0]);
|
|
}
|
|
$12 = $8;
|
|
$23 = $4;
|
|
$47 = $10;
|
|
label$60 : {
|
|
if ($10) {
|
|
$11 = 2;
|
|
if (HEAP32[(($17 << 2) + $8 | 0) + 4724 >> 2]) {
|
|
break label$60;
|
|
}
|
|
}
|
|
$11 = 0;
|
|
}
|
|
silk_encode_indices($12, $23, $47, 1, $11);
|
|
$11 = Math_imul($10, 36) + $8 | 0;
|
|
silk_encode_pulses($4, HEAP8[$11 + 6129 | 0], HEAP8[$11 + 6130 | 0], (Math_imul($10, 320) + $8 | 0) + 6208 | 0, HEAP32[$8 + 4584 >> 2]);
|
|
$11 = HEAP32[$1 + 4 >> 2];
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($11 | 0) > ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$10 = $10 + 1 | 0;
|
|
if (($10 | 0) < HEAP32[$0 + 5744 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = 0;
|
|
if (($11 | 0) > 0) {
|
|
while (1) {
|
|
$9 = Math_imul($8, 10064) + $0 | 0;
|
|
HEAP32[$9 + 4724 >> 2] = 0;
|
|
HEAP32[$9 + 4728 >> 2] = 0;
|
|
HEAP32[$9 + 4732 >> 2] = 0;
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) < HEAP32[$1 + 4 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 20184 >> 2] = (HEAP32[$4 + 20 >> 2] + Math_clz32(HEAP32[$4 + 28 >> 2]) | 0) - 32;
|
|
}
|
|
silk_HP_variable_cutoff($0);
|
|
$8 = HEAP32[$1 + 28 >> 2];
|
|
$10 = HEAP32[$1 + 24 >> 2];
|
|
$9 = (Math_imul($8, $10) | 0) / 1e3 | 0;
|
|
$9 = $6 ? $9 : $9 - HEAP32[$0 + 20184 >> 2] | 0;
|
|
$11 = ($9 | 0) / HEAP32[$0 + 5744 >> 2] | 0;
|
|
$9 = Math_imul($11 << 16 >> 16, ($10 | 0) == 10 ? 100 : 50) - (HEAP32[$0 + 20188 >> 2] << 1) | 0;
|
|
label$65 : {
|
|
if ($6) {
|
|
break label$65;
|
|
}
|
|
$10 = HEAP32[$0 + 5748 >> 2];
|
|
if (($10 | 0) < 1) {
|
|
break label$65;
|
|
}
|
|
$9 = ((HEAP32[$0 + 20184 >> 2] + ((Math_imul($10, $11) - HEAP32[$4 + 20 >> 2] | 0) - Math_clz32(HEAP32[$4 + 28 >> 2]) | 0) << 1) + $9 | 0) - -64 | 0;
|
|
}
|
|
label$66 : {
|
|
if (($8 | 0) >= 5001) {
|
|
$16 = $8;
|
|
if (($8 | 0) < ($9 | 0)) {
|
|
break label$66;
|
|
}
|
|
$16 = ($9 | 0) > 5e3 ? $9 : 5e3;
|
|
break label$66;
|
|
}
|
|
$16 = 5e3;
|
|
if (($9 | 0) > 5e3) {
|
|
break label$66;
|
|
}
|
|
$16 = ($8 | 0) > ($9 | 0) ? $8 : $9;
|
|
}
|
|
label$68 : {
|
|
if (HEAP32[$1 + 4 >> 2] == 2) {
|
|
$8 = HEAP32[$0 + 5748 >> 2];
|
|
silk_stereo_LR_to_MS($44, $43, $42, Math_imul($8, 6) + $29 | 0, $8 + $25 | 0, $15 + 16 | 0, $16, HEAP32[$0 + 4532 >> 2], HEAP32[$1 + 60 >> 2], HEAP32[$0 + 4576 >> 2], HEAP32[$0 + 4584 >> 2]);
|
|
$8 = HEAP32[$0 + 5748 >> 2];
|
|
label$70 : {
|
|
if (!HEAPU8[$25 + $8 | 0]) {
|
|
if (HEAP32[$0 + 20212 >> 2] == 1) {
|
|
$12 = $20;
|
|
HEAP32[$12 >> 2] = 0;
|
|
HEAP32[$12 + 4 >> 2] = 0;
|
|
HEAP32[$12 + 8 >> 2] = 0;
|
|
HEAP32[$0 + 10080 >> 2] = 0;
|
|
HEAP32[$0 + 10084 >> 2] = 0;
|
|
memset($41, 0, 4384);
|
|
HEAP8[$0 + 17232 | 0] = 10;
|
|
HEAP32[$0 + 14540 >> 2] = 100;
|
|
HEAP32[$0 + 14608 >> 2] = 100;
|
|
HEAP8[$0 + 14605 | 0] = 0;
|
|
HEAP32[$0 + 14728 >> 2] = 1;
|
|
HEAP32[$0 + 14556 >> 2] = 65536;
|
|
}
|
|
silk_encode_do_VAD_FLP($34, $7);
|
|
break label$70;
|
|
}
|
|
HEAP8[$8 + $36 | 0] = 0;
|
|
}
|
|
if ($6) {
|
|
break label$68;
|
|
}
|
|
silk_stereo_encode_pred($4, Math_imul(HEAP32[$0 + 5748 >> 2], 6) + $29 | 0);
|
|
$8 = HEAP32[$0 + 5748 >> 2];
|
|
if (HEAPU8[$36 + $8 | 0]) {
|
|
break label$68;
|
|
}
|
|
silk_stereo_encode_mid_only($4, HEAP8[$8 + $25 | 0]);
|
|
break label$68;
|
|
}
|
|
HEAP32[$0 + 5096 >> 2] = HEAP32[$0 + 20132 >> 2];
|
|
$12 = (HEAP32[$0 + 4584 >> 2] << 1) + $26 | 0;
|
|
HEAP32[$0 + 20132 >> 2] = HEAPU16[$12 >> 1] | HEAPU16[$12 + 2 >> 1] << 16;
|
|
}
|
|
$33 = Math_imul($19, $46);
|
|
silk_encode_do_VAD_FLP($0, $7);
|
|
$13 = HEAP32[$1 + 4 >> 2];
|
|
if (($13 | 0) >= 1) {
|
|
$18 = !$21 & ($27 | 0) == 2;
|
|
$8 = 0;
|
|
while (1) {
|
|
$10 = HEAP32[$1 + 56 >> 2];
|
|
$11 = (Math_imul($10, 3) | 0) / 5 | 0;
|
|
label$75 : {
|
|
if ($18) {
|
|
break label$75;
|
|
}
|
|
$11 = $10;
|
|
if (($27 | 0) != 3) {
|
|
break label$75;
|
|
}
|
|
$11 = ($10 << 1) / 5 | 0;
|
|
if (!$21) {
|
|
break label$75;
|
|
}
|
|
$11 = $10;
|
|
if (($21 | 0) != 1) {
|
|
break label$75;
|
|
}
|
|
$11 = (Math_imul($10, 3) | 0) / 4 | 0;
|
|
}
|
|
$17 = ($21 | 0) == ($40 | 0) & HEAP32[$1 + 52 >> 2] != 0;
|
|
label$76 : {
|
|
if (($13 | 0) == 1) {
|
|
$9 = $16;
|
|
break label$76;
|
|
}
|
|
$9 = HEAP32[($15 + 16 | 0) + ($8 << 2) >> 2];
|
|
if (HEAP32[$15 + 20 >> 2] < 1 | $8) {
|
|
break label$76;
|
|
}
|
|
$11 = $11 - (($10 | 0) / ($39 | 0) | 0) | 0;
|
|
$17 = 0;
|
|
}
|
|
if (($9 | 0) >= 1) {
|
|
$10 = Math_imul($8, 10064) + $0 | 0;
|
|
silk_control_SNR($10, $9);
|
|
$12 = $5;
|
|
$23 = $4;
|
|
$9 = 0;
|
|
label$79 : {
|
|
if (HEAP32[$0 + 5748 >> 2] <= ($8 | 0)) {
|
|
break label$79;
|
|
}
|
|
if ($8) {
|
|
$9 = 1;
|
|
if (HEAP32[$0 + 20212 >> 2]) {
|
|
break label$79;
|
|
}
|
|
}
|
|
$9 = 2;
|
|
}
|
|
$14 = silk_encode_frame_FLP($10, $12, $23, $9, $11, $17);
|
|
$13 = HEAP32[$1 + 4 >> 2];
|
|
}
|
|
$9 = Math_imul($8, 10064) + $0 | 0;
|
|
HEAP32[$9 + 5740 >> 2] = 0;
|
|
HEAP32[$9 + 4668 >> 2] = 0;
|
|
HEAP32[$9 + 5748 >> 2] = HEAP32[$9 + 5748 >> 2] + 1;
|
|
$8 = $8 + 1 | 0;
|
|
if (($13 | 0) > ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$18 = $33 << 1;
|
|
$3 = $3 - $19 | 0;
|
|
$16 = HEAP32[$0 + 5748 >> 2];
|
|
HEAP32[$0 + 20212 >> 2] = HEAP8[($25 + $16 | 0) - 1 | 0];
|
|
label$81 : {
|
|
if (HEAP32[$0 + 5744 >> 2] != ($16 | 0) | HEAP32[$5 >> 2] < 1) {
|
|
break label$81;
|
|
}
|
|
$17 = 0;
|
|
$8 = 0;
|
|
if (($13 | 0) >= 1) {
|
|
while (1) {
|
|
$9 = $8 << 1;
|
|
$8 = 0;
|
|
$10 = Math_imul($17, 10064) + $0 | 0;
|
|
$11 = HEAP32[$10 + 5744 >> 2];
|
|
if (($11 | 0) >= 1) {
|
|
while (1) {
|
|
$9 = (HEAP8[($8 + $10 | 0) + 4720 | 0] | $9) << 1;
|
|
$8 = $8 + 1 | 0;
|
|
if (($11 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = HEAP8[$10 + 4723 | 0] | $9;
|
|
$17 = $17 + 1 | 0;
|
|
if (($17 | 0) != ($13 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$6) {
|
|
ec_enc_patch_initial_bits($4, $8, Math_imul($16 + 1 | 0, $13));
|
|
}
|
|
if (!(!HEAP32[$0 + 6080 >> 2] | (HEAP32[$0 + 16144 >> 2] ? 0 : HEAP32[$1 + 4 >> 2] != 1))) {
|
|
HEAP32[$5 >> 2] = 0;
|
|
}
|
|
$9 = HEAP32[$1 + 24 >> 2];
|
|
$8 = (HEAP32[$0 + 20188 >> 2] + (HEAP32[$5 >> 2] << 3) | 0) + ((Math_imul($9, HEAP32[$1 + 28 >> 2]) | 0) / -1e3 | 0) | 0;
|
|
$8 = ($8 | 0) > 0 ? $8 : 0;
|
|
HEAP32[$0 + 20188 >> 2] = ($8 | 0) < 1e4 ? $8 : 1e4;
|
|
$8 = HEAP32[$0 + 20204 >> 2];
|
|
if (HEAP32[$0 + 4532 >> 2] < ((Math_imul($8 << 16 >> 16, 3188) >> 16) + 13 | 0)) {
|
|
HEAP32[$0 + 20204 >> 2] = 0;
|
|
HEAP32[$0 + 20208 >> 2] = 1;
|
|
break label$81;
|
|
}
|
|
HEAP32[$0 + 20208 >> 2] = 0;
|
|
HEAP32[$0 + 20204 >> 2] = $8 + $9;
|
|
}
|
|
$2 = $2 + $18 | 0;
|
|
$21 = $21 + 1 | 0;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = HEAP32[$0 + 20208 >> 2];
|
|
}
|
|
$10 = HEAP32[$1 + 4 >> 2];
|
|
HEAP32[$0 + 20200 >> 2] = $10;
|
|
$8 = $12;
|
|
HEAP32[$1 + 76 >> 2] = $8;
|
|
$8 = HEAP32[$0 + 4576 >> 2];
|
|
$38 = ($8 | 0) == 16 ? !HEAP32[$0 + 28 >> 2] : $38;
|
|
HEAP32[$1 + 80 >> 2] = $38;
|
|
HEAP32[$1 + 72 >> 2] = Math_imul($8 << 16 >> 16, 1e3);
|
|
$8 = 0;
|
|
$8 = HEAP32[$1 + 60 >> 2] ? $8 : HEAP16[$0 + 20156 >> 1];
|
|
HEAP32[$1 + 84 >> 2] = $8;
|
|
label$93 : {
|
|
if (!$6) {
|
|
break label$93;
|
|
}
|
|
HEAP32[$1 + 36 >> 2] = $35;
|
|
HEAP32[$1 + 24 >> 2] = $24;
|
|
if (($10 | 0) < 1) {
|
|
break label$93;
|
|
}
|
|
$8 = 0;
|
|
while (1) {
|
|
$9 = Math_imul($8, 10064) + $0 | 0;
|
|
HEAP32[$9 + 4680 >> 2] = 0;
|
|
HEAP32[$9 + 4668 >> 2] = 0;
|
|
$8 = $8 + 1 | 0;
|
|
if (($10 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = HEAP8[$0 + 4765 | 0];
|
|
HEAP32[$1 + 92 >> 2] = $8;
|
|
HEAP32[$1 + 96 >> 2] = HEAP16[(($8 << 1 & -4) + (HEAP8[$0 + 4766 | 0] << 1) | 0) + 5840 >> 1];
|
|
}
|
|
__stack_pointer = $15 + 32 | 0;
|
|
return $14;
|
|
}
|
|
celt_fatal(17545, 17507, 262);
|
|
abort();
|
|
}
|
|
celt_fatal(17487, 17507, 241);
|
|
abort();
|
|
}
|
|
celt_fatal(17487, 17507, 235);
|
|
abort();
|
|
}
|
|
celt_fatal(17487, 17507, 206);
|
|
abort();
|
|
}
|
|
celt_fatal(17487, 17507, 170);
|
|
abort();
|
|
}
|
|
function quant_all_bands($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22) {
|
|
var $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = Math_fround(0), $34 = Math_fround(0), $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0, $48 = Math_fround(0), $49 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $54 = 0, $55 = 0, $56 = 0, $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $62 = 0, $63 = 0, $64 = 0, $65 = 0, $66 = 0, $67 = 0, $68 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0, $73 = 0, $74 = 0, $75 = 0, $76 = 0, $77 = 0, $78 = 0, $79 = 0, $80 = 0, $81 = 0, $82 = 0, $83 = 0, $84 = 0, $85 = 0, $86 = Math_fround(0), $87 = 0, $88 = 0, $89 = 0, $90 = 0, $91 = 0, $92 = 0, $93 = 0, $94 = 0, $95 = 0, $96 = 0, $97 = 0, $98 = 0, $99 = 0, $100 = 0, $101 = 0, $102 = 0, $103 = 0, $104 = 0, $105 = 0, $106 = 0, $107 = 0, $108 = Math_fround(0);
|
|
$27 = __stack_pointer - 1568 | 0;
|
|
$25 = $27;
|
|
__stack_pointer = $25;
|
|
$28 = 1;
|
|
$37 = HEAP32[$1 + 32 >> 2];
|
|
$63 = $37 + ($2 << 1) | 0;
|
|
$41 = HEAP16[$63 >> 1] << $17;
|
|
$49 = $5 ? 2 : 1;
|
|
$31 = $25 - ((Math_imul($49, (HEAP16[((HEAP32[$1 + 8 >> 2] << 1) + $37 | 0) - 2 >> 1] << $17) - $41 | 0) << 2) + 15 & -16) | 0;
|
|
$26 = $31;
|
|
__stack_pointer = $26;
|
|
$27 = HEAP32[$1 + 8 >> 2];
|
|
$29 = HEAP16[(($27 << 1) + $37 | 0) - 2 >> 1];
|
|
$38 = $29 << $17 << 2;
|
|
$50 = !$11 & (($0 | 0) != 0 & ($5 | 0) != 0) & ($20 | 0) > 7;
|
|
$59 = $50 | !$0;
|
|
$39 = $9 ? 1 << $17 : 1;
|
|
label$1 : {
|
|
if ($50) {
|
|
$28 = HEAP16[($27 << 1) + $37 >> 1] - $29 << $17;
|
|
$32 = $26 - (($28 << 2) + 15 & -16) | 0;
|
|
$26 = $32;
|
|
__stack_pointer = $26;
|
|
break label$1;
|
|
}
|
|
$32 = $4 + $38 | 0;
|
|
}
|
|
$27 = ($28 << 2) + 15 & -16;
|
|
$64 = $26 - $27 | 0;
|
|
$26 = $64;
|
|
__stack_pointer = $26;
|
|
$65 = $26 - $27 | 0;
|
|
$26 = $65;
|
|
__stack_pointer = $26;
|
|
$66 = $26 - $27 | 0;
|
|
$26 = $66;
|
|
__stack_pointer = $26;
|
|
$67 = $26 - $27 | 0;
|
|
$26 = $67;
|
|
__stack_pointer = $26;
|
|
$60 = $26 - $27 | 0;
|
|
__stack_pointer = $60;
|
|
HEAP32[$25 + 1532 >> 2] = $16;
|
|
HEAP32[$25 + 1540 >> 2] = $7;
|
|
HEAP32[$25 + 1520 >> 2] = $12;
|
|
HEAP32[$25 + 1504 >> 2] = $0;
|
|
HEAP32[$25 + 1512 >> 2] = $1;
|
|
$27 = HEAP32[$19 >> 2];
|
|
HEAP32[$25 + 1556 >> 2] = $22;
|
|
HEAP32[$25 + 1548 >> 2] = $21;
|
|
HEAP32[$25 + 1524 >> 2] = $10;
|
|
HEAP32[$25 + 1544 >> 2] = $27;
|
|
$0 = ($39 | 0) > 1;
|
|
HEAP32[$25 + 1560 >> 2] = $0;
|
|
HEAP32[$25 + 1552 >> 2] = 0;
|
|
HEAP32[$25 + 1508 >> 2] = $59;
|
|
if (($2 | 0) < ($3 | 0)) {
|
|
$101 = $5 ? $31 : 0;
|
|
$102 = ($10 | 0) != 3 | $0;
|
|
$45 = $16 + 28 | 0;
|
|
$46 = $16 + 8 | 0;
|
|
$103 = $59 ^ 1;
|
|
$21 = $49 - 1 | 0;
|
|
$68 = $2 + 2 | 0;
|
|
$51 = $2 + 1 | 0;
|
|
$69 = $3 - 1 | 0;
|
|
$27 = 0 - $41 << 2;
|
|
$38 = ($31 + $38 | 0) - ($41 << 2) | 0;
|
|
$104 = $27 + $38 | 0;
|
|
$42 = $27 + $31 | 0;
|
|
$70 = -1 << $39 ^ -1;
|
|
$52 = $2;
|
|
$10 = 1;
|
|
while (1) {
|
|
$22 = $52;
|
|
HEAP32[$25 + 1516 >> 2] = $22;
|
|
label$5 : {
|
|
label$6 : {
|
|
$52 = $22 + 1 | 0;
|
|
$35 = ($22 << 1) + $37 | 0;
|
|
$0 = HEAP16[$35 >> 1] << $17;
|
|
$27 = (HEAP16[($52 << 1) + $37 >> 1] << $17) - $0 | 0;
|
|
if (($27 | 0) > 0) {
|
|
$61 = ec_tell_frac($16);
|
|
$26 = $14 - $61 | 0;
|
|
HEAP32[$25 + 1536 >> 2] = $26 - 1;
|
|
$71 = $15 - (($2 | 0) == ($22 | 0) ? 0 : $61) | 0;
|
|
$36 = 0;
|
|
label$8 : {
|
|
if (($18 | 0) <= ($22 | 0)) {
|
|
break label$8;
|
|
}
|
|
$15 = $18 - $22 | 0;
|
|
$15 = HEAP32[($22 << 2) + $8 >> 2] + (($71 | 0) / ((($15 | 0) < 3 ? $15 : 3) | 0) | 0) | 0;
|
|
$15 = ($15 | 0) > ($26 | 0) ? $26 : $15;
|
|
$36 = 16383;
|
|
if (($15 | 0) > 16383) {
|
|
break label$8;
|
|
}
|
|
$36 = ($15 | 0) > 0 ? $15 : 0;
|
|
}
|
|
$15 = $0 << 2;
|
|
$40 = !$59 | (((HEAP16[$35 >> 1] << $17) - $27 | 0) < HEAP16[$63 >> 1] << $17 ? ($22 | 0) != ($51 | 0) : 0) ? $40 : $10 ? $22 : $40 ? $40 : $22;
|
|
$0 = $5 + $15 | 0;
|
|
$72 = ($22 | 0) != ($51 | 0);
|
|
label$11 : {
|
|
if ($72) {
|
|
break label$11;
|
|
}
|
|
$26 = HEAP32[$1 + 32 >> 2];
|
|
$28 = HEAP16[$26 + ($51 << 1) >> 1];
|
|
$10 = $28 - HEAP16[($2 << 1) + $26 >> 1] << $17;
|
|
$9 = $10 << 2;
|
|
$26 = HEAP16[($68 << 1) + $26 >> 1] - $28 << $17;
|
|
$28 = ($10 << 1) - $26 << 2;
|
|
$26 = $26 - $10 << 2;
|
|
memcpy($31 + $9 | 0, $31 + $28 | 0, $26);
|
|
if (!$11) {
|
|
break label$11;
|
|
}
|
|
memcpy($9 + $38 | 0, $28 + $38 | 0, $26);
|
|
}
|
|
$43 = $5 ? $0 : 0;
|
|
$20 = $4 + $15 | 0;
|
|
$62 = $22 << 2;
|
|
$15 = HEAP32[$62 + $13 >> 2];
|
|
HEAP32[$25 + 1528 >> 2] = $15;
|
|
$29 = HEAP32[$1 + 12 >> 2] > ($22 | 0);
|
|
$32 = $29 ? $32 : 0;
|
|
$44 = ($22 | 0) == ($69 | 0);
|
|
$47 = $44 ? 0 : $32;
|
|
$30 = -1;
|
|
label$12 : {
|
|
if (!$40) {
|
|
$0 = $70;
|
|
$26 = $0;
|
|
break label$12;
|
|
}
|
|
$0 = $70;
|
|
$26 = $0;
|
|
if (!(($15 | 0) < 0 | $102)) {
|
|
break label$12;
|
|
}
|
|
$15 = ((HEAP16[($40 << 1) + $37 >> 1] << $17) - $41 | 0) - $27 | 0;
|
|
$30 = ($15 | 0) > 0 ? $15 : 0;
|
|
$0 = $41 + $30 | 0;
|
|
$15 = $40;
|
|
while (1) {
|
|
$26 = $15;
|
|
$15 = $15 - 1 | 0;
|
|
if (HEAP16[($15 << 1) + $37 >> 1] << $17 > ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$9 = $0 + $27 | 0;
|
|
$10 = $40 - 1 | 0;
|
|
$28 = (($22 | 0) < ($40 | 0) ? $40 : $22) - 1 | 0;
|
|
while (1) {
|
|
label$16 : {
|
|
$0 = $10;
|
|
if (($28 | 0) == ($0 | 0)) {
|
|
$0 = $28;
|
|
break label$16;
|
|
}
|
|
$10 = $0 + 1 | 0;
|
|
if (HEAP16[($10 << 1) + $37 >> 1] << $17 < ($9 | 0)) {
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
$28 = ($0 | 0) < ($26 | 0) ? $15 : $0;
|
|
$0 = 0;
|
|
$26 = 0;
|
|
while (1) {
|
|
$10 = Math_imul($15, $49);
|
|
$0 = HEAPU8[$10 + $6 | 0] | $0;
|
|
$26 = HEAPU8[($10 + $21 | 0) + $6 | 0] | $26;
|
|
$10 = ($15 | 0) != ($28 | 0);
|
|
$15 = $15 + 1 | 0;
|
|
if ($10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$32 = $50 ? $32 : $47;
|
|
$20 = $29 ? $20 : $31;
|
|
$9 = $29 ? $43 : $101;
|
|
if (!$11) {
|
|
break label$6;
|
|
}
|
|
if (!(($12 | 0) != ($22 | 0) | $103)) {
|
|
$15 = HEAP16[$35 >> 1] << $17;
|
|
if (($41 | 0) >= ($15 | 0)) {
|
|
break label$6;
|
|
}
|
|
$15 = $15 - $41 | 0;
|
|
$29 = ($15 | 0) > 1 ? $15 : 1;
|
|
$15 = 0;
|
|
while (1) {
|
|
$10 = $15 << 2;
|
|
$28 = $31 + $10 | 0;
|
|
HEAPF32[$28 >> 2] = Math_fround(HEAPF32[$28 >> 2] + HEAPF32[$10 + $38 >> 2]) * Math_fround(.5);
|
|
$15 = $15 + 1 | 0;
|
|
if (($29 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$6;
|
|
}
|
|
if (($12 | 0) == ($22 | 0)) {
|
|
break label$6;
|
|
}
|
|
$10 = $30 << 2;
|
|
$28 = ($30 | 0) == -1;
|
|
$29 = $28 ? 0 : $31 + $10 | 0;
|
|
$15 = $36 >>> 1 | 0;
|
|
label$21 : {
|
|
if (($22 | 0) == ($69 | 0)) {
|
|
$30 = 0;
|
|
$10 = $28 ? 0 : $10 + $38 | 0;
|
|
$20 = quant_band($25 + 1504 | 0, $20, $27, $15, $39, $29, $17, 0, Math_fround(1), $32, $0);
|
|
break label$21;
|
|
}
|
|
$10 = $28 ? 0 : $10 + $38 | 0;
|
|
$20 = quant_band($25 + 1504 | 0, $20, $27, $15, $39, $29, $17, (HEAP16[$35 >> 1] << $17 << 2) + $42 | 0, Math_fround(1), $32, $0);
|
|
$30 = (HEAP16[$35 >> 1] << $17 << 2) + $104 | 0;
|
|
}
|
|
$15 = quant_band($25 + 1504 | 0, $9, $27, $15, $39, $10, $17, $30, Math_fround(1), $32, $26);
|
|
break label$5;
|
|
}
|
|
celt_fatal(41890, 41800, 1495);
|
|
abort();
|
|
}
|
|
label$23 : {
|
|
if ($9) {
|
|
if (!($50 ^ 1 | ($12 | 0) <= ($22 | 0))) {
|
|
$33 = HEAPF32[$7 + $62 >> 2];
|
|
$34 = HEAPF32[(HEAP32[$1 + 8 >> 2] + $22 << 2) + $7 >> 2];
|
|
$73 = HEAP32[$16 + 4 >> 2];
|
|
$74 = HEAP32[$16 >> 2];
|
|
$24 = $46;
|
|
$23 = HEAP32[$24 + 8 >> 2];
|
|
$15 = HEAP32[$24 + 12 >> 2];
|
|
$10 = $23;
|
|
$75 = $25 + 1496 | 0;
|
|
$23 = $75;
|
|
HEAP32[$23 >> 2] = $10;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$15 = HEAP32[$24 >> 2];
|
|
$10 = $15;
|
|
$15 = $25;
|
|
HEAP32[$15 + 1488 >> 2] = $10;
|
|
HEAP32[$15 + 1492 >> 2] = $23;
|
|
$47 = HEAP32[$16 + 24 >> 2];
|
|
$76 = $15 + 1480 | 0;
|
|
HEAP32[$76 >> 2] = HEAP32[$45 + 16 >> 2];
|
|
$77 = $15 + 1472 | 0;
|
|
$24 = $45;
|
|
$23 = HEAP32[$24 + 8 >> 2];
|
|
$15 = HEAP32[$24 + 12 >> 2];
|
|
$10 = $23;
|
|
$23 = $77;
|
|
HEAP32[$23 >> 2] = $10;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$15 = HEAP32[$24 >> 2];
|
|
$10 = $15;
|
|
$15 = $25;
|
|
HEAP32[$15 + 1464 >> 2] = $10;
|
|
HEAP32[$15 + 1468 >> 2] = $23;
|
|
$78 = $15 + 1408 | 0;
|
|
$53 = $15 + 1560 | 0;
|
|
HEAP32[$78 >> 2] = HEAP32[$53 >> 2];
|
|
$79 = $15 + 1400 | 0;
|
|
$43 = $15 + 1552 | 0;
|
|
$24 = $43;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$10 = $23;
|
|
$23 = $79;
|
|
HEAP32[$23 >> 2] = $10;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$54 = $25 + 1544 | 0;
|
|
$24 = $54;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$10 = $15;
|
|
$80 = $25 + 1392 | 0;
|
|
$15 = $80;
|
|
HEAP32[$15 >> 2] = $10;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$55 = $25 + 1536 | 0;
|
|
$24 = $55;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$10 = $23;
|
|
$81 = $25 + 1384 | 0;
|
|
$23 = $81;
|
|
HEAP32[$23 >> 2] = $10;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$56 = $25 + 1528 | 0;
|
|
$24 = $56;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$10 = $15;
|
|
$82 = $25 + 1376 | 0;
|
|
$15 = $82;
|
|
HEAP32[$15 >> 2] = $10;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$57 = $25 + 1520 | 0;
|
|
$24 = $57;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$10 = $23;
|
|
$83 = $25 + 1368 | 0;
|
|
$23 = $83;
|
|
HEAP32[$23 >> 2] = $10;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$58 = $25 + 1512 | 0;
|
|
$24 = $58;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$10 = $15;
|
|
$84 = $25 + 1360 | 0;
|
|
$15 = $84;
|
|
HEAP32[$15 >> 2] = $10;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $25;
|
|
$23 = HEAP32[$24 + 1504 >> 2];
|
|
$15 = HEAP32[$24 + 1508 >> 2];
|
|
$10 = $23;
|
|
$23 = $24;
|
|
HEAP32[$23 + 1352 >> 2] = $10;
|
|
HEAP32[$23 + 1356 >> 2] = $15;
|
|
$11 = $27 << 2;
|
|
$10 = memcpy($64, $20, $11);
|
|
$28 = memcpy($65, $9, $11);
|
|
HEAP32[$43 >> 2] = -1;
|
|
$15 = 0;
|
|
$85 = $0 | $26;
|
|
$0 = 0;
|
|
$48 = Math_fround(($33 < $34 ? $33 : $34) / Math_fround(3));
|
|
$86 = Math_fround($34 + $48);
|
|
$48 = Math_fround($33 + $48);
|
|
$33 = Math_fround(0);
|
|
$30 = ($30 | 0) == -1 ? 0 : ($30 << 2) + $31 | 0;
|
|
$0 = $44 ? $0 : (HEAP16[$35 >> 1] << $17 << 2) + $42 | 0;
|
|
$105 = quant_band_stereo($23 + 1504 | 0, $20, $9, $27, $36, $39, $30, $17, $0, $32, $85);
|
|
$34 = Math_fround(0);
|
|
while (1) {
|
|
$0 = $15 << 2;
|
|
$34 = Math_fround($34 + Math_fround(HEAPF32[$10 + $0 >> 2] * HEAPF32[$0 + $20 >> 2]));
|
|
$15 = $15 + 1 | 0;
|
|
if (($27 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$15 = 0;
|
|
while (1) {
|
|
$0 = $15 << 2;
|
|
$33 = Math_fround($33 + Math_fround(HEAPF32[$28 + $0 >> 2] * HEAPF32[$0 + $9 >> 2]));
|
|
$15 = $15 + 1 | 0;
|
|
if (($27 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$24 = $16;
|
|
$15 = HEAP32[$24 + 40 >> 2];
|
|
$23 = HEAP32[$24 + 44 >> 2];
|
|
$0 = $15;
|
|
$87 = $25 + 1456 | 0;
|
|
$15 = $87;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$15 = HEAP32[$24 + 36 >> 2];
|
|
$23 = HEAP32[$24 + 32 >> 2];
|
|
$0 = $23;
|
|
$88 = $25 + 1448 | 0;
|
|
$23 = $88;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$23 = HEAP32[$24 + 28 >> 2];
|
|
$15 = HEAP32[$24 + 24 >> 2];
|
|
$0 = $15;
|
|
$89 = $25 + 1440 | 0;
|
|
$15 = $89;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$15 = HEAP32[$24 + 20 >> 2];
|
|
$23 = HEAP32[$24 + 16 >> 2];
|
|
$0 = $23;
|
|
$90 = $25 + 1432 | 0;
|
|
$23 = $90;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $46;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$91 = $25 + 1424 | 0;
|
|
$15 = $91;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $16;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$26 = $23;
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$24 = $58;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$24 = $15;
|
|
$92 = $25 + 1296 | 0;
|
|
$15 = $92;
|
|
HEAP32[$15 >> 2] = $24;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $57;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$24 = $23;
|
|
$93 = $25 + 1304 | 0;
|
|
$23 = $93;
|
|
HEAP32[$23 >> 2] = $24;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $56;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$24 = $15;
|
|
$94 = $25 + 1312 | 0;
|
|
$15 = $94;
|
|
HEAP32[$15 >> 2] = $24;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $55;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$24 = $23;
|
|
$95 = $25 + 1320 | 0;
|
|
$23 = $95;
|
|
HEAP32[$23 >> 2] = $24;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $54;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$24 = $15;
|
|
$96 = $25 + 1328 | 0;
|
|
$15 = $96;
|
|
HEAP32[$15 >> 2] = $24;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $43;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$24 = $23;
|
|
$97 = $25 + 1336 | 0;
|
|
$23 = $97;
|
|
HEAP32[$23 >> 2] = $24;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$98 = $25 + 1344 | 0;
|
|
HEAP32[$98 >> 2] = HEAP32[$53 >> 2];
|
|
$23 = $25;
|
|
HEAP32[$23 + 1416 >> 2] = $26;
|
|
$15 = $0;
|
|
HEAP32[$23 + 1420 >> 2] = $15;
|
|
$24 = $23;
|
|
$15 = HEAP32[$23 + 1504 >> 2];
|
|
$23 = HEAP32[$23 + 1508 >> 2];
|
|
$0 = $15;
|
|
$15 = $24;
|
|
HEAP32[$15 + 1288 >> 2] = $0;
|
|
HEAP32[$15 + 1292 >> 2] = $23;
|
|
$106 = memcpy($66, $20, $11);
|
|
$107 = memcpy($67, $9, $11);
|
|
if (!$44) {
|
|
memcpy($60, (HEAP16[$35 >> 1] << $17 << 2) + $42 | 0, $11);
|
|
}
|
|
$99 = $47 + $74 | 0;
|
|
$100 = $73 - $47 | 0;
|
|
$29 = memcpy($25, $99, $100);
|
|
HEAP32[$16 + 4 >> 2] = $73;
|
|
HEAP32[$16 >> 2] = $74;
|
|
$24 = $75;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $46;
|
|
HEAP32[$23 + 8 >> 2] = $0;
|
|
HEAP32[$23 + 12 >> 2] = $15;
|
|
$24 = $29;
|
|
$15 = HEAP32[$24 + 1488 >> 2];
|
|
$23 = HEAP32[$24 + 1492 >> 2];
|
|
$0 = $15;
|
|
$15 = $46;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
HEAP32[$16 + 24 >> 2] = $47;
|
|
HEAP32[$45 + 16 >> 2] = HEAP32[$76 >> 2];
|
|
$24 = $77;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $45;
|
|
HEAP32[$23 + 8 >> 2] = $0;
|
|
HEAP32[$23 + 12 >> 2] = $15;
|
|
$24 = $29;
|
|
$15 = HEAP32[$24 + 1464 >> 2];
|
|
$23 = HEAP32[$24 + 1468 >> 2];
|
|
$0 = $15;
|
|
$15 = $45;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $84;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $58;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $83;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $57;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $82;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $56;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $81;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $55;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $80;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $54;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $79;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $43;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
HEAP32[$53 >> 2] = HEAP32[$78 >> 2];
|
|
$24 = $29;
|
|
$23 = HEAP32[$24 + 1352 >> 2];
|
|
$15 = HEAP32[$24 + 1356 >> 2];
|
|
$0 = $23;
|
|
$23 = $24;
|
|
HEAP32[$23 + 1504 >> 2] = $0;
|
|
HEAP32[$23 + 1508 >> 2] = $15;
|
|
$26 = memcpy($20, $10, $11);
|
|
$9 = memcpy($9, $28, $11);
|
|
if (!$72) {
|
|
$15 = HEAP32[$1 + 32 >> 2];
|
|
$20 = HEAP16[$15 + ($51 << 1) >> 1];
|
|
$0 = $20 - HEAP16[($2 << 1) + $15 >> 1] << $17;
|
|
$15 = HEAP16[($68 << 1) + $15 >> 1] - $20 << $17;
|
|
memcpy(($0 << 2) + $31 | 0, (($0 << 1) - $15 << 2) + $31 | 0, $15 - $0 << 2);
|
|
}
|
|
HEAP32[$29 + 1552 >> 2] = 1;
|
|
$15 = 0;
|
|
$0 = 0;
|
|
$34 = Math_fround($48 * $34);
|
|
$33 = Math_fround($86 * $33);
|
|
$108 = Math_fround($34 + $33);
|
|
$33 = Math_fround(0);
|
|
$0 = $44 ? $0 : (HEAP16[$35 >> 1] << $17 << 2) + $42 | 0;
|
|
$20 = quant_band_stereo($29 + 1504 | 0, $26, $9, $27, $36, $39, $30, $17, $0, $32, $85);
|
|
$34 = Math_fround(0);
|
|
while (1) {
|
|
$0 = $15 << 2;
|
|
$34 = Math_fround($34 + Math_fround(HEAPF32[$10 + $0 >> 2] * HEAPF32[$0 + $26 >> 2]));
|
|
$15 = $15 + 1 | 0;
|
|
if (($27 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$15 = 0;
|
|
while (1) {
|
|
$0 = $15 << 2;
|
|
$33 = Math_fround($33 + Math_fround(HEAPF32[$28 + $0 >> 2] * HEAPF32[$0 + $9 >> 2]));
|
|
$15 = $15 + 1 | 0;
|
|
if (($27 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!(Math_fround(Math_fround($48 * $34) + Math_fround($86 * $33)) <= $108 ^ 1)) {
|
|
$15 = HEAP32[$29 + 1416 >> 2];
|
|
$23 = HEAP32[$24 + 1420 >> 2];
|
|
$0 = $15;
|
|
$15 = $16;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $87;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $16;
|
|
HEAP32[$23 + 40 >> 2] = $0;
|
|
HEAP32[$23 + 44 >> 2] = $15;
|
|
$24 = $88;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $16;
|
|
HEAP32[$15 + 32 >> 2] = $0;
|
|
HEAP32[$15 + 36 >> 2] = $23;
|
|
$24 = $89;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $16;
|
|
HEAP32[$23 + 24 >> 2] = $0;
|
|
HEAP32[$23 + 28 >> 2] = $15;
|
|
$24 = $90;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $16;
|
|
HEAP32[$15 + 16 >> 2] = $0;
|
|
HEAP32[$15 + 20 >> 2] = $23;
|
|
$24 = $91;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $46;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $92;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $58;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $93;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $57;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $94;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $56;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $95;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $55;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
$24 = $96;
|
|
$15 = HEAP32[$24 >> 2];
|
|
$23 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $15;
|
|
$15 = $54;
|
|
HEAP32[$15 >> 2] = $0;
|
|
HEAP32[$15 + 4 >> 2] = $23;
|
|
$24 = $97;
|
|
$23 = HEAP32[$24 >> 2];
|
|
$15 = HEAP32[$24 + 4 >> 2];
|
|
$0 = $23;
|
|
$23 = $43;
|
|
HEAP32[$23 >> 2] = $0;
|
|
HEAP32[$23 + 4 >> 2] = $15;
|
|
HEAP32[$53 >> 2] = HEAP32[$98 >> 2];
|
|
$24 = $29;
|
|
$15 = HEAP32[$24 + 1288 >> 2];
|
|
$23 = HEAP32[$24 + 1292 >> 2];
|
|
$0 = $15;
|
|
$15 = $24;
|
|
HEAP32[$15 + 1504 >> 2] = $0;
|
|
HEAP32[$15 + 1508 >> 2] = $23;
|
|
memcpy($26, $106, $11);
|
|
memcpy($9, $107, $11);
|
|
if (!$44) {
|
|
memcpy((HEAP16[$35 >> 1] << $17 << 2) + $42 | 0, $60, $11);
|
|
}
|
|
memcpy($99, $29, $100);
|
|
$20 = $105;
|
|
}
|
|
$11 = 0;
|
|
break label$23;
|
|
}
|
|
$11 = 0;
|
|
HEAP32[$25 + 1552 >> 2] = 0;
|
|
$15 = 0;
|
|
$10 = ($30 | 0) == -1 ? 0 : ($30 << 2) + $31 | 0;
|
|
$15 = $44 ? $15 : (HEAP16[$35 >> 1] << $17 << 2) + $42 | 0;
|
|
$20 = quant_band_stereo($25 + 1504 | 0, $20, $9, $27, $36, $39, $10, $17, $15, $32, $0 | $26);
|
|
break label$23;
|
|
}
|
|
$11 = 0;
|
|
$15 = 0;
|
|
$10 = ($30 | 0) == -1 ? 0 : ($30 << 2) + $31 | 0;
|
|
$15 = $44 ? $15 : (HEAP16[$35 >> 1] << $17 << 2) + $42 | 0;
|
|
$20 = quant_band($25 + 1504 | 0, $20, $27, $36, $39, $10, $17, $15, Math_fround(1), $32, $0 | $26);
|
|
}
|
|
$15 = $20;
|
|
}
|
|
$0 = Math_imul($22, $49);
|
|
HEAP8[$6 + $0 | 0] = $20;
|
|
HEAP8[($0 + $21 | 0) + $6 | 0] = $15;
|
|
$15 = HEAP32[$8 + $62 >> 2];
|
|
HEAP32[$25 + 1560 >> 2] = 0;
|
|
$15 = ($61 + $71 | 0) + $15 | 0;
|
|
$10 = $27 << 3 < ($36 | 0);
|
|
if (($3 | 0) != ($52 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$27 = HEAP32[$25 + 1544 >> 2];
|
|
}
|
|
HEAP32[$19 >> 2] = $27;
|
|
__stack_pointer = $25 + 1568 | 0;
|
|
}
|
|
function silk_NSQ_c($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) {
|
|
var $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $54 = 0, $55 = 0, $56 = 0, $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $62 = 0, $63 = 0, $64 = 0, $65 = 0, $66 = 0, $67 = 0, $68 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0;
|
|
$15 = __stack_pointer;
|
|
$60 = $15;
|
|
HEAP32[$1 + 4340 >> 2] = HEAP8[$2 + 34 | 0];
|
|
$32 = HEAP32[$1 + 4328 >> 2];
|
|
$19 = HEAPU8[$2 + 31 | 0];
|
|
$23 = HEAP8[$2 + 29 | 0];
|
|
$22 = HEAP8[$2 + 30 | 0];
|
|
$18 = HEAP32[$0 + 4592 >> 2];
|
|
$17 = HEAP32[$0 + 4584 >> 2];
|
|
$16 = $18 + $17 | 0;
|
|
$34 = $15 - (($16 << 2) + 15 & -16) | 0;
|
|
$15 = $34;
|
|
__stack_pointer = $15;
|
|
$39 = $15 - (($16 << 1) + 15 & -16) | 0;
|
|
$16 = $39;
|
|
__stack_pointer = $16;
|
|
$15 = HEAP32[$0 + 4588 >> 2];
|
|
$40 = $16 - (($15 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $40;
|
|
HEAP32[$1 + 4332 >> 2] = $18;
|
|
HEAP32[$1 + 4336 >> 2] = $18;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
$16 = HEAP32[$0 + 4580 >> 2];
|
|
if (($16 | 0) >= 1) {
|
|
$30 = $13 << 16 >> 16;
|
|
$25 = HEAP16[(($23 << 1 & -4) + ($22 << 1) | 0) + 5840 >> 1];
|
|
$41 = $25 + 944 | 0;
|
|
$46 = Math_imul($30, $41 << 16 >> 16);
|
|
$47 = $25 - 944 | 0;
|
|
$61 = Math_imul(0 - ($47 << 16) >> 16, $30);
|
|
$48 = ($19 & 255) == 4;
|
|
$62 = $48 ? 3 : 1;
|
|
$63 = $25 - 80 | 0;
|
|
$64 = $1 + 3900 | 0;
|
|
$16 = $13 >>> 1 | 0;
|
|
$65 = 512 - $16 | 0;
|
|
$42 = $16 - 512 | 0;
|
|
$49 = $14 << 16 >> 16;
|
|
$43 = ($18 << 1) + $1 | 0;
|
|
$44 = Math_imul($25, $30);
|
|
$66 = ($13 | 0) < 2049;
|
|
$28 = $1 + 3840 | 0;
|
|
$67 = $28;
|
|
while (1) {
|
|
$22 = $24 << 2;
|
|
$29 = HEAP32[$22 + $8 >> 2];
|
|
HEAP32[$1 + 4348 >> 2] = 0;
|
|
$19 = 1;
|
|
$21 = (($24 >>> 1 | $48) << 5) + $5 | 0;
|
|
label$6 : {
|
|
if (($23 & 255) != 2) {
|
|
break label$6;
|
|
}
|
|
$23 = 2;
|
|
$32 = HEAP32[($24 << 2) + $12 >> 2];
|
|
if ($24 & $62) {
|
|
break label$6;
|
|
}
|
|
$18 = HEAP32[$0 + 4592 >> 2];
|
|
$13 = HEAP32[$0 + 4640 >> 2];
|
|
$16 = ($18 - $32 | 0) - $13 | 0;
|
|
if (($16 | 0) <= 2) {
|
|
break label$3;
|
|
}
|
|
$16 = $16 - 2 | 0;
|
|
silk_LPC_analysis_filter(($16 << 1) + $39 | 0, (Math_imul($15, $24) + $16 << 1) + $1 | 0, $21, $18 - $16 | 0, $13, HEAP32[$0 + 5092 >> 2]);
|
|
HEAP32[$1 + 4348 >> 2] = 1;
|
|
HEAP32[$1 + 4332 >> 2] = HEAP32[$0 + 4592 >> 2];
|
|
$23 = HEAPU8[$2 + 29 | 0];
|
|
$19 = 0;
|
|
}
|
|
$20 = $11 + $22 | 0;
|
|
$14 = HEAP32[$20 >> 2];
|
|
$16 = ($14 | 0) > 1 ? $14 : 1;
|
|
$13 = Math_clz32($16);
|
|
$15 = $16 << $13 - 1;
|
|
$18 = $15 >> 16;
|
|
$17 = 536870911 / ($18 | 0) | 0;
|
|
$35 = ($17 >> 15) + 1 >> 1;
|
|
$26 = $15 & 65535;
|
|
$17 = $17 << 16;
|
|
$15 = $17 >> 16;
|
|
$18 = 0 - ((Math_imul($26, $15) >> 16) + Math_imul($15, $18) << 3) | 0;
|
|
$15 = ((Math_imul($18, $35) + $17 | 0) + Math_imul($18 >> 16, $15) | 0) + (Math_imul($18 & 65528, $15) >> 16) | 0;
|
|
$18 = 15 - $13 | 0;
|
|
$27 = HEAP32[$12 + $22 >> 2];
|
|
label$7 : {
|
|
if ($16 >>> 0 <= 131071) {
|
|
$16 = 0 - $18 | 0;
|
|
$18 = 2147483647 >>> $16 | 0;
|
|
$13 = -2147483648 >> $16;
|
|
$17 = (($15 | 0) > ($18 | 0) ? $18 : ($13 | 0) > ($15 | 0) ? $13 : $15) << $16;
|
|
break label$7;
|
|
}
|
|
$17 = $15 >> $18;
|
|
}
|
|
$33 = HEAP32[$0 + 4588 >> 2];
|
|
if (($33 | 0) >= 1) {
|
|
$15 = ($17 >> 4) + 1 | 0;
|
|
$18 = $15 << 15 >> 16;
|
|
$13 = ($15 >> 16) + 1 >> 1;
|
|
$15 = 0;
|
|
while (1) {
|
|
$16 = HEAP16[($15 << 1) + $3 >> 1];
|
|
HEAP32[($15 << 2) + $40 >> 2] = (Math_imul($16 >> 16, $18) + Math_imul($13, $16) | 0) + (Math_imul($16 & 65535, $18) >> 16);
|
|
$15 = $15 + 1 | 0;
|
|
if (($33 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$11 : {
|
|
if ($19) {
|
|
break label$11;
|
|
}
|
|
$17 = $24 ? $17 : Math_imul($17 >> 16, $49) + (Math_imul($17 & 65535, $49) >> 16) << 2;
|
|
$18 = HEAP32[$1 + 4332 >> 2];
|
|
$15 = ($18 - $27 | 0) - 2 | 0;
|
|
if (($15 | 0) >= ($18 | 0)) {
|
|
break label$11;
|
|
}
|
|
$13 = $17 & 65535;
|
|
$17 = $17 >> 16;
|
|
while (1) {
|
|
$16 = HEAP16[($15 << 1) + $39 >> 1];
|
|
HEAP32[($15 << 2) + $34 >> 2] = (Math_imul($16, $13) >> 16) + Math_imul($16, $17);
|
|
$15 = $15 + 1 | 0;
|
|
if (($18 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$15 = HEAP32[$1 + 4344 >> 2];
|
|
if (($15 | 0) != ($14 | 0)) {
|
|
$16 = $15 >> 31;
|
|
$18 = Math_clz32($16 ^ $15 + $16);
|
|
$16 = $15 << $18 - 1;
|
|
$35 = $16;
|
|
$15 = $14 >> 31;
|
|
$13 = Math_clz32($15 ^ $14 + $15);
|
|
$17 = $14 << $13 - 1;
|
|
$15 = 536870911 / ($17 >> 16) << 16 >> 16;
|
|
$16 = (Math_imul($15, $16 & 65535) >> 16) + Math_imul($16 >> 16, $15) | 0;
|
|
$19 = $16 >> 31;
|
|
$26 = $19;
|
|
$19 = $17 >> 31;
|
|
$14 = $19;
|
|
$19 = $26;
|
|
$14 = __wasm_i64_mul($16, $19, $17, $14);
|
|
$17 = $14;
|
|
$19 = i64toi32_i32$HIGH_BITS;
|
|
$17 = $35 - ((($19 & 536870911) << 3 | $17 >>> 29) & -8) | 0;
|
|
$15 = (Math_imul($17 >> 16, $15) + $16 | 0) + (Math_imul($17 & 65535, $15) >> 16) | 0;
|
|
$16 = $18 - $13 | 0;
|
|
$18 = $16 + 13 | 0;
|
|
$16 = $16 + 29 | 0;
|
|
label$15 : {
|
|
if (($16 | 0) <= 15) {
|
|
$16 = 0 - $18 | 0;
|
|
$18 = 2147483647 >>> $16 | 0;
|
|
$13 = -2147483648 >> $16;
|
|
$18 = (($15 | 0) > ($18 | 0) ? $18 : ($13 | 0) > ($15 | 0) ? $13 : $15) << $16;
|
|
break label$15;
|
|
}
|
|
$18 = ($16 | 0) < 48 ? $15 >> $18 : 0;
|
|
}
|
|
$15 = HEAP32[$0 + 4592 >> 2];
|
|
if (($15 | 0) >= 1) {
|
|
$17 = $18 & 65535;
|
|
$14 = $18 >> 16;
|
|
$15 = HEAP32[$1 + 4336 >> 2] - $15 | 0;
|
|
while (1) {
|
|
$16 = (($15 << 2) + $1 | 0) + 1280 | 0;
|
|
$19 = $16;
|
|
$16 = HEAP32[$16 >> 2];
|
|
$13 = $16 << 16 >> 16;
|
|
HEAP32[$19 >> 2] = ((Math_imul($17, $13) >> 16) + Math_imul($13, $14) | 0) + Math_imul(($16 >> 15) + 1 >> 1, $18);
|
|
$15 = $15 + 1 | 0;
|
|
if (($15 | 0) < HEAP32[$1 + 4336 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$19 : {
|
|
if (HEAP32[$1 + 4348 >> 2] | ($23 & 255) != 2) {
|
|
break label$19;
|
|
}
|
|
$17 = HEAP32[$1 + 4332 >> 2];
|
|
$15 = ($17 - $27 | 0) - 2 | 0;
|
|
if (($15 | 0) >= ($17 | 0)) {
|
|
break label$19;
|
|
}
|
|
$14 = $18 & 65535;
|
|
$19 = $18 >> 16;
|
|
while (1) {
|
|
$16 = ($15 << 2) + $34 | 0;
|
|
$26 = $16;
|
|
$16 = HEAP32[$16 >> 2];
|
|
$13 = $16 << 16 >> 16;
|
|
HEAP32[$26 >> 2] = ((Math_imul($14, $13) >> 16) + Math_imul($13, $19) | 0) + Math_imul(($16 >> 15) + 1 >> 1, $18);
|
|
$15 = $15 + 1 | 0;
|
|
if (($17 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = $18 & 65535;
|
|
$15 = HEAP32[$1 + 4320 >> 2];
|
|
$16 = $15 << 16 >> 16;
|
|
$17 = $18 >> 16;
|
|
HEAP32[$1 + 4320 >> 2] = ((Math_imul($13, $16) >> 16) + Math_imul($17, $16) | 0) + Math_imul(($15 >> 15) + 1 >> 1, $18);
|
|
$15 = HEAP32[$1 + 4324 >> 2];
|
|
$16 = $15 << 16 >> 16;
|
|
HEAP32[$1 + 4324 >> 2] = ((Math_imul($16, $13) >> 16) + Math_imul($16, $17) | 0) + Math_imul(($15 >> 15) + 1 >> 1, $18);
|
|
$15 = 0;
|
|
$16 = 0;
|
|
while (1) {
|
|
$14 = (($16 << 2) + $1 | 0) + 3840 | 0;
|
|
$26 = $14;
|
|
$14 = HEAP32[$14 >> 2];
|
|
$19 = $14 << 16 >> 16;
|
|
HEAP32[$26 >> 2] = ((Math_imul($19, $13) >> 16) + Math_imul($17, $19) | 0) + Math_imul(($14 >> 15) + 1 >> 1, $18);
|
|
$16 = $16 + 1 | 0;
|
|
if (($16 | 0) != 16) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
while (1) {
|
|
$16 = (($15 << 2) + $1 | 0) + 4224 | 0;
|
|
$19 = $16;
|
|
$16 = HEAP32[$16 >> 2];
|
|
$14 = $16 << 16 >> 16;
|
|
HEAP32[$19 >> 2] = ((Math_imul($14, $13) >> 16) + Math_imul($14, $17) | 0) + Math_imul(($16 >> 15) + 1 >> 1, $18);
|
|
$15 = $15 + 1 | 0;
|
|
if (($15 | 0) != 24) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$1 + 4344 >> 2] = HEAP32[$20 >> 2];
|
|
$33 = HEAP32[$0 + 4588 >> 2];
|
|
$14 = HEAP32[$20 >> 2];
|
|
}
|
|
if (($33 | 0) >= 1) {
|
|
$36 = Math_imul($24, 10) + $6 | 0;
|
|
$27 = 0;
|
|
$50 = ($23 & 255) != 2;
|
|
$68 = $50 | ($32 | 0) > 0;
|
|
$15 = $29 >> 2;
|
|
$51 = ($15 | $29 << 15) >> 16;
|
|
$16 = HEAP32[$10 + $22 >> 2];
|
|
$52 = $16 >> 16;
|
|
$29 = HEAP32[$0 + 4636 >> 2];
|
|
$69 = $29 >> 1;
|
|
$70 = $29 & 1;
|
|
$53 = HEAP32[$0 + 4640 >> 2];
|
|
$71 = $53 >> 1;
|
|
$54 = $14 << 10 >> 16;
|
|
$55 = $15 << 16 >> 16;
|
|
$56 = $16 << 16 >> 16;
|
|
$72 = ($14 >> 21) + 1 >> 1;
|
|
$14 = Math_imul($24, 48) + $7 | 0;
|
|
$15 = $29 - 1 | 0;
|
|
$35 = $14 + ($15 << 1) | 0;
|
|
$26 = (($15 << 2) + $1 | 0) + 4224 | 0;
|
|
$37 = ((HEAP32[$1 + 4336 >> 2] - $32 << 2) + $1 | 0) + 1284 | 0;
|
|
$31 = ((HEAP32[$1 + 4332 >> 2] - $32 << 2) + $34 | 0) + 8 | 0;
|
|
$57 = HEAP16[$9 + $22 >> 1];
|
|
$15 = HEAP32[$1 + 4340 >> 2];
|
|
$20 = $64;
|
|
while (1) {
|
|
HEAP32[$1 + 4340 >> 2] = Math_imul($15, 196314165) + 907633515;
|
|
$16 = HEAP16[$21 >> 1];
|
|
$15 = HEAP32[$20 >> 2];
|
|
$13 = (Math_imul($16, $15 >> 16) + $71 | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 2 >> 1];
|
|
$15 = HEAP32[$20 - 4 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 4 >> 1];
|
|
$15 = HEAP32[$20 - 8 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 6 >> 1];
|
|
$15 = HEAP32[$20 - 12 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 8 >> 1];
|
|
$15 = HEAP32[$20 - 16 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 10 >> 1];
|
|
$15 = HEAP32[$20 - 20 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 12 >> 1];
|
|
$15 = HEAP32[$20 - 24 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 14 >> 1];
|
|
$15 = HEAP32[$20 - 28 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 16 >> 1];
|
|
$15 = HEAP32[$20 - 32 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 18 >> 1];
|
|
$15 = HEAP32[$20 - 36 >> 2];
|
|
$38 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
if (($53 | 0) == 16) {
|
|
$16 = HEAP16[$21 + 20 >> 1];
|
|
$15 = HEAP32[$20 - 40 >> 2];
|
|
$13 = (Math_imul($16, $15 >> 16) + $38 | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 22 >> 1];
|
|
$15 = HEAP32[$20 - 44 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 24 >> 1];
|
|
$15 = HEAP32[$20 - 48 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 26 >> 1];
|
|
$15 = HEAP32[$20 - 52 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 28 >> 1];
|
|
$15 = HEAP32[$20 - 56 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$21 + 30 >> 1];
|
|
$15 = HEAP32[$20 - 60 >> 2];
|
|
$38 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
}
|
|
$45 = 0;
|
|
if (!$50) {
|
|
$16 = HEAP16[$36 >> 1];
|
|
$15 = HEAP32[$31 >> 2];
|
|
$13 = Math_imul($16, $15 >> 16) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$36 + 2 >> 1];
|
|
$15 = HEAP32[$31 - 4 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$36 + 4 >> 1];
|
|
$15 = HEAP32[$31 - 8 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$36 + 6 >> 1];
|
|
$15 = HEAP32[$31 - 12 >> 2];
|
|
$13 = ($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0;
|
|
$16 = HEAP16[$36 + 8 >> 1];
|
|
$15 = HEAP32[$31 - 16 >> 2];
|
|
$45 = (($13 + Math_imul($16, $15 >> 16) | 0) + (Math_imul($15 & 65535, $16) >> 16) | 0) + 2 | 0;
|
|
$31 = $31 + 4 | 0;
|
|
}
|
|
if ($70) {
|
|
break label$2;
|
|
}
|
|
$16 = HEAP32[$1 + 4224 >> 2];
|
|
$15 = HEAP32[$1 + 4324 >> 2];
|
|
HEAP32[$1 + 4224 >> 2] = $15;
|
|
$18 = HEAP16[$14 >> 1];
|
|
$17 = (Math_imul($18, $15 >> 16) + $69 | 0) + (Math_imul($15 & 65535, $18) >> 16) | 0;
|
|
$15 = 2;
|
|
if (($29 | 0) >= 3) {
|
|
while (1) {
|
|
$13 = $1 + 4224 | 0;
|
|
$19 = $15 - 1 | 0;
|
|
$22 = $13 + ($19 << 2) | 0;
|
|
$18 = HEAP32[$22 >> 2];
|
|
HEAP32[$22 >> 2] = $16;
|
|
$22 = ($15 << 2) + $13 | 0;
|
|
$23 = HEAP32[$22 >> 2];
|
|
$13 = HEAP16[($19 << 1) + $14 >> 1];
|
|
HEAP32[$22 >> 2] = $18;
|
|
$13 = (Math_imul($16 >> 16, $13) + $17 | 0) + (Math_imul($16 & 65535, $13) >> 16) | 0;
|
|
$16 = HEAP16[($15 << 1) + $14 >> 1];
|
|
$17 = ($13 + Math_imul($16, $18 >> 16) | 0) + (Math_imul($18 & 65535, $16) >> 16) | 0;
|
|
$16 = $23;
|
|
$15 = $15 + 2 | 0;
|
|
if (($29 | 0) > ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$26 >> 2] = $16;
|
|
if (!$68) {
|
|
break label$1;
|
|
}
|
|
$15 = HEAP32[$1 + 4320 >> 2];
|
|
$18 = $15 & 65535;
|
|
$15 = $15 >> 16;
|
|
$13 = HEAP16[$35 >> 1];
|
|
$22 = ((Math_imul($57, $18) >> 16) + Math_imul($57, $15) | 0) + ((Math_imul($13, $16 >> 16) + $17 | 0) + (Math_imul($16 & 65535, $13) >> 16) << 1) | 0;
|
|
$13 = Math_imul($15, $52) + (Math_imul($18, $52) >> 16) | 0;
|
|
$15 = HEAP32[((HEAP32[$1 + 4336 >> 2] << 2) + $1 | 0) + 1276 >> 2];
|
|
$23 = ($13 + Math_imul($15 >> 16, $56) | 0) + (Math_imul($15 & 65535, $56) >> 16) | 0;
|
|
$15 = (($38 << 2) - $22 | 0) - $23 | 0;
|
|
label$29 : {
|
|
if (($32 | 0) >= 1) {
|
|
$13 = ($15 << 1) + $45 | 0;
|
|
$15 = HEAP32[$37 - 4 >> 2];
|
|
$16 = HEAP32[$37 - 8 >> 2] + HEAP32[$37 >> 2] | 0;
|
|
$15 = $13 - (((Math_imul($15 >> 16, $51) + Math_imul($16 >> 16, $55) | 0) + (Math_imul($16 & 65535, $55) >> 16) | 0) + (Math_imul($15 & 65535, $51) >> 16) << 1) >> 2;
|
|
$37 = $37 + 4 | 0;
|
|
break label$29;
|
|
}
|
|
$15 = $15 >> 1;
|
|
}
|
|
label$31 : {
|
|
label$32 : {
|
|
label$33 : {
|
|
label$34 : {
|
|
$58 = ($27 << 2) + $40 | 0;
|
|
$15 = HEAP32[$58 >> 2] - ($15 + 1 >> 1) | 0;
|
|
$15 = HEAP32[$1 + 4340 >> 2] < 0 ? 0 - $15 | 0 : $15;
|
|
$15 = ($15 | 0) > -31744 ? $15 : -31744;
|
|
$13 = ($15 | 0) < 30720 ? $15 : 30720;
|
|
$15 = $13 - $25 | 0;
|
|
$16 = $15;
|
|
label$35 : {
|
|
if ($66) {
|
|
break label$35;
|
|
}
|
|
$16 = $15 - $42 | 0;
|
|
if (($15 | 0) > ($42 | 0)) {
|
|
break label$35;
|
|
}
|
|
if (($15 | 0) >= ($65 | 0)) {
|
|
break label$34;
|
|
}
|
|
$16 = $15 + $42 | 0;
|
|
}
|
|
$15 = $16;
|
|
if (($15 | 0) >= 1024) {
|
|
$16 = ($15 & -1024) + $63 | 0;
|
|
$17 = Math_imul($16 << 16 >> 16, $30);
|
|
$18 = $16 + 1024 | 0;
|
|
$19 = Math_imul($18 << 16 >> 16, $30);
|
|
break label$31;
|
|
}
|
|
$16 = $25;
|
|
$18 = $41;
|
|
$17 = $44;
|
|
$19 = $46;
|
|
switch (($15 >> 10) + 1 | 0) {
|
|
case 1:
|
|
break label$31;
|
|
case 0:
|
|
break label$33;
|
|
default:
|
|
break label$32;
|
|
}
|
|
}
|
|
$16 = $25;
|
|
$18 = $41;
|
|
$17 = $44;
|
|
$19 = $46;
|
|
if (($15 | 0) >= 0) {
|
|
break label$31;
|
|
}
|
|
}
|
|
$16 = $47;
|
|
$18 = $25;
|
|
$17 = $61;
|
|
$19 = $44;
|
|
break label$31;
|
|
}
|
|
$16 = ($15 & -1024 | 80) + $25 | 0;
|
|
$17 = Math_imul(0 - ($16 << 16) >> 16, $30);
|
|
$18 = $16 + 1024 | 0;
|
|
$19 = Math_imul(0 - ($18 << 16) >> 16, $30);
|
|
}
|
|
$59 = $4 + $27 | 0;
|
|
$15 = $13 - $18 << 16 >> 16;
|
|
$19 = Math_imul($15, $15) + $19 | 0;
|
|
$15 = $13 - $16 << 16 >> 16;
|
|
$15 = ($19 | 0) < (Math_imul($15, $15) + $17 | 0) ? $18 : $16;
|
|
HEAP8[$59 | 0] = ($15 >>> 9 | 0) + 1 >>> 1;
|
|
$15 = $15 << 4;
|
|
$18 = ($45 << 1) + (HEAP32[$1 + 4340 >> 2] < 0 ? 0 - $15 | 0 : $15) | 0;
|
|
$15 = $18 + ($38 << 4) | 0;
|
|
$16 = (Math_imul($15 >> 16, $54) + Math_imul($15, $72) | 0) + (Math_imul($15 & 65534, $54) >> 16) | 0;
|
|
HEAP16[($27 << 1) + $43 >> 1] = ($16 | 0) > 8388479 ? 32767 : ($16 | 0) < -8388736 ? -32768 : ($16 >>> 7 | 0) + 1 >>> 1 | 0;
|
|
HEAP32[$20 + 4 >> 2] = $15;
|
|
$15 = $15 - (HEAP32[$58 >> 2] << 4) | 0;
|
|
HEAP32[$1 + 4324 >> 2] = $15;
|
|
$15 = $15 - ($22 << 2) | 0;
|
|
HEAP32[$1 + 4320 >> 2] = $15;
|
|
HEAP32[((HEAP32[$1 + 4336 >> 2] << 2) + $1 | 0) + 1280 >> 2] = $15 - ($23 << 2);
|
|
$15 = HEAP32[$1 + 4332 >> 2];
|
|
HEAP32[($15 << 2) + $34 >> 2] = $18 << 1;
|
|
HEAP32[$1 + 4332 >> 2] = $15 + 1;
|
|
HEAP32[$1 + 4336 >> 2] = HEAP32[$1 + 4336 >> 2] + 1;
|
|
$15 = HEAP32[$1 + 4340 >> 2] + HEAP8[$59 | 0] | 0;
|
|
HEAP32[$1 + 4340 >> 2] = $15;
|
|
$20 = $20 + 4 | 0;
|
|
$27 = $27 + 1 | 0;
|
|
if (($33 | 0) != ($27 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$15 = ($33 << 2) + $1 | 0;
|
|
$19 = $15 + 3896 | 0;
|
|
$14 = HEAP32[$19 >> 2];
|
|
$17 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $14;
|
|
$14 = $67;
|
|
HEAP32[$14 + 56 >> 2] = $13;
|
|
HEAP32[$14 + 60 >> 2] = $17;
|
|
$19 = $15 + 3888 | 0;
|
|
$17 = HEAP32[$19 >> 2];
|
|
$14 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $17;
|
|
$17 = $28;
|
|
HEAP32[$17 + 48 >> 2] = $13;
|
|
HEAP32[$17 + 52 >> 2] = $14;
|
|
$19 = $15 + 3880 | 0;
|
|
$14 = HEAP32[$19 >> 2];
|
|
$17 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $14;
|
|
$14 = $28;
|
|
HEAP32[$14 + 40 >> 2] = $13;
|
|
HEAP32[$14 + 44 >> 2] = $17;
|
|
$19 = $15 + 3872 | 0;
|
|
$17 = HEAP32[$19 >> 2];
|
|
$14 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $17;
|
|
$17 = $28;
|
|
HEAP32[$17 + 32 >> 2] = $13;
|
|
HEAP32[$17 + 36 >> 2] = $14;
|
|
$19 = $15 + 3864 | 0;
|
|
$14 = HEAP32[$19 >> 2];
|
|
$17 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $14;
|
|
$14 = $28;
|
|
HEAP32[$14 + 24 >> 2] = $13;
|
|
HEAP32[$14 + 28 >> 2] = $17;
|
|
$19 = $15 + 3856 | 0;
|
|
$17 = HEAP32[$19 >> 2];
|
|
$14 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $17;
|
|
$17 = $28;
|
|
HEAP32[$17 + 16 >> 2] = $13;
|
|
HEAP32[$17 + 20 >> 2] = $14;
|
|
$19 = $15 + 3848 | 0;
|
|
$14 = HEAP32[$19 >> 2];
|
|
$17 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $14;
|
|
$14 = $28;
|
|
HEAP32[$14 + 8 >> 2] = $13;
|
|
HEAP32[$14 + 12 >> 2] = $17;
|
|
$19 = $15 + 3840 | 0;
|
|
$17 = HEAP32[$19 >> 2];
|
|
$14 = HEAP32[$19 + 4 >> 2];
|
|
$13 = $17;
|
|
$17 = $28;
|
|
HEAP32[$17 >> 2] = $13;
|
|
HEAP32[$17 + 4 >> 2] = $14;
|
|
$16 = HEAP32[$0 + 4580 >> 2];
|
|
$24 = $24 + 1 | 0;
|
|
if (($16 | 0) > ($24 | 0)) {
|
|
$15 = HEAP32[$0 + 4588 >> 2];
|
|
$4 = $15 + $4 | 0;
|
|
$16 = $15 << 1;
|
|
$3 = $16 + $3 | 0;
|
|
$43 = $16 + $43 | 0;
|
|
$23 = HEAPU8[$2 + 29 | 0];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$17 = HEAP32[$0 + 4584 >> 2];
|
|
$18 = HEAP32[$0 + 4592 >> 2];
|
|
}
|
|
HEAP32[$1 + 4328 >> 2] = HEAP32[(($16 << 2) + $12 | 0) - 4 >> 2];
|
|
$15 = memmove($1, ($17 << 1) + $1 | 0, $18 << 1) + 1280 | 0;
|
|
memmove($15, (HEAP32[$0 + 4584 >> 2] << 2) + $15 | 0, HEAP32[$0 + 4592 >> 2] << 2);
|
|
__stack_pointer = $60;
|
|
return;
|
|
}
|
|
celt_fatal(16318, 16350, 146);
|
|
abort();
|
|
}
|
|
celt_fatal(16361, 16350, 250);
|
|
abort();
|
|
}
|
|
celt_fatal(16408, 16350, 258);
|
|
abort();
|
|
}
|
|
function silk_encode_frame_FLP($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = Math_fround(0), $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0;
|
|
$9 = __stack_pointer - 13584 | 0;
|
|
__stack_pointer = $9;
|
|
HEAP32[$9 + 40 >> 2] = 0;
|
|
HEAP32[$9 + 44 >> 2] = 0;
|
|
HEAP32[$9 + 32 >> 2] = 0;
|
|
HEAP32[$9 + 36 >> 2] = 0;
|
|
$10 = HEAP32[$0 + 4620 >> 2];
|
|
HEAP8[$0 + 4770 | 0] = $10 & 3;
|
|
HEAP32[$0 + 4620 >> 2] = $10 + 1;
|
|
$10 = HEAP32[$0 + 4592 >> 2];
|
|
silk_LP_variable_cutoff($0 + 16 | 0, $0 + 5098 | 0, HEAP32[$0 + 4584 >> 2]);
|
|
$14 = $10 << 2;
|
|
$28 = $0 + 7180 | 0;
|
|
$15 = $14 + $28 | 0;
|
|
$11 = Math_imul(HEAP32[$0 + 4576 >> 2], 5);
|
|
$12 = $15 + ($11 << 2) | 0;
|
|
$13 = HEAP32[$0 + 4584 >> 2];
|
|
if (($13 | 0) >= 1) {
|
|
$10 = $13;
|
|
while (1) {
|
|
$6 = $10 - 1 | 0;
|
|
HEAPF32[($6 << 2) + $12 >> 2] = HEAP16[(($10 << 1) + $0 | 0) + 5096 >> 1];
|
|
$7 = ($10 | 0) > 1;
|
|
$10 = $6;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$12 >> 2] = HEAPF32[$12 >> 2] + Math_fround(9.999999974752427e-7);
|
|
$10 = $13 >> 3;
|
|
$6 = ($11 + $10 << 2) + $15 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround(9.999999974752427e-7);
|
|
$6 = (($10 << 1) + $11 << 2) + $15 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround(-9.999999974752427e-7);
|
|
$6 = (Math_imul($10, 3) + $11 << 2) + $15 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround(-9.999999974752427e-7);
|
|
$6 = (($10 << 2) + $11 << 2) + $15 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround(9.999999974752427e-7);
|
|
$6 = (Math_imul($10, 5) + $11 << 2) + $15 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround(9.999999974752427e-7);
|
|
$6 = (Math_imul($10, 6) + $11 << 2) + $15 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] + Math_fround(-9.999999974752427e-7);
|
|
$10 = (Math_imul($10, 7) + $11 << 2) + $15 | 0;
|
|
HEAPF32[$10 >> 2] = HEAPF32[$10 >> 2] + Math_fround(-9.999999974752427e-7);
|
|
label$3 : {
|
|
if (HEAP32[$0 + 4680 >> 2]) {
|
|
break label$3;
|
|
}
|
|
$20 = $0 + 4736 | 0;
|
|
silk_find_pitch_lags_FLP($0, $9 + 8480 | 0, $9 + 5792 | 0, $15, HEAP32[$0 + 5092 >> 2]);
|
|
$10 = ($9 + 5792 | 0) + $14 | 0;
|
|
silk_noise_shape_analysis_FLP($0, $9 + 8480 | 0, $10, $15);
|
|
silk_find_pred_coefs_FLP($0, $9 + 8480 | 0, $10, $15, $3);
|
|
silk_process_gains_FLP($0, $9 + 8480 | 0, $3);
|
|
if (!(!HEAP32[$0 + 6092 >> 2] | HEAP32[$0 + 4532 >> 2] < 78)) {
|
|
$10 = HEAP32[$0 + 5748 >> 2];
|
|
HEAP32[(($10 << 2) + $0 | 0) + 4724 >> 2] = 1;
|
|
memcpy($9 + 9232 | 0, $0 + 148 | 0, 4352);
|
|
$12 = (Math_imul($10, 36) + $0 | 0) + 6100 | 0;
|
|
$7 = $0 + 4768 | 0;
|
|
$7 = HEAPU16[$7 >> 1] | HEAPU16[$7 + 2 >> 1] << 16;
|
|
HEAP16[$12 + 32 >> 1] = $7;
|
|
HEAP16[$12 + 34 >> 1] = $7 >>> 16;
|
|
$8 = $0 + 4760 | 0;
|
|
$6 = HEAPU16[$8 >> 1] | HEAPU16[$8 + 2 >> 1] << 16;
|
|
$7 = HEAPU16[$8 + 4 >> 1] | HEAPU16[$8 + 6 >> 1] << 16;
|
|
$8 = $6;
|
|
$6 = $12;
|
|
HEAP16[$6 + 24 >> 1] = $8;
|
|
HEAP16[$6 + 26 >> 1] = $8 >>> 16;
|
|
HEAP16[$6 + 28 >> 1] = $7;
|
|
HEAP16[$6 + 30 >> 1] = $7 >>> 16;
|
|
$8 = $0 + 4752 | 0;
|
|
$7 = HEAPU16[$8 >> 1] | HEAPU16[$8 + 2 >> 1] << 16;
|
|
$6 = HEAPU16[$8 + 4 >> 1] | HEAPU16[$8 + 6 >> 1] << 16;
|
|
$8 = $7;
|
|
$7 = $12;
|
|
HEAP16[$7 + 16 >> 1] = $8;
|
|
HEAP16[$7 + 18 >> 1] = $8 >>> 16;
|
|
HEAP16[$7 + 20 >> 1] = $6;
|
|
HEAP16[$7 + 22 >> 1] = $6 >>> 16;
|
|
$8 = $0 + 4744 | 0;
|
|
$6 = HEAPU16[$8 >> 1] | HEAPU16[$8 + 2 >> 1] << 16;
|
|
$7 = HEAPU16[$8 + 4 >> 1] | HEAPU16[$8 + 6 >> 1] << 16;
|
|
$8 = $6;
|
|
$6 = $12;
|
|
HEAP16[$6 + 8 >> 1] = $8;
|
|
HEAP16[$6 + 10 >> 1] = $8 >>> 16;
|
|
HEAP16[$6 + 12 >> 1] = $7;
|
|
HEAP16[$6 + 14 >> 1] = $7 >>> 16;
|
|
$6 = HEAPU16[$0 + 4740 >> 1] | HEAPU16[$0 + 4742 >> 1] << 16;
|
|
$7 = HEAPU16[$0 + 4736 >> 1] | HEAPU16[$0 + 4738 >> 1] << 16;
|
|
$8 = $7;
|
|
$7 = $12;
|
|
HEAP16[$7 >> 1] = $8;
|
|
HEAP16[$7 + 2 >> 1] = $8 >>> 16;
|
|
HEAP16[$7 + 4 >> 1] = $6;
|
|
HEAP16[$7 + 6 >> 1] = $6 >>> 16;
|
|
$10 = HEAP32[$0 + 4580 >> 2];
|
|
memcpy($9 + 48 | 0, $9 + 8480 | 0, $10 << 2);
|
|
$8 = $9 + 1344 | 0;
|
|
$11 = $0 + 4540 | 0;
|
|
$14 = ($3 | 0) == 2;
|
|
$6 = HEAP32[$0 + 5748 >> 2];
|
|
if (!(HEAP32[(($6 << 2) + $0 | 0) + 4720 >> 2] ? $6 : 0)) {
|
|
HEAP8[$0 + 4540 | 0] = HEAPU8[$0 + 7168 | 0];
|
|
$10 = HEAPU8[$12 | 0] + HEAPU8[$0 + 6096 | 0] | 0;
|
|
HEAP8[$12 | 0] = $10 << 24 >> 24 < 63 ? $10 : 63;
|
|
$10 = HEAP32[$0 + 4580 >> 2];
|
|
}
|
|
silk_gains_dequant($8, $7, $11, $14, $10);
|
|
$7 = HEAP32[$0 + 4580 >> 2];
|
|
if (($7 | 0) >= 1) {
|
|
$10 = 0;
|
|
while (1) {
|
|
$6 = $10 << 2;
|
|
HEAPF32[$6 + ($9 + 8480 | 0) >> 2] = Math_fround(HEAP32[($9 + 1344 | 0) + $6 >> 2]) * Math_fround(152587890625e-16);
|
|
$10 = $10 + 1 | 0;
|
|
if (($7 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_NSQ_wrapper_FLP($0, $9 + 8480 | 0, $12, $9 + 9232 | 0, (Math_imul(HEAP32[$0 + 5748 >> 2], 320) + $0 | 0) + 6208 | 0, $15);
|
|
memcpy($9 + 8480 | 0, $9 + 48 | 0, HEAP32[$0 + 4580 >> 2] << 2);
|
|
}
|
|
$16 = silk_gains_ID($20, HEAP32[$0 + 4580 >> 2]);
|
|
$8 = $2;
|
|
$6 = HEAP32[$8 + 40 >> 2];
|
|
$7 = HEAP32[$8 + 44 >> 2];
|
|
$11 = $6;
|
|
$29 = $9 + 5784 | 0;
|
|
$6 = $29;
|
|
HEAP32[$6 >> 2] = $11;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$6 = HEAP32[$8 + 36 >> 2];
|
|
$7 = HEAP32[$8 + 32 >> 2];
|
|
$11 = $7;
|
|
$30 = $9 + 5776 | 0;
|
|
$7 = $30;
|
|
HEAP32[$7 >> 2] = $11;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
$7 = HEAP32[$8 + 28 >> 2];
|
|
$6 = HEAP32[$8 + 24 >> 2];
|
|
$11 = $6;
|
|
$31 = $9 + 5768 | 0;
|
|
$6 = $31;
|
|
HEAP32[$6 >> 2] = $11;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$6 = HEAP32[$8 + 20 >> 2];
|
|
$7 = HEAP32[$8 + 16 >> 2];
|
|
$11 = $7;
|
|
$32 = $9 + 5760 | 0;
|
|
$7 = $32;
|
|
HEAP32[$7 >> 2] = $11;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
$7 = HEAP32[$8 + 12 >> 2];
|
|
$6 = HEAP32[$8 + 8 >> 2];
|
|
$11 = $6;
|
|
$33 = $9 + 5752 | 0;
|
|
$6 = $33;
|
|
HEAP32[$6 >> 2] = $11;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$7 = HEAP32[$8 >> 2];
|
|
HEAP32[$9 + 5744 >> 2] = $7;
|
|
HEAP32[$9 + 5748 >> 2] = $6;
|
|
$21 = $0 + 148 | 0;
|
|
memcpy($9 + 9232 | 0, $21, 4352);
|
|
$41 = $0 + 4736 | 0;
|
|
$34 = ($3 | 0) == 2;
|
|
$42 = $4 - 5 | 0;
|
|
$26 = $0 + 7168 | 0;
|
|
$24 = $0 + 4772 | 0;
|
|
$35 = HEAP32[$0 + 5768 >> 2];
|
|
$36 = HEAPU16[$0 + 5772 >> 1];
|
|
$43 = HEAPU8[$0 + 4770 | 0];
|
|
$13 = 256;
|
|
$27 = -1;
|
|
$14 = -1;
|
|
while (1) {
|
|
$10 = ($16 | 0) == ($27 | 0);
|
|
label$10 : {
|
|
if ($10) {
|
|
$11 = $25;
|
|
break label$10;
|
|
}
|
|
if (($14 | 0) == ($16 | 0)) {
|
|
$11 = $22;
|
|
break label$10;
|
|
}
|
|
if ($17) {
|
|
$7 = HEAP32[$9 + 5748 >> 2];
|
|
$6 = HEAP32[$9 + 5744 >> 2];
|
|
$8 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 >> 2] = $8;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$8 = $29;
|
|
$7 = HEAP32[$8 >> 2];
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 40 >> 2] = $8;
|
|
HEAP32[$7 + 44 >> 2] = $6;
|
|
$8 = $30;
|
|
$6 = HEAP32[$8 >> 2];
|
|
$7 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 + 32 >> 2] = $8;
|
|
HEAP32[$6 + 36 >> 2] = $7;
|
|
$8 = $31;
|
|
$7 = HEAP32[$8 >> 2];
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 24 >> 2] = $8;
|
|
HEAP32[$7 + 28 >> 2] = $6;
|
|
$8 = $32;
|
|
$6 = HEAP32[$8 >> 2];
|
|
$7 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 + 16 >> 2] = $8;
|
|
HEAP32[$6 + 20 >> 2] = $7;
|
|
$8 = $33;
|
|
$7 = HEAP32[$8 >> 2];
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 8 >> 2] = $8;
|
|
HEAP32[$7 + 12 >> 2] = $6;
|
|
memcpy($21, $9 + 9232 | 0, 4352);
|
|
HEAP16[$0 + 5772 >> 1] = $36;
|
|
HEAP8[$0 + 4770 | 0] = $43;
|
|
HEAP32[$0 + 5768 >> 2] = $35;
|
|
}
|
|
silk_NSQ_wrapper_FLP($0, $9 + 8480 | 0, $20, $21, $24, $15);
|
|
if (!(($17 | 0) != 6 | $19)) {
|
|
$8 = $2;
|
|
$6 = HEAP32[$8 + 16 >> 2];
|
|
$7 = HEAP32[$8 + 20 >> 2];
|
|
$11 = $6;
|
|
$6 = $9 + 5736 | 0;
|
|
HEAP32[$6 >> 2] = $11;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$6 = HEAP32[$8 + 12 >> 2];
|
|
$7 = HEAP32[$8 + 8 >> 2];
|
|
$11 = $7;
|
|
$7 = $9 + 5728 | 0;
|
|
HEAP32[$7 >> 2] = $11;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
$7 = HEAP32[$8 + 4 >> 2];
|
|
$6 = HEAP32[$8 >> 2];
|
|
HEAP32[$9 + 5720 >> 2] = $6;
|
|
HEAP32[$9 + 5724 >> 2] = $7;
|
|
$18 = HEAP32[$8 + 24 >> 2];
|
|
$6 = HEAP32[$8 + 40 >> 2];
|
|
$7 = HEAP32[$8 + 36 >> 2];
|
|
$11 = $7;
|
|
$7 = $9 + 5704 | 0;
|
|
HEAP32[$7 >> 2] = $11;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
HEAP32[$9 + 5712 >> 2] = HEAP32[$8 + 44 >> 2];
|
|
$7 = HEAP32[$8 + 32 >> 2];
|
|
$6 = HEAP32[$8 + 28 >> 2];
|
|
HEAP32[$9 + 5696 >> 2] = $6;
|
|
HEAP32[$9 + 5700 >> 2] = $7;
|
|
}
|
|
silk_encode_indices($0, $2, HEAP32[$0 + 5748 >> 2], 0, $3);
|
|
silk_encode_pulses($2, HEAP8[$0 + 4765 | 0], HEAP8[$0 + 4766 | 0], $24, HEAP32[$0 + 4584 >> 2]);
|
|
$11 = (HEAP32[$2 + 20 >> 2] + Math_clz32(HEAP32[$2 + 28 >> 2]) | 0) - 32 | 0;
|
|
if (!($19 | ($11 | 0) <= ($4 | 0) | ($17 | 0) != 6)) {
|
|
$6 = HEAP32[$9 + 5724 >> 2];
|
|
$7 = HEAP32[$9 + 5720 >> 2];
|
|
$8 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 >> 2] = $8;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
$8 = $9 + 5736 | 0;
|
|
$6 = HEAP32[$8 >> 2];
|
|
$7 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 + 16 >> 2] = $8;
|
|
HEAP32[$6 + 20 >> 2] = $7;
|
|
$8 = $9 + 5728 | 0;
|
|
$7 = HEAP32[$8 >> 2];
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 8 >> 2] = $8;
|
|
HEAP32[$7 + 12 >> 2] = $6;
|
|
HEAP32[$7 + 24 >> 2] = $18;
|
|
HEAP32[$7 + 44 >> 2] = HEAP32[$9 + 5712 >> 2];
|
|
$8 = $9 + 5704 | 0;
|
|
$6 = HEAP32[$8 >> 2];
|
|
$7 = HEAP32[$8 + 4 >> 2];
|
|
$8 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 + 36 >> 2] = $8;
|
|
HEAP32[$6 + 40 >> 2] = $7;
|
|
$6 = HEAP32[$9 + 5700 >> 2];
|
|
$7 = HEAP32[$9 + 5696 >> 2];
|
|
$8 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 28 >> 2] = $8;
|
|
HEAP32[$7 + 32 >> 2] = $6;
|
|
$7 = HEAPU8[$9 + 9224 | 0];
|
|
HEAP8[$0 + 7168 | 0] = $7;
|
|
$6 = HEAP32[$0 + 4580 >> 2];
|
|
if (($6 | 0) >= 1) {
|
|
memset($41, 4, $6);
|
|
}
|
|
if (!$34) {
|
|
HEAP8[$20 | 0] = $7;
|
|
}
|
|
HEAP32[$0 + 5768 >> 2] = $35;
|
|
HEAP16[$0 + 5772 >> 1] = $36;
|
|
$6 = HEAP32[$0 + 4584 >> 2];
|
|
if (($6 | 0) >= 1) {
|
|
memset($24, 0, $6);
|
|
}
|
|
silk_encode_indices($0, $2, HEAP32[$0 + 5748 >> 2], 0, $3);
|
|
silk_encode_pulses($2, HEAP8[$0 + 4765 | 0], HEAP8[$0 + 4766 | 0], $24, HEAP32[$0 + 4584 >> 2]);
|
|
$11 = (HEAP32[$2 + 20 >> 2] + Math_clz32(HEAP32[$2 + 28 >> 2]) | 0) - 32 | 0;
|
|
}
|
|
if ($5 | $17) {
|
|
break label$10;
|
|
}
|
|
if (($4 | 0) >= ($11 | 0)) {
|
|
break label$3;
|
|
}
|
|
}
|
|
label$19 : {
|
|
label$20 : {
|
|
label$21 : {
|
|
label$22 : {
|
|
label$23 : {
|
|
label$24 : {
|
|
if (($17 | 0) == 6) {
|
|
if (!$19 | !(($4 | 0) < ($11 | 0) | $10)) {
|
|
break label$3;
|
|
}
|
|
$7 = HEAP32[$9 + 5724 >> 2];
|
|
$6 = HEAP32[$9 + 5720 >> 2];
|
|
$3 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 >> 2] = $3;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$8 = $9 + 5736 | 0;
|
|
$7 = HEAP32[$8 >> 2];
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$3 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 16 >> 2] = $3;
|
|
HEAP32[$7 + 20 >> 2] = $6;
|
|
$8 = $9 + 5728 | 0;
|
|
$6 = HEAP32[$8 >> 2];
|
|
$7 = HEAP32[$8 + 4 >> 2];
|
|
$3 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 + 8 >> 2] = $3;
|
|
HEAP32[$6 + 12 >> 2] = $7;
|
|
HEAP32[$6 + 24 >> 2] = $18;
|
|
HEAP32[$6 + 44 >> 2] = HEAP32[$9 + 5712 >> 2];
|
|
$8 = $9 + 5704 | 0;
|
|
$7 = HEAP32[$8 >> 2];
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$3 = $7;
|
|
$7 = $2;
|
|
HEAP32[$7 + 36 >> 2] = $3;
|
|
HEAP32[$7 + 40 >> 2] = $6;
|
|
$7 = HEAP32[$9 + 5700 >> 2];
|
|
$6 = HEAP32[$9 + 5696 >> 2];
|
|
$3 = $6;
|
|
$6 = $2;
|
|
HEAP32[$6 + 28 >> 2] = $3;
|
|
HEAP32[$6 + 32 >> 2] = $7;
|
|
if ($18 >>> 0 >= 1276) {
|
|
break label$24;
|
|
}
|
|
memcpy(HEAP32[$2 >> 2], $9 + 48 | 0, $18);
|
|
memcpy($21, $9 + 1344 | 0, 4352);
|
|
HEAP8[$26 | 0] = $44;
|
|
break label$3;
|
|
}
|
|
label$26 : {
|
|
label$27 : {
|
|
label$28 : {
|
|
label$29 : {
|
|
if (($4 | 0) < ($11 | 0)) {
|
|
if ($17 >>> 0 < 2 | $19) {
|
|
break label$29;
|
|
}
|
|
$37 = Math_fround(HEAPF32[$9 + 9172 >> 2] * Math_fround(1.5));
|
|
HEAPF32[$9 + 9172 >> 2] = $37 > Math_fround(1.5) ? $37 : Math_fround(1.5);
|
|
$38 = 0;
|
|
HEAP8[$0 + 4766 | 0] = 0;
|
|
$16 = -1;
|
|
break label$28;
|
|
}
|
|
if (($11 | 0) >= ($42 | 0)) {
|
|
break label$3;
|
|
}
|
|
if (!$10) {
|
|
$8 = $2;
|
|
$7 = HEAP32[$8 + 16 >> 2];
|
|
$6 = HEAP32[$8 + 20 >> 2];
|
|
$12 = $7;
|
|
$7 = $9 + 5736 | 0;
|
|
HEAP32[$7 >> 2] = $12;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
$7 = HEAP32[$8 + 12 >> 2];
|
|
$6 = HEAP32[$8 + 8 >> 2];
|
|
$12 = $6;
|
|
$6 = $9 + 5728 | 0;
|
|
HEAP32[$6 >> 2] = $12;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
$6 = HEAP32[$8 + 4 >> 2];
|
|
$7 = HEAP32[$8 >> 2];
|
|
HEAP32[$9 + 5720 >> 2] = $7;
|
|
HEAP32[$9 + 5724 >> 2] = $6;
|
|
$18 = HEAP32[$8 + 24 >> 2];
|
|
$7 = HEAP32[$8 + 40 >> 2];
|
|
$6 = HEAP32[$8 + 36 >> 2];
|
|
$12 = $6;
|
|
$6 = $9 + 5704 | 0;
|
|
HEAP32[$6 >> 2] = $12;
|
|
HEAP32[$6 + 4 >> 2] = $7;
|
|
HEAP32[$9 + 5712 >> 2] = HEAP32[$8 + 44 >> 2];
|
|
$6 = HEAP32[$8 + 32 >> 2];
|
|
$7 = HEAP32[$8 + 28 >> 2];
|
|
HEAP32[$9 + 5696 >> 2] = $7;
|
|
HEAP32[$9 + 5700 >> 2] = $6;
|
|
if ($18 >>> 0 >= 1276) {
|
|
break label$23;
|
|
}
|
|
memcpy($9 + 48 | 0, HEAP32[$2 >> 2], $18);
|
|
memcpy($9 + 1344 | 0, $21, 4352);
|
|
$44 = HEAPU8[$26 | 0];
|
|
}
|
|
$23 = $13 << 16 >> 16;
|
|
$19 = 1;
|
|
if (!$38) {
|
|
break label$22;
|
|
}
|
|
$25 = $11;
|
|
$11 = $22;
|
|
$27 = $16;
|
|
break label$26;
|
|
}
|
|
$39 = $13 << 16 >> 16;
|
|
$38 = 1;
|
|
if ($19) {
|
|
break label$27;
|
|
}
|
|
$22 = $11;
|
|
}
|
|
$40 = HEAP32[$0 + 4580 >> 2];
|
|
if (($40 | 0) < 1) {
|
|
break label$21;
|
|
}
|
|
$11 = 0;
|
|
$14 = HEAP32[$0 + 4588 >> 2];
|
|
$12 = $14;
|
|
while (1) {
|
|
$6 = 0;
|
|
$10 = Math_imul($11, $14);
|
|
$8 = $11 + 1 | 0;
|
|
if (($10 | 0) < (Math_imul($8, $14) | 0)) {
|
|
while (1) {
|
|
$7 = HEAP8[($0 + $10 | 0) + 4772 | 0];
|
|
$45 = $7;
|
|
$7 = $7 >> 31;
|
|
$6 = ($7 ^ $7 + $45) + $6 | 0;
|
|
$10 = $10 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$35 : {
|
|
label$36 : {
|
|
if ($17) {
|
|
$10 = $11 << 2;
|
|
if (HEAP32[$10 + $9 >> 2] <= ($6 | 0) | HEAP32[($9 + 32 | 0) + $10 >> 2]) {
|
|
break label$36;
|
|
}
|
|
}
|
|
HEAP16[($9 + 24 | 0) + ($11 << 1) >> 1] = $13;
|
|
HEAP32[($11 << 2) + $9 >> 2] = $6;
|
|
break label$35;
|
|
}
|
|
HEAP32[($9 + 32 | 0) + $10 >> 2] = 1;
|
|
}
|
|
$12 = $12 + $14 | 0;
|
|
$11 = $8;
|
|
if (($40 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$21;
|
|
}
|
|
$14 = $16;
|
|
$16 = $14;
|
|
if (!$19) {
|
|
break label$20;
|
|
}
|
|
}
|
|
$10 = $39 - $23 | 0;
|
|
$6 = ((Math_imul($10, $4 - $25 | 0) | 0) / ($11 - $25 | 0) | 0) + $23 | 0;
|
|
$7 = $6 << 16 >> 16;
|
|
$10 = $10 >> 2;
|
|
$13 = $23 + $10 | 0;
|
|
if (($7 | 0) > ($13 | 0)) {
|
|
break label$19;
|
|
}
|
|
$10 = $39 - $10 | 0;
|
|
$13 = ($10 | 0) > ($7 | 0) ? $10 : $6;
|
|
break label$19;
|
|
}
|
|
celt_fatal(16895, 16942, 251);
|
|
abort();
|
|
}
|
|
celt_fatal(16972, 16942, 281);
|
|
abort();
|
|
}
|
|
$10 = silk_log2lin((($11 - $4 << 7) / HEAP32[$0 + 4584 >> 2] | 0) + 2048 | 0);
|
|
$13 = (Math_imul($10 & 65535, $23) >>> 16 | 0) + Math_imul($10 >> 16, $23) | 0;
|
|
$25 = $11;
|
|
$11 = $22;
|
|
$27 = $16;
|
|
break label$19;
|
|
}
|
|
$11 = $22;
|
|
}
|
|
$14 = $16;
|
|
$13 = $13 << 16 >> 16 < 16384 ? $13 << 1 : 32767;
|
|
}
|
|
$10 = 0;
|
|
$12 = HEAP32[$0 + 4580 >> 2];
|
|
if (($12 | 0) >= 1) {
|
|
while (1) {
|
|
$7 = $13;
|
|
$6 = $10 << 2;
|
|
$7 = HEAP32[$6 + ($9 + 32 | 0) >> 2] ? HEAPU16[($9 + 24 | 0) + ($10 << 1) >> 1] : $7;
|
|
$8 = ($9 + 1328 | 0) + $6 | 0;
|
|
$7 = $7 << 16 >> 16;
|
|
$6 = HEAP32[($9 + $6 | 0) + 9208 >> 2];
|
|
$6 = (Math_imul($7, $6 & 65535) >> 16) + Math_imul($6 >> 16, $7) | 0;
|
|
$6 = ($6 | 0) > -8388608 ? $6 : -8388608;
|
|
HEAP32[$8 >> 2] = (($6 | 0) < 8388607 ? $6 : 8388607) << 8;
|
|
$10 = $10 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP8[$0 + 7168 | 0] = HEAPU8[$9 + 9224 | 0];
|
|
silk_gains_quant($20, $9 + 1328 | 0, $26, $34, $12);
|
|
$16 = silk_gains_ID($20, HEAP32[$0 + 4580 >> 2]);
|
|
$10 = 0;
|
|
$7 = HEAP32[$0 + 4580 >> 2];
|
|
if (($7 | 0) >= 1) {
|
|
while (1) {
|
|
$6 = $10 << 2;
|
|
HEAPF32[$6 + ($9 + 8480 | 0) >> 2] = Math_fround(HEAP32[($9 + 1328 | 0) + $6 >> 2]) * Math_fround(152587890625e-16);
|
|
$10 = $10 + 1 | 0;
|
|
if (($7 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$17 = $17 + 1 | 0;
|
|
$22 = $11;
|
|
continue;
|
|
}
|
|
}
|
|
memmove($28, ((HEAP32[$0 + 4584 >> 2] << 2) + $0 | 0) + 7180 | 0, HEAP32[$0 + 4592 >> 2] + Math_imul(HEAP32[$0 + 4576 >> 2], 5) << 2);
|
|
$10 = 0;
|
|
if (!HEAP32[$0 + 4680 >> 2]) {
|
|
$10 = HEAP32[((HEAP32[$0 + 4580 >> 2] << 2) + $9 | 0) + 8704 >> 2];
|
|
HEAP32[$0 + 4664 >> 2] = 0;
|
|
HEAP8[$0 + 4541 | 0] = HEAPU8[$0 + 4765 | 0];
|
|
HEAP32[$0 + 4544 >> 2] = $10;
|
|
$10 = (HEAP32[$2 + 20 >> 2] + Math_clz32(HEAP32[$2 + 28 >> 2]) | 0) - 25 >> 3;
|
|
}
|
|
HEAP32[$1 >> 2] = $10;
|
|
__stack_pointer = $9 + 13584 | 0;
|
|
return 0;
|
|
}
|
|
function printf_core($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0;
|
|
$7 = __stack_pointer - 80 | 0;
|
|
__stack_pointer = $7;
|
|
HEAP32[$7 + 76 >> 2] = $1;
|
|
$22 = $7 + 55 | 0;
|
|
$20 = $7 + 56 | 0;
|
|
$1 = 0;
|
|
label$1 : {
|
|
label$2 : while (1) {
|
|
label$3 : {
|
|
if (($17 | 0) < 0) {
|
|
break label$3;
|
|
}
|
|
if ((2147483647 - $17 | 0) < ($1 | 0)) {
|
|
HEAP32[__errno_location() >> 2] = 61;
|
|
$17 = -1;
|
|
break label$3;
|
|
}
|
|
$17 = $1 + $17 | 0;
|
|
}
|
|
label$5 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
$13 = HEAP32[$7 + 76 >> 2];
|
|
$1 = $13;
|
|
$8 = HEAPU8[$1 | 0];
|
|
if ($8) {
|
|
while (1) {
|
|
label$11 : {
|
|
$8 = $8 & 255;
|
|
label$12 : {
|
|
if (!$8) {
|
|
$8 = $1;
|
|
break label$12;
|
|
}
|
|
if (($8 | 0) != 37) {
|
|
break label$11;
|
|
}
|
|
$8 = $1;
|
|
while (1) {
|
|
if (HEAPU8[$1 + 1 | 0] != 37) {
|
|
break label$12;
|
|
}
|
|
$9 = $1 + 2 | 0;
|
|
HEAP32[$7 + 76 >> 2] = $9;
|
|
$8 = $8 + 1 | 0;
|
|
$12 = HEAPU8[$1 + 2 | 0];
|
|
$1 = $9;
|
|
if (($12 | 0) == 37) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = $8 - $13 | 0;
|
|
if ($0) {
|
|
out($0, $13, $1);
|
|
}
|
|
if ($1) {
|
|
continue label$2;
|
|
}
|
|
$1 = isdigit(HEAP8[HEAP32[$7 + 76 >> 2] + 1 | 0]);
|
|
$10 = $7;
|
|
$8 = HEAP32[$7 + 76 >> 2];
|
|
label$16 : {
|
|
if (!(!$1 | HEAPU8[$8 + 2 | 0] != 36)) {
|
|
$21 = 1;
|
|
$1 = $8 + 3 | 0;
|
|
$19 = HEAP8[$8 + 1 | 0] - 48 | 0;
|
|
break label$16;
|
|
}
|
|
$1 = $8 + 1 | 0;
|
|
$19 = -1;
|
|
}
|
|
HEAP32[$10 + 76 >> 2] = $1;
|
|
$18 = 0;
|
|
$12 = HEAP8[$1 | 0];
|
|
$9 = $12 - 32 | 0;
|
|
label$18 : {
|
|
if ($9 >>> 0 > 31) {
|
|
$8 = $1;
|
|
break label$18;
|
|
}
|
|
$8 = $1;
|
|
$9 = 1 << $9;
|
|
if (!($9 & 75913)) {
|
|
break label$18;
|
|
}
|
|
while (1) {
|
|
$8 = $1 + 1 | 0;
|
|
HEAP32[$7 + 76 >> 2] = $8;
|
|
$18 = $9 | $18;
|
|
$12 = HEAP8[$1 + 1 | 0];
|
|
$9 = $12 - 32 | 0;
|
|
if ($9 >>> 0 >= 32) {
|
|
break label$18;
|
|
}
|
|
$1 = $8;
|
|
$9 = 1 << $9;
|
|
if ($9 & 75913) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$21 : {
|
|
if (($12 | 0) == 42) {
|
|
$10 = $7;
|
|
label$23 : {
|
|
label$24 : {
|
|
if (!isdigit(HEAP8[$8 + 1 | 0])) {
|
|
break label$24;
|
|
}
|
|
$8 = HEAP32[$7 + 76 >> 2];
|
|
if (HEAPU8[$8 + 2 | 0] != 36) {
|
|
break label$24;
|
|
}
|
|
HEAP32[((HEAP8[$8 + 1 | 0] << 2) + $4 | 0) - 192 >> 2] = 10;
|
|
$15 = HEAP32[((HEAP8[$8 + 1 | 0] << 3) + $3 | 0) - 384 >> 2];
|
|
$21 = 1;
|
|
$1 = $8 + 3 | 0;
|
|
break label$23;
|
|
}
|
|
if ($21) {
|
|
break label$8;
|
|
}
|
|
$21 = 0;
|
|
$15 = 0;
|
|
if ($0) {
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$15 = HEAP32[$1 >> 2];
|
|
}
|
|
$1 = HEAP32[$7 + 76 >> 2] + 1 | 0;
|
|
}
|
|
HEAP32[$10 + 76 >> 2] = $1;
|
|
if (($15 | 0) > -1) {
|
|
break label$21;
|
|
}
|
|
$15 = 0 - $15 | 0;
|
|
$18 = $18 | 8192;
|
|
break label$21;
|
|
}
|
|
$15 = getint($7 + 76 | 0);
|
|
if (($15 | 0) < 0) {
|
|
break label$8;
|
|
}
|
|
$1 = HEAP32[$7 + 76 >> 2];
|
|
}
|
|
$11 = -1;
|
|
label$26 : {
|
|
if (HEAPU8[$1 | 0] != 46) {
|
|
break label$26;
|
|
}
|
|
if (HEAPU8[$1 + 1 | 0] == 42) {
|
|
label$28 : {
|
|
if (!isdigit(HEAP8[$1 + 2 | 0])) {
|
|
break label$28;
|
|
}
|
|
$1 = HEAP32[$7 + 76 >> 2];
|
|
if (HEAPU8[$1 + 3 | 0] != 36) {
|
|
break label$28;
|
|
}
|
|
HEAP32[((HEAP8[$1 + 2 | 0] << 2) + $4 | 0) - 192 >> 2] = 10;
|
|
$11 = HEAP32[((HEAP8[$1 + 2 | 0] << 3) + $3 | 0) - 384 >> 2];
|
|
$1 = $1 + 4 | 0;
|
|
HEAP32[$7 + 76 >> 2] = $1;
|
|
break label$26;
|
|
}
|
|
if ($21) {
|
|
break label$8;
|
|
}
|
|
if ($0) {
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$11 = HEAP32[$1 >> 2];
|
|
} else {
|
|
$11 = 0;
|
|
}
|
|
$1 = HEAP32[$7 + 76 >> 2] + 2 | 0;
|
|
HEAP32[$7 + 76 >> 2] = $1;
|
|
break label$26;
|
|
}
|
|
HEAP32[$7 + 76 >> 2] = $1 + 1;
|
|
$11 = getint($7 + 76 | 0);
|
|
$1 = HEAP32[$7 + 76 >> 2];
|
|
}
|
|
$8 = 0;
|
|
while (1) {
|
|
$9 = $8;
|
|
$16 = -1;
|
|
if (HEAP8[$1 | 0] - 65 >>> 0 > 57) {
|
|
break label$1;
|
|
}
|
|
$12 = $1 + 1 | 0;
|
|
HEAP32[$7 + 76 >> 2] = $12;
|
|
$8 = HEAP8[$1 | 0];
|
|
$1 = $12;
|
|
$8 = HEAPU8[(Math_imul($9, 58) + $8 | 0) + 1071 | 0];
|
|
if ($8 - 1 >>> 0 < 8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
label$32 : {
|
|
label$33 : {
|
|
if (($8 | 0) != 19) {
|
|
if (!$8) {
|
|
break label$1;
|
|
}
|
|
if (($19 | 0) >= 0) {
|
|
HEAP32[($19 << 2) + $4 >> 2] = $8;
|
|
$10 = ($19 << 3) + $3 | 0;
|
|
$14 = HEAP32[$10 >> 2];
|
|
$10 = HEAP32[$10 + 4 >> 2];
|
|
HEAP32[$7 + 64 >> 2] = $14;
|
|
HEAP32[$7 + 68 >> 2] = $10;
|
|
break label$33;
|
|
}
|
|
if (!$0) {
|
|
break label$5;
|
|
}
|
|
pop_arg($7 - -64 | 0, $8, $2, $6);
|
|
$12 = HEAP32[$7 + 76 >> 2];
|
|
break label$32;
|
|
}
|
|
if (($19 | 0) > -1) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$1 = 0;
|
|
if (!$0) {
|
|
continue label$2;
|
|
}
|
|
}
|
|
$14 = $18 & -65537;
|
|
$8 = $18 & 8192 ? $14 : $18;
|
|
$16 = 0;
|
|
$19 = 1116;
|
|
$18 = $20;
|
|
label$36 : {
|
|
label$37 : {
|
|
label$38 : {
|
|
label$39 : {
|
|
label$40 : {
|
|
label$41 : {
|
|
label$42 : {
|
|
label$43 : {
|
|
label$44 : {
|
|
label$45 : {
|
|
label$46 : {
|
|
label$47 : {
|
|
label$48 : {
|
|
label$49 : {
|
|
label$50 : {
|
|
label$51 : {
|
|
$1 = HEAP8[$12 - 1 | 0];
|
|
$1 = $9 ? ($1 & 15) == 3 ? $1 & -33 : $1 : $1;
|
|
switch ($1 - 88 | 0) {
|
|
case 11:
|
|
break label$36;
|
|
case 9:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
break label$37;
|
|
case 27:
|
|
break label$42;
|
|
case 12:
|
|
case 17:
|
|
break label$45;
|
|
case 23:
|
|
break label$46;
|
|
case 0:
|
|
case 32:
|
|
break label$47;
|
|
case 24:
|
|
break label$48;
|
|
case 22:
|
|
break label$49;
|
|
case 29:
|
|
break label$50;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 10:
|
|
case 16:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 25:
|
|
case 26:
|
|
case 28:
|
|
case 30:
|
|
case 31:
|
|
break label$7;
|
|
default:
|
|
break label$51;
|
|
}
|
|
}
|
|
label$52 : {
|
|
switch ($1 - 65 | 0) {
|
|
case 0:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
break label$37;
|
|
case 2:
|
|
break label$40;
|
|
case 1:
|
|
case 3:
|
|
break label$7;
|
|
default:
|
|
break label$52;
|
|
}
|
|
}
|
|
if (($1 | 0) == 83) {
|
|
break label$41;
|
|
}
|
|
break label$7;
|
|
}
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
$9 = $10;
|
|
$14 = HEAP32[$7 + 68 >> 2];
|
|
$1 = $14;
|
|
$19 = 1116;
|
|
break label$44;
|
|
}
|
|
$1 = 0;
|
|
label$53 : {
|
|
switch ($9 & 255) {
|
|
case 0:
|
|
HEAP32[HEAP32[$7 + 64 >> 2] >> 2] = $17;
|
|
continue label$2;
|
|
case 1:
|
|
HEAP32[HEAP32[$7 + 64 >> 2] >> 2] = $17;
|
|
continue label$2;
|
|
case 2:
|
|
$10 = $17;
|
|
$14 = $10 >> 31;
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
HEAP32[$10 >> 2] = $17;
|
|
HEAP32[$10 + 4 >> 2] = $14;
|
|
continue label$2;
|
|
case 3:
|
|
HEAP16[HEAP32[$7 + 64 >> 2] >> 1] = $17;
|
|
continue label$2;
|
|
case 4:
|
|
HEAP8[HEAP32[$7 + 64 >> 2]] = $17;
|
|
continue label$2;
|
|
case 6:
|
|
HEAP32[HEAP32[$7 + 64 >> 2] >> 2] = $17;
|
|
continue label$2;
|
|
case 7:
|
|
break label$53;
|
|
default:
|
|
continue label$2;
|
|
}
|
|
}
|
|
$10 = $17;
|
|
$14 = $10 >> 31;
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
HEAP32[$10 >> 2] = $17;
|
|
HEAP32[$10 + 4 >> 2] = $14;
|
|
continue label$2;
|
|
}
|
|
$11 = $11 >>> 0 > 8 ? $11 : 8;
|
|
$8 = $8 | 8;
|
|
$1 = 120;
|
|
}
|
|
$14 = HEAP32[$7 + 64 >> 2];
|
|
$10 = HEAP32[$7 + 68 >> 2];
|
|
$13 = fmt_x($14, $10, $20, $1 & 32);
|
|
if (!($8 & 8)) {
|
|
break label$43;
|
|
}
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
$14 = HEAP32[$7 + 68 >> 2];
|
|
if (!($10 | $14)) {
|
|
break label$43;
|
|
}
|
|
$19 = ($1 >>> 4 | 0) + 1116 | 0;
|
|
$16 = 2;
|
|
break label$43;
|
|
}
|
|
$14 = HEAP32[$7 + 64 >> 2];
|
|
$10 = HEAP32[$7 + 68 >> 2];
|
|
$13 = fmt_o($14, $10, $20);
|
|
if (!($8 & 8)) {
|
|
break label$43;
|
|
}
|
|
$1 = $20 - $13 | 0;
|
|
$11 = ($1 | 0) < ($11 | 0) ? $11 : $1 + 1 | 0;
|
|
break label$43;
|
|
}
|
|
$14 = HEAP32[$7 + 68 >> 2];
|
|
$1 = $14;
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
$9 = $10;
|
|
if (($14 | 0) < -1 ? 1 : ($14 | 0) <= -1) {
|
|
$10 = $9;
|
|
$9 = 0 - $10 | 0;
|
|
$14 = $1;
|
|
$10 = $14 + (($10 | 0) != 0) | 0;
|
|
$10 = 0 - $10 | 0;
|
|
$1 = $10;
|
|
HEAP32[$7 + 64 >> 2] = $9;
|
|
HEAP32[$7 + 68 >> 2] = $10;
|
|
$16 = 1;
|
|
$19 = 1116;
|
|
break label$44;
|
|
}
|
|
if ($8 & 2048) {
|
|
$16 = 1;
|
|
$19 = 1117;
|
|
break label$44;
|
|
}
|
|
$16 = $8 & 1;
|
|
$19 = $16 ? 1118 : 1116;
|
|
}
|
|
$10 = $1;
|
|
$13 = fmt_u($9, $10, $20);
|
|
}
|
|
$8 = ($11 | 0) > -1 ? $8 & -65537 : $8;
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
$9 = $10;
|
|
$1 = HEAP32[$7 + 68 >> 2];
|
|
if (!(!!($10 | $1) | $11)) {
|
|
$11 = 0;
|
|
$13 = $20;
|
|
break label$7;
|
|
}
|
|
$1 = !($9 | $1) + ($20 - $13 | 0) | 0;
|
|
$11 = ($1 | 0) < ($11 | 0) ? $11 : $1;
|
|
break label$7;
|
|
}
|
|
$1 = HEAP32[$7 + 64 >> 2];
|
|
$13 = $1 ? $1 : 1126;
|
|
$1 = memchr($13, 0, $11);
|
|
$18 = $1 ? $1 : $11 + $13 | 0;
|
|
$8 = $14;
|
|
$11 = $1 ? $1 - $13 | 0 : $11;
|
|
break label$7;
|
|
}
|
|
$9 = HEAP32[$7 + 64 >> 2];
|
|
if ($11) {
|
|
break label$39;
|
|
}
|
|
$1 = 0;
|
|
pad($0, 32, $15, 0, $8);
|
|
break label$38;
|
|
}
|
|
HEAP32[$7 + 12 >> 2] = 0;
|
|
HEAP32[$7 + 8 >> 2] = HEAP32[$7 + 64 >> 2];
|
|
HEAP32[$7 + 64 >> 2] = $7 + 8;
|
|
$11 = -1;
|
|
$9 = $7 + 8 | 0;
|
|
}
|
|
$1 = 0;
|
|
label$64 : {
|
|
while (1) {
|
|
$12 = HEAP32[$9 >> 2];
|
|
if (!$12) {
|
|
break label$64;
|
|
}
|
|
$12 = wctomb($7 + 4 | 0, $12);
|
|
$13 = ($12 | 0) < 0;
|
|
if (!($13 | $11 - $1 >>> 0 < $12 >>> 0)) {
|
|
$9 = $9 + 4 | 0;
|
|
$1 = $1 + $12 | 0;
|
|
if ($11 >>> 0 > $1 >>> 0) {
|
|
continue;
|
|
}
|
|
break label$64;
|
|
}
|
|
break;
|
|
}
|
|
$16 = -1;
|
|
if ($13) {
|
|
break label$1;
|
|
}
|
|
}
|
|
pad($0, 32, $15, $1, $8);
|
|
if (!$1) {
|
|
$1 = 0;
|
|
break label$38;
|
|
}
|
|
$9 = 0;
|
|
$12 = HEAP32[$7 + 64 >> 2];
|
|
while (1) {
|
|
$13 = HEAP32[$12 >> 2];
|
|
if (!$13) {
|
|
break label$38;
|
|
}
|
|
$13 = wctomb($7 + 4 | 0, $13);
|
|
$9 = $13 + $9 | 0;
|
|
if (($9 | 0) > ($1 | 0)) {
|
|
break label$38;
|
|
}
|
|
out($0, $7 + 4 | 0, $13);
|
|
$12 = $12 + 4 | 0;
|
|
if ($1 >>> 0 > $9 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
pad($0, 32, $15, $1, $8 ^ 8192);
|
|
$1 = ($1 | 0) < ($15 | 0) ? $15 : $1;
|
|
continue label$2;
|
|
}
|
|
$1 = FUNCTION_TABLE[$5 | 0]($0, HEAPF64[$7 + 64 >> 3], $15, $11, $8, $1) | 0;
|
|
continue label$2;
|
|
}
|
|
$10 = HEAP32[$7 + 64 >> 2];
|
|
HEAP8[$7 + 55 | 0] = $10;
|
|
$11 = 1;
|
|
$13 = $22;
|
|
$8 = $14;
|
|
break label$7;
|
|
}
|
|
$9 = $1 + 1 | 0;
|
|
HEAP32[$7 + 76 >> 2] = $9;
|
|
$8 = HEAPU8[$1 + 1 | 0];
|
|
$1 = $9;
|
|
continue;
|
|
}
|
|
}
|
|
$16 = $17;
|
|
if ($0) {
|
|
break label$1;
|
|
}
|
|
if (!$21) {
|
|
break label$5;
|
|
}
|
|
$1 = 1;
|
|
while (1) {
|
|
$8 = HEAP32[($1 << 2) + $4 >> 2];
|
|
if ($8) {
|
|
pop_arg(($1 << 3) + $3 | 0, $8, $2, $6);
|
|
$16 = 1;
|
|
$1 = $1 + 1 | 0;
|
|
if (($1 | 0) != 10) {
|
|
continue;
|
|
}
|
|
break label$1;
|
|
}
|
|
break;
|
|
}
|
|
$16 = 1;
|
|
if ($1 >>> 0 >= 10) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
if (HEAP32[($1 << 2) + $4 >> 2]) {
|
|
break label$8;
|
|
}
|
|
$1 = $1 + 1 | 0;
|
|
if (($1 | 0) != 10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
$16 = -1;
|
|
break label$1;
|
|
}
|
|
$12 = $18 - $13 | 0;
|
|
$18 = ($11 | 0) < ($12 | 0) ? $12 : $11;
|
|
$9 = $18 + $16 | 0;
|
|
$1 = ($9 | 0) > ($15 | 0) ? $9 : $15;
|
|
pad($0, 32, $1, $9, $8);
|
|
out($0, $19, $16);
|
|
pad($0, 48, $1, $9, $8 ^ 65536);
|
|
pad($0, 48, $18, $12, 0);
|
|
out($0, $13, $12);
|
|
pad($0, 32, $1, $9, $8 ^ 8192);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$16 = 0;
|
|
}
|
|
__stack_pointer = $7 + 80 | 0;
|
|
return $16;
|
|
}
|
|
function silk_NSQ_del_dec_c($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) {
|
|
var $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0;
|
|
$15 = __stack_pointer - 176 | 0;
|
|
$28 = $15;
|
|
__stack_pointer = $15;
|
|
$30 = HEAP32[$1 + 4328 >> 2];
|
|
$15 = $15 - (Math_imul(HEAP32[$0 + 4628 >> 2], 1300) + 15 & -16) | 0;
|
|
$29 = $15;
|
|
__stack_pointer = $15;
|
|
$21 = HEAP32[$0 + 4628 >> 2];
|
|
$27 = memset($15, 0, Math_imul($21, 1300));
|
|
if (($21 | 0) >= 1) {
|
|
$17 = $1 + 4224 | 0;
|
|
$16 = $1 + 3840 | 0;
|
|
$22 = HEAP32[((HEAP32[$0 + 4592 >> 2] << 2) + $1 | 0) + 1276 >> 2];
|
|
$24 = HEAP32[$1 + 4324 >> 2];
|
|
$25 = HEAP32[$1 + 4320 >> 2];
|
|
$31 = HEAPU8[$2 + 34 | 0];
|
|
while (1) {
|
|
$15 = Math_imul($18, 1300) + $27 | 0;
|
|
HEAP32[$15 + 1296 >> 2] = 0;
|
|
$19 = $18 + $31 & 3;
|
|
HEAP32[$15 + 1292 >> 2] = $19;
|
|
HEAP32[$15 + 1288 >> 2] = $19;
|
|
HEAP32[$15 + 1284 >> 2] = $24;
|
|
HEAP32[$15 + 1280 >> 2] = $25;
|
|
HEAP32[$15 + 1024 >> 2] = $22;
|
|
$20 = HEAP32[$16 + 4 >> 2];
|
|
$23 = HEAP32[$16 >> 2];
|
|
HEAP32[$15 >> 2] = $23;
|
|
HEAP32[$15 + 4 >> 2] = $20;
|
|
$23 = HEAP32[$16 + 12 >> 2];
|
|
$20 = HEAP32[$16 + 8 >> 2];
|
|
HEAP32[$15 + 8 >> 2] = $20;
|
|
HEAP32[$15 + 12 >> 2] = $23;
|
|
$20 = HEAP32[$16 + 20 >> 2];
|
|
$23 = HEAP32[$16 + 16 >> 2];
|
|
HEAP32[$15 + 16 >> 2] = $23;
|
|
HEAP32[$15 + 20 >> 2] = $20;
|
|
$23 = HEAP32[$16 + 28 >> 2];
|
|
$20 = HEAP32[$16 + 24 >> 2];
|
|
HEAP32[$15 + 24 >> 2] = $20;
|
|
HEAP32[$15 + 28 >> 2] = $23;
|
|
$20 = HEAP32[$16 + 36 >> 2];
|
|
$23 = HEAP32[$16 + 32 >> 2];
|
|
HEAP32[$15 + 32 >> 2] = $23;
|
|
HEAP32[$15 + 36 >> 2] = $20;
|
|
$23 = HEAP32[$16 + 44 >> 2];
|
|
$20 = HEAP32[$16 + 40 >> 2];
|
|
HEAP32[$15 + 40 >> 2] = $20;
|
|
HEAP32[$15 + 44 >> 2] = $23;
|
|
$20 = HEAP32[$16 + 52 >> 2];
|
|
$23 = HEAP32[$16 + 48 >> 2];
|
|
HEAP32[$15 + 48 >> 2] = $23;
|
|
HEAP32[$15 + 52 >> 2] = $20;
|
|
$23 = HEAP32[$16 + 60 >> 2];
|
|
$20 = HEAP32[$16 + 56 >> 2];
|
|
HEAP32[$15 + 56 >> 2] = $20;
|
|
HEAP32[$15 + 60 >> 2] = $23;
|
|
memcpy($15 + 1184 | 0, $17, 96);
|
|
$18 = $18 + 1 | 0;
|
|
if (($21 | 0) != ($18 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$24 = HEAPU8[$2 + 29 | 0];
|
|
$17 = HEAP8[$2 + 30 | 0];
|
|
HEAP32[$28 + 172 >> 2] = 0;
|
|
$18 = HEAP32[$0 + 4588 >> 2];
|
|
$26 = ($18 | 0) < 40 ? $18 : 40;
|
|
label$3 : {
|
|
if (($24 | 0) == 2) {
|
|
$19 = HEAP32[$0 + 4580 >> 2];
|
|
if (($19 | 0) < 1) {
|
|
break label$3;
|
|
}
|
|
$15 = 0;
|
|
while (1) {
|
|
$16 = HEAP32[($15 << 2) + $12 >> 2] - 3 | 0;
|
|
$26 = ($16 | 0) > ($26 | 0) ? $26 : $16;
|
|
$15 = $15 + 1 | 0;
|
|
if (($19 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$3;
|
|
}
|
|
if (($30 | 0) < 1) {
|
|
break label$3;
|
|
}
|
|
$15 = $30 - 3 | 0;
|
|
$26 = ($15 | 0) > ($26 | 0) ? $26 : $15;
|
|
}
|
|
$22 = HEAPU8[$2 + 31 | 0];
|
|
$15 = HEAP32[$0 + 4592 >> 2];
|
|
$16 = $15 + HEAP32[$0 + 4584 >> 2] | 0;
|
|
$35 = $29 - (($16 << 2) + 15 & -16) | 0;
|
|
$19 = $35;
|
|
__stack_pointer = $19;
|
|
$38 = $19 - (($16 << 1) + 15 & -16) | 0;
|
|
$16 = $38;
|
|
__stack_pointer = $16;
|
|
$31 = $16 - (($18 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $31;
|
|
HEAP32[$1 + 4332 >> 2] = $15;
|
|
HEAP32[$1 + 4336 >> 2] = $15;
|
|
$32 = ($15 << 1) + $1 | 0;
|
|
label$6 : {
|
|
$25 = HEAP32[$0 + 4580 >> 2];
|
|
if (($25 | 0) >= 1) {
|
|
$46 = HEAP16[(($24 << 24 >> 24 << 1 & -4) + ($17 << 1) | 0) + 5840 >> 1];
|
|
$42 = ($22 & 255) == 4;
|
|
$47 = $42 ? 3 : 1;
|
|
$43 = $14 << 16 >> 16;
|
|
$14 = 0;
|
|
while (1) {
|
|
$33 = $14 << 2;
|
|
$25 = HEAP32[$33 + $8 >> 2];
|
|
HEAP32[$1 + 4348 >> 2] = 0;
|
|
$36 = 1;
|
|
$44 = (($14 >>> 1 | $42) << 5) + $5 | 0;
|
|
label$9 : {
|
|
if (($24 & 255) != 2) {
|
|
break label$9;
|
|
}
|
|
$24 = 2;
|
|
$30 = HEAP32[($14 << 2) + $12 >> 2];
|
|
if ($14 & $47) {
|
|
break label$9;
|
|
}
|
|
label$10 : {
|
|
if (($14 | 0) != 2) {
|
|
break label$10;
|
|
}
|
|
$16 = 0;
|
|
$15 = 0;
|
|
$21 = HEAP32[$0 + 4628 >> 2];
|
|
if (($21 | 0) >= 2) {
|
|
$19 = HEAP32[$27 + 1296 >> 2];
|
|
$18 = 1;
|
|
while (1) {
|
|
$17 = HEAP32[(Math_imul($18, 1300) + $27 | 0) + 1296 >> 2];
|
|
$20 = $17;
|
|
$17 = ($19 | 0) > ($17 | 0);
|
|
$19 = $17 ? $20 : $19;
|
|
$15 = $17 ? $18 : $15;
|
|
$18 = $18 + 1 | 0;
|
|
if (($21 | 0) != ($18 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($21 | 0) > 0) {
|
|
while (1) {
|
|
if (($15 | 0) != ($16 | 0)) {
|
|
$18 = Math_imul($16, 1300) + $27 | 0;
|
|
HEAP32[$18 + 1296 >> 2] = HEAP32[$18 + 1296 >> 2] + 134217727;
|
|
}
|
|
$16 = $16 + 1 | 0;
|
|
if (($21 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($26 | 0) < 1) {
|
|
$37 = 0;
|
|
break label$10;
|
|
}
|
|
$17 = HEAP32[$28 + 172 >> 2] + $26 | 0;
|
|
$37 = 0;
|
|
$16 = 0;
|
|
while (1) {
|
|
$18 = $16 - $26 | 0;
|
|
$19 = ($17 - 1 | 0) % 40 | 0;
|
|
$17 = ($19 | 0) < 0 ? $19 + 40 | 0 : $19;
|
|
$19 = (Math_imul($15, 1300) + $27 | 0) + ($17 << 2) | 0;
|
|
HEAP8[$18 + $4 | 0] = (HEAP32[$19 + 544 >> 2] >>> 9 | 0) + 1 >>> 1;
|
|
$22 = HEAP32[$11 + 4 >> 2];
|
|
$24 = $22 << 16 >> 16;
|
|
$21 = HEAP32[$19 + 704 >> 2];
|
|
$21 = ((Math_imul($24, $21 & 65535) >> 16) + Math_imul($21 >> 16, $24) | 0) + Math_imul(($22 >> 15) + 1 >> 1, $21) | 0;
|
|
HEAP16[($18 << 1) + $32 >> 1] = ($21 | 0) > 536862719 ? 32767 : ($21 | 0) < -536879104 ? -32768 : ($21 >>> 13 | 0) + 1 >>> 1 | 0;
|
|
HEAP32[((HEAP32[$1 + 4336 >> 2] + $18 << 2) + $1 | 0) + 1280 >> 2] = HEAP32[$19 + 1024 >> 2];
|
|
$16 = $16 + 1 | 0;
|
|
if (($26 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$16 = HEAP32[$0 + 4592 >> 2];
|
|
$18 = HEAP32[$0 + 4640 >> 2];
|
|
$15 = ($16 - $30 | 0) - $18 | 0;
|
|
if (($15 | 0) <= 2) {
|
|
break label$6;
|
|
}
|
|
$15 = $15 - 2 | 0;
|
|
silk_LPC_analysis_filter(($15 << 1) + $38 | 0, (Math_imul(HEAP32[$0 + 4588 >> 2], $14) + $15 << 1) + $1 | 0, $44, $16 - $15 | 0, $18, HEAP32[$0 + 5092 >> 2]);
|
|
$15 = HEAP32[$0 + 4592 >> 2];
|
|
HEAP32[$1 + 4348 >> 2] = 1;
|
|
HEAP32[$1 + 4332 >> 2] = $15;
|
|
$24 = HEAPU8[$2 + 29 | 0];
|
|
$36 = 0;
|
|
}
|
|
$39 = $11 + $33 | 0;
|
|
$22 = HEAP32[$39 >> 2];
|
|
$16 = ($22 | 0) > 1 ? $22 : 1;
|
|
$19 = Math_clz32($16);
|
|
$15 = $16 << $19 - 1;
|
|
$18 = $15 >> 16;
|
|
$21 = 536870911 / ($18 | 0) | 0;
|
|
$17 = ($21 >> 15) + 1 >> 1;
|
|
$20 = $15 & 65535;
|
|
$21 = $21 << 16;
|
|
$15 = $21 >> 16;
|
|
$18 = 0 - ((Math_imul($20, $15) >> 16) + Math_imul($15, $18) << 3) | 0;
|
|
$15 = ((Math_imul($18, $17) + $21 | 0) + Math_imul($18 >> 16, $15) | 0) + (Math_imul($18 & 65528, $15) >> 16) | 0;
|
|
$18 = 15 - $19 | 0;
|
|
$45 = HEAP32[$12 + $33 >> 2];
|
|
$29 = HEAP32[$0 + 4628 >> 2];
|
|
label$18 : {
|
|
if ($16 >>> 0 <= 131071) {
|
|
$16 = 0 - $18 | 0;
|
|
$18 = 2147483647 >>> $16 | 0;
|
|
$19 = -2147483648 >> $16;
|
|
$17 = (($15 | 0) > ($18 | 0) ? $18 : ($15 | 0) < ($19 | 0) ? $19 : $15) << $16;
|
|
break label$18;
|
|
}
|
|
$17 = $15 >> $18;
|
|
}
|
|
$34 = $25 << 15;
|
|
$19 = HEAP32[$0 + 4588 >> 2];
|
|
if (($19 | 0) >= 1) {
|
|
$15 = ($17 >> 4) + 1 | 0;
|
|
$18 = $15 << 15 >> 16;
|
|
$21 = ($15 >> 16) + 1 >> 1;
|
|
$15 = 0;
|
|
while (1) {
|
|
$16 = HEAP16[($15 << 1) + $3 >> 1];
|
|
HEAP32[($15 << 2) + $31 >> 2] = (Math_imul($16 >> 16, $18) + Math_imul($16, $21) | 0) + (Math_imul($16 & 65535, $18) >> 16);
|
|
$15 = $15 + 1 | 0;
|
|
if (($19 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$25 = $25 >> 2;
|
|
$34 = $34 & -65536;
|
|
$40 = Math_imul($14, 48);
|
|
$41 = Math_imul($14, 10);
|
|
$20 = $24 << 24;
|
|
label$22 : {
|
|
if ($36) {
|
|
break label$22;
|
|
}
|
|
$17 = $14 ? $17 : Math_imul($17 >> 16, $43) + (Math_imul($17 & 65535, $43) >> 16) << 2;
|
|
$18 = HEAP32[$1 + 4332 >> 2];
|
|
$15 = ($18 - $45 | 0) - 2 | 0;
|
|
if (($15 | 0) >= ($18 | 0)) {
|
|
break label$22;
|
|
}
|
|
$21 = $17 & 65535;
|
|
$17 = $17 >> 16;
|
|
while (1) {
|
|
$16 = HEAP16[($15 << 1) + $38 >> 1];
|
|
HEAP32[($15 << 2) + $35 >> 2] = (Math_imul($21, $16) >> 16) + Math_imul($16, $17);
|
|
$15 = $15 + 1 | 0;
|
|
if (($18 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$36 = $25 | $34;
|
|
$34 = $7 + $40 | 0;
|
|
$40 = $6 + $41 | 0;
|
|
$41 = $20 >> 24;
|
|
$15 = HEAP32[$1 + 4344 >> 2];
|
|
if (($22 | 0) != ($15 | 0)) {
|
|
$16 = $15 >> 31;
|
|
$18 = Math_clz32($16 ^ $15 + $16);
|
|
$16 = $15 << $18 - 1;
|
|
$25 = $16;
|
|
$15 = $22 >> 31;
|
|
$19 = Math_clz32($15 ^ $15 + $22);
|
|
$21 = $22 << $19 - 1;
|
|
$15 = 536870911 / ($21 >> 16) << 16 >> 16;
|
|
$16 = (Math_imul($15, $16 & 65535) >> 16) + Math_imul($16 >> 16, $15) | 0;
|
|
$23 = $16 >> 31;
|
|
$17 = $23;
|
|
$23 = $21 >> 31;
|
|
$20 = $23;
|
|
$23 = $17;
|
|
$20 = __wasm_i64_mul($16, $23, $21, $20);
|
|
$17 = $20;
|
|
$23 = i64toi32_i32$HIGH_BITS;
|
|
$21 = $25 - ((($23 & 536870911) << 3 | $17 >>> 29) & -8) | 0;
|
|
$15 = (Math_imul($21 >> 16, $15) + $16 | 0) + (Math_imul($21 & 65535, $15) >> 16) | 0;
|
|
$16 = $18 - $19 | 0;
|
|
$18 = $16 + 13 | 0;
|
|
$16 = $16 + 29 | 0;
|
|
label$26 : {
|
|
if (($16 | 0) <= 15) {
|
|
$16 = 0 - $18 | 0;
|
|
$18 = 2147483647 >>> $16 | 0;
|
|
$19 = -2147483648 >> $16;
|
|
$15 = (($15 | 0) > ($18 | 0) ? $18 : ($15 | 0) < ($19 | 0) ? $19 : $15) << $16;
|
|
break label$26;
|
|
}
|
|
$15 = ($16 | 0) < 48 ? $15 >> $18 : 0;
|
|
}
|
|
$16 = HEAP32[$0 + 4592 >> 2];
|
|
if (($16 | 0) >= 1) {
|
|
$21 = $15 & 65535;
|
|
$17 = $15 >> 16;
|
|
$16 = HEAP32[$1 + 4336 >> 2] - $16 | 0;
|
|
while (1) {
|
|
$18 = (($16 << 2) + $1 | 0) + 1280 | 0;
|
|
$20 = $18;
|
|
$18 = HEAP32[$18 >> 2];
|
|
$19 = $18 << 16 >> 16;
|
|
HEAP32[$20 >> 2] = ((Math_imul($21, $19) >> 16) + Math_imul($19, $17) | 0) + Math_imul(($18 >> 15) + 1 >> 1, $15);
|
|
$16 = $16 + 1 | 0;
|
|
if (($16 | 0) < HEAP32[$1 + 4336 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$30 : {
|
|
if (HEAP32[$1 + 4348 >> 2] | ($24 & 255) != 2) {
|
|
break label$30;
|
|
}
|
|
$18 = HEAP32[$1 + 4332 >> 2];
|
|
$16 = ($18 - $45 | 0) - 2 | 0;
|
|
$21 = $18 - $26 | 0;
|
|
if (($16 | 0) >= ($21 | 0)) {
|
|
break label$30;
|
|
}
|
|
$17 = $15 & 65535;
|
|
$22 = $15 >> 16;
|
|
while (1) {
|
|
$18 = ($16 << 2) + $35 | 0;
|
|
$20 = $18;
|
|
$18 = HEAP32[$18 >> 2];
|
|
$19 = $18 << 16 >> 16;
|
|
HEAP32[$20 >> 2] = ((Math_imul($17, $19) >> 16) + Math_imul($19, $22) | 0) + Math_imul(($18 >> 15) + 1 >> 1, $15);
|
|
$16 = $16 + 1 | 0;
|
|
if (($21 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($29 | 0) >= 1) {
|
|
$16 = $15 & 65535;
|
|
$18 = $15 >> 16;
|
|
$25 = 0;
|
|
while (1) {
|
|
$21 = Math_imul($25, 1300) + $27 | 0;
|
|
$19 = HEAP32[$21 + 1280 >> 2];
|
|
$17 = $19 << 16 >> 16;
|
|
HEAP32[$21 + 1280 >> 2] = (Math_imul($18, $17) + (Math_imul($16, $17) >> 16) | 0) + Math_imul(($19 >> 15) + 1 >> 1, $15);
|
|
$19 = HEAP32[$21 + 1284 >> 2];
|
|
$17 = $19 << 16 >> 16;
|
|
HEAP32[$21 + 1284 >> 2] = ((Math_imul($17, $16) >> 16) + Math_imul($18, $17) | 0) + Math_imul(($19 >> 15) + 1 >> 1, $15);
|
|
$17 = 0;
|
|
while (1) {
|
|
$19 = ($17 << 2) + $21 | 0;
|
|
$20 = $19;
|
|
$19 = HEAP32[$19 >> 2];
|
|
$22 = $19 << 16 >> 16;
|
|
HEAP32[$20 >> 2] = ((Math_imul($22, $16) >> 16) + Math_imul($18, $22) | 0) + Math_imul(($19 >> 15) + 1 >> 1, $15);
|
|
$19 = 0;
|
|
$17 = $17 + 1 | 0;
|
|
if (($17 | 0) != 16) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$17 = 0;
|
|
while (1) {
|
|
$22 = (($17 << 2) + $21 | 0) + 1184 | 0;
|
|
$20 = $22;
|
|
$22 = HEAP32[$22 >> 2];
|
|
$24 = $22 << 16 >> 16;
|
|
HEAP32[$20 >> 2] = ((Math_imul($24, $16) >> 16) + Math_imul($18, $24) | 0) + Math_imul(($22 >> 15) + 1 >> 1, $15);
|
|
$17 = $17 + 1 | 0;
|
|
if (($17 | 0) != 24) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
while (1) {
|
|
$17 = ($19 << 2) + $21 | 0;
|
|
$22 = $17 + 864 | 0;
|
|
$20 = $22;
|
|
$22 = HEAP32[$17 + 864 >> 2];
|
|
$24 = $22 << 16 >> 16;
|
|
HEAP32[$20 >> 2] = ((Math_imul($24, $16) >> 16) + Math_imul($18, $24) | 0) + Math_imul(($22 >> 15) + 1 >> 1, $15);
|
|
$17 = $17 + 1024 | 0;
|
|
$20 = $17;
|
|
$17 = HEAP32[$17 >> 2];
|
|
$22 = $17 << 16 >> 16;
|
|
HEAP32[$20 >> 2] = ((Math_imul($22, $16) >> 16) + Math_imul($18, $22) | 0) + Math_imul(($17 >> 15) + 1 >> 1, $15);
|
|
$19 = $19 + 1 | 0;
|
|
if (($19 | 0) != 40) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$25 = $25 + 1 | 0;
|
|
if (($29 | 0) != ($25 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$1 + 4344 >> 2] = HEAP32[$39 >> 2];
|
|
$29 = HEAP32[$0 + 4628 >> 2];
|
|
$22 = HEAP32[$39 >> 2];
|
|
$19 = HEAP32[$0 + 4588 >> 2];
|
|
}
|
|
silk_noise_shape_quantizer_del_dec($1, $27, $41, $31, $4, $32, $35, $28, $44, $40, $34, $30, $36, HEAP32[$9 + $33 >> 2], HEAP32[$10 + $33 >> 2], $22, $13, $46, $19, $37, HEAP32[$0 + 4636 >> 2], HEAP32[$0 + 4640 >> 2], HEAP32[$0 + 4672 >> 2], $29, $28 + 172 | 0, $26);
|
|
$18 = HEAP32[$0 + 4588 >> 2];
|
|
$4 = $18 + $4 | 0;
|
|
$15 = $18 << 1;
|
|
$32 = $32 + $15 | 0;
|
|
$14 = $14 + 1 | 0;
|
|
$25 = HEAP32[$0 + 4580 >> 2];
|
|
if (($14 | 0) < ($25 | 0)) {
|
|
$37 = $37 + 1 | 0;
|
|
$3 = $3 + $15 | 0;
|
|
$24 = HEAPU8[$2 + 29 | 0];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$21 = HEAP32[$0 + 4628 >> 2];
|
|
}
|
|
$19 = 0;
|
|
if (($21 | 0) >= 2) {
|
|
$16 = HEAP32[$27 + 1296 >> 2];
|
|
$15 = 1;
|
|
while (1) {
|
|
$17 = HEAP32[(Math_imul($15, 1300) + $27 | 0) + 1296 >> 2];
|
|
$3 = $17;
|
|
$17 = ($16 | 0) > ($17 | 0);
|
|
$16 = $17 ? $3 : $16;
|
|
$19 = $17 ? $15 : $19;
|
|
$15 = $15 + 1 | 0;
|
|
if (($21 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$22 = Math_imul($19, 1300) + $27 | 0;
|
|
HEAP8[$2 + 34 | 0] = HEAP32[$22 + 1292 >> 2];
|
|
if (($26 | 0) >= 1) {
|
|
$21 = HEAP32[$28 + 172 >> 2] + $26 | 0;
|
|
$15 = HEAP32[(($25 << 2) + $11 | 0) - 4 >> 2];
|
|
$17 = $15 << 10 >> 16;
|
|
$24 = ($15 >> 21) + 1 >> 1;
|
|
$15 = 0;
|
|
while (1) {
|
|
$16 = $15 - $26 | 0;
|
|
$18 = ($21 - 1 | 0) % 40 | 0;
|
|
$21 = ($18 | 0) < 0 ? $18 + 40 | 0 : $18;
|
|
$18 = ($21 << 2) + $22 | 0;
|
|
HEAP8[$16 + $4 | 0] = (HEAP32[$18 + 544 >> 2] >>> 9 | 0) + 1 >>> 1;
|
|
$19 = HEAP32[$18 + 704 >> 2];
|
|
$19 = (Math_imul($19 >> 16, $17) + Math_imul($19, $24) | 0) + (Math_imul($19 & 65535, $17) >> 16) | 0;
|
|
HEAP16[($16 << 1) + $32 >> 1] = ($19 | 0) > 8388479 ? 32767 : ($19 | 0) < -8388736 ? -32768 : ($19 >>> 7 | 0) + 1 >>> 1 | 0;
|
|
HEAP32[((HEAP32[$1 + 4336 >> 2] + $16 << 2) + $1 | 0) + 1280 >> 2] = HEAP32[$18 + 1024 >> 2];
|
|
$15 = $15 + 1 | 0;
|
|
if (($26 | 0) != ($15 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$18 = HEAP32[$0 + 4588 >> 2];
|
|
}
|
|
$15 = ($18 << 2) + $22 | 0;
|
|
$17 = HEAP32[$15 + 4 >> 2];
|
|
$20 = HEAP32[$15 >> 2];
|
|
HEAP32[$1 + 3840 >> 2] = $20;
|
|
HEAP32[$1 + 3844 >> 2] = $17;
|
|
$20 = HEAP32[$15 + 60 >> 2];
|
|
$17 = HEAP32[$15 + 56 >> 2];
|
|
$2 = $17;
|
|
$17 = $1 + 3896 | 0;
|
|
HEAP32[$17 >> 2] = $2;
|
|
HEAP32[$17 + 4 >> 2] = $20;
|
|
$17 = HEAP32[$15 + 52 >> 2];
|
|
$20 = HEAP32[$15 + 48 >> 2];
|
|
$2 = $20;
|
|
$20 = $1 + 3888 | 0;
|
|
HEAP32[$20 >> 2] = $2;
|
|
HEAP32[$20 + 4 >> 2] = $17;
|
|
$20 = HEAP32[$15 + 44 >> 2];
|
|
$17 = HEAP32[$15 + 40 >> 2];
|
|
$2 = $17;
|
|
$17 = $1 + 3880 | 0;
|
|
HEAP32[$17 >> 2] = $2;
|
|
HEAP32[$17 + 4 >> 2] = $20;
|
|
$17 = HEAP32[$15 + 36 >> 2];
|
|
$20 = HEAP32[$15 + 32 >> 2];
|
|
$2 = $20;
|
|
$20 = $1 + 3872 | 0;
|
|
HEAP32[$20 >> 2] = $2;
|
|
HEAP32[$20 + 4 >> 2] = $17;
|
|
$20 = HEAP32[$15 + 28 >> 2];
|
|
$17 = HEAP32[$15 + 24 >> 2];
|
|
$2 = $17;
|
|
$17 = $1 + 3864 | 0;
|
|
HEAP32[$17 >> 2] = $2;
|
|
HEAP32[$17 + 4 >> 2] = $20;
|
|
$17 = HEAP32[$15 + 20 >> 2];
|
|
$20 = HEAP32[$15 + 16 >> 2];
|
|
$2 = $20;
|
|
$20 = $1 + 3856 | 0;
|
|
HEAP32[$20 >> 2] = $2;
|
|
HEAP32[$20 + 4 >> 2] = $17;
|
|
$20 = HEAP32[$15 + 12 >> 2];
|
|
$17 = HEAP32[$15 + 8 >> 2];
|
|
$2 = $17;
|
|
$17 = $1 + 3848 | 0;
|
|
HEAP32[$17 >> 2] = $2;
|
|
HEAP32[$17 + 4 >> 2] = $20;
|
|
memcpy($1 + 4224 | 0, $22 + 1184 | 0, 96);
|
|
HEAP32[$1 + 4320 >> 2] = HEAP32[$22 + 1280 >> 2];
|
|
HEAP32[$1 + 4324 >> 2] = HEAP32[$22 + 1284 >> 2];
|
|
HEAP32[$1 + 4328 >> 2] = HEAP32[((HEAP32[$0 + 4580 >> 2] << 2) + $12 | 0) - 4 >> 2];
|
|
$15 = memmove($1, (HEAP32[$0 + 4584 >> 2] << 1) + $1 | 0, HEAP32[$0 + 4592 >> 2] << 1) + 1280 | 0;
|
|
memmove($15, (HEAP32[$0 + 4584 >> 2] << 2) + $15 | 0, HEAP32[$0 + 4592 >> 2] << 2);
|
|
__stack_pointer = $28 + 176 | 0;
|
|
return;
|
|
}
|
|
celt_fatal(16175, 16207, 253);
|
|
abort();
|
|
}
|
|
function silk_noise_shape_quantizer_del_dec($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25) {
|
|
var $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $54 = 0, $55 = 0, $56 = 0, $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $62 = 0, $63 = 0, $64 = 0, $65 = 0, $66 = 0, $67 = 0, $68 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0, $73 = 0, $74 = 0, $75 = 0, $76 = 0, $77 = 0;
|
|
$26 = __stack_pointer;
|
|
$63 = $26;
|
|
label$1 : {
|
|
if (($23 | 0) > 0) {
|
|
$30 = $26 - (Math_imul($23, 56) + 15 & -16) | 0;
|
|
__stack_pointer = $30;
|
|
if (($18 | 0) >= 1) {
|
|
$64 = $15 >> 6;
|
|
$31 = $16 << 16 >> 16;
|
|
$38 = Math_imul($31, $17 << 16 >> 16);
|
|
$39 = $17 + 944 | 0;
|
|
$42 = Math_imul($39 << 16 >> 16, $31);
|
|
$43 = $17 - 944 | 0;
|
|
$65 = Math_imul(0 - ($43 << 16) >> 16, $31);
|
|
$66 = $17 - 80 | 0;
|
|
$44 = $14 >> 16;
|
|
$67 = $20 >> 1;
|
|
$68 = $20 & 1;
|
|
$69 = $21 >> 1;
|
|
$45 = $12 >> 16;
|
|
$26 = $16 >>> 1 | 0;
|
|
$70 = 512 - $26 | 0;
|
|
$40 = $26 - 512 | 0;
|
|
$46 = $14 << 16 >> 16;
|
|
$47 = $13 << 16 >> 16;
|
|
$14 = $22 << 16 >> 16;
|
|
$48 = $12 << 16 >> 16;
|
|
$49 = $20 - 1 | 0;
|
|
$71 = ($49 << 1) + $10 | 0;
|
|
$34 = ((HEAP32[$0 + 4336 >> 2] - $11 << 2) + $0 | 0) + 1284 | 0;
|
|
$32 = ((HEAP32[$0 + 4332 >> 2] - $11 << 2) + $6 | 0) + 8 | 0;
|
|
$72 = ($2 | 0) != 2;
|
|
$73 = ($20 | 0) < 3;
|
|
$74 = ($16 | 0) < 2049;
|
|
$75 = ($19 | 0) > 0;
|
|
while (1) {
|
|
label$5 : {
|
|
if ($72) {
|
|
$37 = 0;
|
|
break label$5;
|
|
}
|
|
$12 = HEAP16[$9 >> 1];
|
|
$16 = HEAP32[$32 >> 2];
|
|
$2 = Math_imul($12, $16 >> 16) + (Math_imul($16 & 65535, $12) >> 16) | 0;
|
|
$12 = HEAP16[$9 + 2 >> 1];
|
|
$16 = HEAP32[$32 - 4 >> 2];
|
|
$2 = ($2 + Math_imul($12, $16 >> 16) | 0) + (Math_imul($16 & 65535, $12) >> 16) | 0;
|
|
$12 = HEAP16[$9 + 4 >> 1];
|
|
$16 = HEAP32[$32 - 8 >> 2];
|
|
$2 = ($2 + Math_imul($12, $16 >> 16) | 0) + (Math_imul($16 & 65535, $12) >> 16) | 0;
|
|
$12 = HEAP16[$9 + 6 >> 1];
|
|
$16 = HEAP32[$32 - 12 >> 2];
|
|
$2 = ($2 + Math_imul($12, $16 >> 16) | 0) + (Math_imul($16 & 65535, $12) >> 16) | 0;
|
|
$12 = HEAP16[$9 + 8 >> 1];
|
|
$16 = HEAP32[$32 - 16 >> 2];
|
|
$37 = (($2 + Math_imul($12, $16 >> 16) | 0) + (Math_imul($16 & 65535, $12) >> 16) << 1) + 4 | 0;
|
|
$32 = $32 + 4 | 0;
|
|
}
|
|
$35 = 0;
|
|
label$7 : {
|
|
if (($11 | 0) < 1) {
|
|
$50 = 0;
|
|
break label$7;
|
|
}
|
|
$16 = HEAP32[$34 - 4 >> 2];
|
|
$12 = HEAP32[$34 - 8 >> 2] + HEAP32[$34 >> 2] | 0;
|
|
$50 = $37 - (((Math_imul($16 >> 16, $45) + Math_imul($12 >> 16, $48) | 0) + (Math_imul($12 & 65535, $48) >> 16) | 0) + (Math_imul($16 & 65535, $45) >> 16) << 2) | 0;
|
|
$34 = $34 + 4 | 0;
|
|
}
|
|
$76 = $33 + 15 | 0;
|
|
$36 = $33 << 2;
|
|
$77 = $36 + $3 | 0;
|
|
$51 = HEAP16[$8 + 18 >> 1];
|
|
$52 = HEAP16[$8 + 16 >> 1];
|
|
$53 = HEAP16[$8 + 14 >> 1];
|
|
$54 = HEAP16[$8 + 12 >> 1];
|
|
$55 = HEAP16[$8 + 10 >> 1];
|
|
$56 = HEAP16[$8 + 8 >> 1];
|
|
$57 = HEAP16[$8 + 6 >> 1];
|
|
$58 = HEAP16[$8 + 4 >> 1];
|
|
$59 = HEAP16[$8 + 2 >> 1];
|
|
$60 = HEAP16[$8 >> 1];
|
|
while (1) {
|
|
$27 = Math_imul($35, 1300) + $1 | 0;
|
|
HEAP32[$27 + 1288 >> 2] = Math_imul(HEAP32[$27 + 1288 >> 2], 196314165) + 907633515;
|
|
$16 = ($76 << 2) + $27 | 0;
|
|
$12 = HEAP32[$16 >> 2];
|
|
$2 = (Math_imul($12 >> 16, $60) + $69 | 0) + (Math_imul($12 & 65535, $60) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 4 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $59) | 0) + (Math_imul($12 & 65535, $59) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 8 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $58) | 0) + (Math_imul($12 & 65535, $58) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 12 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $57) | 0) + (Math_imul($12 & 65535, $57) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 16 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $56) | 0) + (Math_imul($12 & 65535, $56) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 20 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $55) | 0) + (Math_imul($12 & 65535, $55) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 24 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $54) | 0) + (Math_imul($12 & 65535, $54) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 28 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $53) | 0) + (Math_imul($12 & 65535, $53) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 32 >> 2];
|
|
$2 = ($2 + Math_imul($12 >> 16, $52) | 0) + (Math_imul($12 & 65535, $52) >> 16) | 0;
|
|
$12 = HEAP32[$16 - 36 >> 2];
|
|
$12 = ($2 + Math_imul($12 >> 16, $51) | 0) + (Math_imul($12 & 65535, $51) >> 16) | 0;
|
|
if (($21 | 0) == 16) {
|
|
$2 = HEAP16[$8 + 20 >> 1];
|
|
$26 = HEAP32[$16 - 40 >> 2];
|
|
$2 = (Math_imul($2, $26 >> 16) + $12 | 0) + (Math_imul($26 & 65535, $2) >> 16) | 0;
|
|
$26 = HEAP16[$8 + 22 >> 1];
|
|
$12 = HEAP32[$16 - 44 >> 2];
|
|
$2 = ($2 + Math_imul($26, $12 >> 16) | 0) + (Math_imul($12 & 65535, $26) >> 16) | 0;
|
|
$26 = HEAP16[$8 + 24 >> 1];
|
|
$12 = HEAP32[$16 - 48 >> 2];
|
|
$2 = ($2 + Math_imul($26, $12 >> 16) | 0) + (Math_imul($12 & 65535, $26) >> 16) | 0;
|
|
$26 = HEAP16[$8 + 26 >> 1];
|
|
$12 = HEAP32[$16 - 52 >> 2];
|
|
$2 = ($2 + Math_imul($26, $12 >> 16) | 0) + (Math_imul($12 & 65535, $26) >> 16) | 0;
|
|
$12 = HEAP16[$8 + 28 >> 1];
|
|
$16 = HEAP32[$16 - 56 >> 2];
|
|
$2 = ($2 + Math_imul($12, $16 >> 16) | 0) + (Math_imul($16 & 65535, $12) >> 16) | 0;
|
|
$12 = HEAP16[$8 + 30 >> 1];
|
|
$16 = HEAP32[$27 + $36 >> 2];
|
|
$12 = ($2 + Math_imul($12, $16 >> 16) | 0) + (Math_imul($16 & 65535, $12) >> 16) | 0;
|
|
}
|
|
if ($68) {
|
|
break label$1;
|
|
}
|
|
$41 = $12 << 4;
|
|
$12 = HEAP32[$27 + 1184 >> 2];
|
|
$16 = (HEAP32[$27 + 1284 >> 2] + Math_imul($12 >> 16, $14) | 0) + (Math_imul($12 & 65535, $14) >> 16) | 0;
|
|
HEAP32[$27 + 1184 >> 2] = $16;
|
|
$26 = HEAP16[$10 >> 1];
|
|
$15 = (Math_imul($26, $16 >> 16) + $67 | 0) + (Math_imul($16 & 65535, $26) >> 16) | 0;
|
|
$16 = HEAP32[$27 + 1188 >> 2] - $16 | 0;
|
|
$16 = (Math_imul($16 >> 16, $14) + $12 | 0) + (Math_imul($16 & 65535, $14) >> 16) | 0;
|
|
$12 = 2;
|
|
if (!$73) {
|
|
while (1) {
|
|
$26 = $27 + 1184 | 0;
|
|
$13 = $12 - 1 | 0;
|
|
$19 = $26 + ($13 << 2) | 0;
|
|
$22 = HEAP32[$19 >> 2];
|
|
$28 = $12 << 2;
|
|
$29 = $28 + $26 | 0;
|
|
$2 = HEAP32[$29 >> 2];
|
|
HEAP32[$19 >> 2] = $16;
|
|
$19 = HEAP32[($28 | 4) + $26 >> 2];
|
|
$13 = HEAP16[($13 << 1) + $10 >> 1];
|
|
$26 = $2 - $16 | 0;
|
|
$26 = (Math_imul($26 >> 16, $14) + $22 | 0) + (Math_imul($26 & 65535, $14) >> 16) | 0;
|
|
HEAP32[$29 >> 2] = $26;
|
|
$13 = (Math_imul($16 >> 16, $13) + $15 | 0) + (Math_imul($16 & 65535, $13) >> 16) | 0;
|
|
$16 = HEAP16[($12 << 1) + $10 >> 1];
|
|
$15 = ($13 + Math_imul($16, $26 >> 16) | 0) + (Math_imul($26 & 65535, $16) >> 16) | 0;
|
|
$16 = $19 - $26 | 0;
|
|
$16 = (Math_imul($16 >> 16, $14) + $2 | 0) + (Math_imul($16 & 65535, $14) >> 16) | 0;
|
|
$12 = $12 + 2 | 0;
|
|
if (($20 | 0) > ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[(($49 << 2) + $27 | 0) + 1184 >> 2] = $16;
|
|
label$13 : {
|
|
label$14 : {
|
|
label$15 : {
|
|
label$16 : {
|
|
$61 = HEAP32[$77 >> 2];
|
|
$12 = HEAP32[$27 + 1280 >> 2];
|
|
$26 = $12 & 65535;
|
|
$12 = $12 >> 16;
|
|
$2 = HEAP16[$71 >> 1];
|
|
$13 = ((Math_imul($47, $26) >> 16) + Math_imul($47, $12) | 0) + ((Math_imul($2, $16 >> 16) + $15 | 0) + (Math_imul($16 & 65535, $2) >> 16) << 1) << 2;
|
|
$62 = HEAP32[$24 >> 2];
|
|
$16 = HEAP32[(($62 << 2) + $27 | 0) + 1024 >> 2];
|
|
$15 = ((Math_imul($12, $44) + (Math_imul($26, $44) >> 16) | 0) + Math_imul($16 >> 16, $46) | 0) + (Math_imul($16 & 65535, $46) >> 16) << 2;
|
|
$16 = $61 - (((($41 + $50 | 0) - $13 | 0) - $15 >> 3) + 1 >> 1) | 0;
|
|
$19 = HEAP32[$27 + 1288 >> 2] < 0;
|
|
$16 = $19 ? 0 - $16 | 0 : $16;
|
|
$16 = ($16 | 0) > -31744 ? $16 : -31744;
|
|
$2 = ($16 | 0) < 30720 ? $16 : 30720;
|
|
$16 = $2 - $17 | 0;
|
|
$12 = $16;
|
|
label$17 : {
|
|
if ($74) {
|
|
break label$17;
|
|
}
|
|
$12 = $16 - $40 | 0;
|
|
if (($16 | 0) > ($40 | 0)) {
|
|
break label$17;
|
|
}
|
|
if (($16 | 0) >= ($70 | 0)) {
|
|
break label$16;
|
|
}
|
|
$12 = $16 + $40 | 0;
|
|
}
|
|
$16 = $12;
|
|
if (($16 | 0) >= 1024) {
|
|
$12 = ($16 & -1024) + $66 | 0;
|
|
$28 = Math_imul($12 << 16 >> 16, $31);
|
|
$26 = $12 + 1024 | 0;
|
|
$29 = Math_imul($26 << 16 >> 16, $31);
|
|
break label$13;
|
|
}
|
|
$28 = $38;
|
|
$29 = $42;
|
|
$12 = $17;
|
|
$26 = $39;
|
|
switch (($16 >> 10) + 1 | 0) {
|
|
case 1:
|
|
break label$13;
|
|
case 0:
|
|
break label$15;
|
|
default:
|
|
break label$14;
|
|
}
|
|
}
|
|
$28 = $38;
|
|
$29 = $42;
|
|
$12 = $17;
|
|
$26 = $39;
|
|
if (($16 | 0) >= 0) {
|
|
break label$13;
|
|
}
|
|
}
|
|
$28 = $65;
|
|
$29 = $38;
|
|
$12 = $43;
|
|
$26 = $17;
|
|
break label$13;
|
|
}
|
|
$12 = ($16 & -1024 | 80) + $17 | 0;
|
|
$28 = Math_imul(0 - ($12 << 16) >> 16, $31);
|
|
$26 = $12 + 1024 | 0;
|
|
$29 = Math_imul(0 - ($26 << 16) >> 16, $31);
|
|
}
|
|
$22 = HEAP32[$27 + 1296 >> 2];
|
|
$16 = Math_imul($35, 56) + $30 | 0;
|
|
$27 = $2 - $12 << 16 >> 16;
|
|
$28 = Math_imul($27, $27) + $28 >> 10;
|
|
$2 = $2 - $26 << 16 >> 16;
|
|
$29 = Math_imul($2, $2) + $29 >> 10;
|
|
$2 = ($28 | 0) < ($29 | 0);
|
|
$27 = $2 ? $26 : $12;
|
|
HEAP32[$16 + 28 >> 2] = $27;
|
|
$12 = $2 ? $12 : $26;
|
|
HEAP32[$16 >> 2] = $12;
|
|
HEAP32[$16 + 32 >> 2] = ($2 ? $29 : $28) + $22;
|
|
HEAP32[$16 + 4 >> 2] = ($2 ? $28 : $29) + $22;
|
|
$12 = $12 << 4;
|
|
$12 = ($19 ? 0 - $12 | 0 : $12) + $37 | 0;
|
|
HEAP32[$16 + 24 >> 2] = $12;
|
|
$26 = $27 << 4;
|
|
$26 = ($19 ? 0 - $26 | 0 : $26) + $37 | 0;
|
|
HEAP32[$16 + 52 >> 2] = $26;
|
|
$12 = $12 + $41 | 0;
|
|
HEAP32[$16 + 8 >> 2] = $12;
|
|
$26 = $26 + $41 | 0;
|
|
HEAP32[$16 + 36 >> 2] = $26;
|
|
$2 = $61 << 4;
|
|
$12 = $12 - $2 | 0;
|
|
HEAP32[$16 + 16 >> 2] = $12;
|
|
$26 = $26 - $2 | 0;
|
|
HEAP32[$16 + 44 >> 2] = $26;
|
|
$12 = $12 - $13 | 0;
|
|
HEAP32[$16 + 12 >> 2] = $12;
|
|
$26 = $26 - $13 | 0;
|
|
HEAP32[$16 + 40 >> 2] = $26;
|
|
HEAP32[$16 + 20 >> 2] = $12 - $15;
|
|
HEAP32[$16 + 48 >> 2] = $26 - $15;
|
|
$35 = $35 + 1 | 0;
|
|
if (($35 | 0) != ($23 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$16 = 0;
|
|
$12 = ($62 - 1 | 0) % 40 | 0;
|
|
$12 = ($12 | 0) < 0 ? $12 + 40 | 0 : $12;
|
|
HEAP32[$24 >> 2] = $12;
|
|
$15 = ($12 + $25 | 0) % 40 | 0;
|
|
$2 = 0;
|
|
$19 = ($23 | 0) < 2;
|
|
if (!$19) {
|
|
$26 = HEAP32[$30 + 4 >> 2];
|
|
$12 = 1;
|
|
while (1) {
|
|
$13 = HEAP32[(Math_imul($12, 56) + $30 | 0) + 4 >> 2];
|
|
$22 = $13;
|
|
$13 = ($13 | 0) < ($26 | 0);
|
|
$26 = $13 ? $22 : $26;
|
|
$2 = $13 ? $12 : $2;
|
|
$12 = $12 + 1 | 0;
|
|
if (($23 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$15 = $15 << 2;
|
|
$28 = $15 + (Math_imul($2, 1300) + $1 | 0) | 0;
|
|
$26 = HEAP32[$28 + 384 >> 2];
|
|
while (1) {
|
|
if (HEAP32[((Math_imul($16, 1300) + $1 | 0) + $15 | 0) + 384 >> 2] != ($26 | 0)) {
|
|
$12 = Math_imul($16, 56) + $30 | 0;
|
|
HEAP32[$12 + 4 >> 2] = HEAP32[$12 + 4 >> 2] + 134217727;
|
|
$2 = $12;
|
|
$12 = $12 + 32 | 0;
|
|
HEAP32[$12 >> 2] = HEAP32[$2 + 32 >> 2] + 134217727;
|
|
}
|
|
$16 = $16 + 1 | 0;
|
|
if (($23 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = HEAP32[$30 + 32 >> 2];
|
|
$26 = HEAP32[$30 + 4 >> 2];
|
|
$2 = 0;
|
|
$16 = 1;
|
|
$13 = 0;
|
|
if (!$19) {
|
|
while (1) {
|
|
$19 = Math_imul($16, 56) + $30 | 0;
|
|
$22 = HEAP32[$19 + 4 >> 2];
|
|
$29 = $22;
|
|
$22 = ($22 | 0) > ($26 | 0);
|
|
$26 = $22 ? $29 : $26;
|
|
$19 = HEAP32[$19 + 32 >> 2];
|
|
$29 = $19;
|
|
$19 = ($12 | 0) > ($19 | 0);
|
|
$12 = $19 ? $29 : $12;
|
|
$13 = $22 ? $16 : $13;
|
|
$2 = $19 ? $16 : $2;
|
|
$16 = $16 + 1 | 0;
|
|
if (($23 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($12 | 0) < ($26 | 0)) {
|
|
memcpy((Math_imul($13, 1300) + $1 | 0) + $36 | 0, (Math_imul($2, 1300) + $1 | 0) + $36 | 0, 1300 - $36 | 0);
|
|
$16 = Math_imul($13, 56) + $30 | 0;
|
|
$12 = Math_imul($2, 56) + $30 | 0;
|
|
HEAP32[$16 + 24 >> 2] = HEAP32[$12 + 52 >> 2];
|
|
$13 = HEAP32[$12 + 48 >> 2];
|
|
$2 = HEAP32[$12 + 44 >> 2];
|
|
HEAP32[$16 + 16 >> 2] = $2;
|
|
HEAP32[$16 + 20 >> 2] = $13;
|
|
$2 = HEAP32[$12 + 40 >> 2];
|
|
$13 = HEAP32[$12 + 36 >> 2];
|
|
HEAP32[$16 + 8 >> 2] = $13;
|
|
HEAP32[$16 + 12 >> 2] = $2;
|
|
$13 = HEAP32[$12 + 32 >> 2];
|
|
$2 = HEAP32[$12 + 28 >> 2];
|
|
HEAP32[$16 >> 2] = $2;
|
|
HEAP32[$16 + 4 >> 2] = $13;
|
|
}
|
|
if (!(($25 | 0) > ($33 | 0) ? !$75 : 0)) {
|
|
$16 = $33 - $25 | 0;
|
|
HEAP8[$16 + $4 | 0] = (HEAP32[$28 + 544 >> 2] >>> 9 | 0) + 1 >>> 1;
|
|
$2 = ($16 << 1) + $5 | 0;
|
|
$12 = HEAP32[$7 + $15 >> 2];
|
|
$26 = $12 << 16 >> 16;
|
|
$16 = HEAP32[$28 + 704 >> 2];
|
|
$16 = ((Math_imul($26, $16 & 65535) >> 16) + Math_imul($16 >> 16, $26) | 0) + Math_imul(($12 >> 15) + 1 >> 1, $16) | 0;
|
|
HEAP16[$2 >> 1] = ($16 | 0) > 8388479 ? 32767 : ($16 | 0) < -8388736 ? -32768 : ($16 >>> 7 | 0) + 1 >>> 1 | 0;
|
|
HEAP32[((HEAP32[$0 + 4336 >> 2] - $25 << 2) + $0 | 0) + 1280 >> 2] = HEAP32[$28 + 1024 >> 2];
|
|
HEAP32[(HEAP32[$0 + 4332 >> 2] - $25 << 2) + $6 >> 2] = HEAP32[$28 + 864 >> 2];
|
|
}
|
|
HEAP32[$0 + 4336 >> 2] = HEAP32[$0 + 4336 >> 2] + 1;
|
|
HEAP32[$0 + 4332 >> 2] = HEAP32[$0 + 4332 >> 2] + 1;
|
|
$13 = $33 + 16 | 0;
|
|
$26 = 0;
|
|
while (1) {
|
|
$16 = Math_imul($26, 1300) + $1 | 0;
|
|
$12 = Math_imul($26, 56) + $30 | 0;
|
|
HEAP32[$16 + 1280 >> 2] = HEAP32[$12 + 12 >> 2];
|
|
HEAP32[$16 + 1284 >> 2] = HEAP32[$12 + 16 >> 2];
|
|
$2 = HEAP32[$12 + 8 >> 2];
|
|
HEAP32[($13 << 2) + $16 >> 2] = $2;
|
|
HEAP32[((HEAP32[$24 >> 2] << 2) + $16 | 0) + 704 >> 2] = $2;
|
|
$2 = HEAP32[$12 >> 2];
|
|
HEAP32[((HEAP32[$24 >> 2] << 2) + $16 | 0) + 544 >> 2] = $2;
|
|
HEAP32[((HEAP32[$24 >> 2] << 2) + $16 | 0) + 864 >> 2] = HEAP32[$12 + 24 >> 2] << 1;
|
|
HEAP32[((HEAP32[$24 >> 2] << 2) + $16 | 0) + 1024 >> 2] = HEAP32[$12 + 20 >> 2];
|
|
$2 = HEAP32[$16 + 1288 >> 2] + (($2 >> 9) + 1 >> 1) | 0;
|
|
HEAP32[$16 + 1288 >> 2] = $2;
|
|
HEAP32[((HEAP32[$24 >> 2] << 2) + $16 | 0) + 384 >> 2] = $2;
|
|
HEAP32[$16 + 1296 >> 2] = HEAP32[$12 + 4 >> 2];
|
|
$26 = $26 + 1 | 0;
|
|
if (($26 | 0) != ($23 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[(HEAP32[$24 >> 2] << 2) + $7 >> 2] = $64;
|
|
$33 = $33 + 1 | 0;
|
|
if (($33 | 0) != ($18 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$14 = 0;
|
|
$26 = $18 << 2;
|
|
while (1) {
|
|
$16 = Math_imul($14, 1300) + $1 | 0;
|
|
$12 = $26 + $16 | 0;
|
|
$13 = HEAP32[$12 >> 2];
|
|
$2 = HEAP32[$12 + 4 >> 2];
|
|
HEAP32[$16 >> 2] = $13;
|
|
HEAP32[$16 + 4 >> 2] = $2;
|
|
$13 = HEAP32[$12 + 60 >> 2];
|
|
$2 = HEAP32[$12 + 56 >> 2];
|
|
HEAP32[$16 + 56 >> 2] = $2;
|
|
HEAP32[$16 + 60 >> 2] = $13;
|
|
$2 = HEAP32[$12 + 52 >> 2];
|
|
$13 = HEAP32[$12 + 48 >> 2];
|
|
HEAP32[$16 + 48 >> 2] = $13;
|
|
HEAP32[$16 + 52 >> 2] = $2;
|
|
$13 = HEAP32[$12 + 44 >> 2];
|
|
$2 = HEAP32[$12 + 40 >> 2];
|
|
HEAP32[$16 + 40 >> 2] = $2;
|
|
HEAP32[$16 + 44 >> 2] = $13;
|
|
$2 = HEAP32[$12 + 36 >> 2];
|
|
$13 = HEAP32[$12 + 32 >> 2];
|
|
HEAP32[$16 + 32 >> 2] = $13;
|
|
HEAP32[$16 + 36 >> 2] = $2;
|
|
$13 = HEAP32[$12 + 28 >> 2];
|
|
$2 = HEAP32[$12 + 24 >> 2];
|
|
HEAP32[$16 + 24 >> 2] = $2;
|
|
HEAP32[$16 + 28 >> 2] = $13;
|
|
$2 = HEAP32[$12 + 20 >> 2];
|
|
$13 = HEAP32[$12 + 16 >> 2];
|
|
HEAP32[$16 + 16 >> 2] = $13;
|
|
HEAP32[$16 + 20 >> 2] = $2;
|
|
$13 = HEAP32[$12 + 12 >> 2];
|
|
$2 = HEAP32[$12 + 8 >> 2];
|
|
HEAP32[$16 + 8 >> 2] = $2;
|
|
HEAP32[$16 + 12 >> 2] = $13;
|
|
$14 = $14 + 1 | 0;
|
|
if (($23 | 0) != ($14 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
__stack_pointer = $63;
|
|
return;
|
|
}
|
|
celt_fatal(16226, 16207, 364);
|
|
abort();
|
|
}
|
|
celt_fatal(16271, 16207, 422);
|
|
abort();
|
|
}
|
|
function dynalloc_analysis($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20) {
|
|
var $21 = Math_fround(0), $22 = 0, $23 = Math_fround(0), $24 = 0, $25 = 0, $26 = Math_fround(0), $27 = Math_fround(0), $28 = Math_fround(0), $29 = 0, $30 = 0, $31 = Math_fround(0), $32 = 0, $33 = Math_fround(0), $34 = 0, $35 = 0, $36 = Math_fround(0), $37 = 0, $38 = 0, $39 = 0, $40 = Math_fround(0), $41 = 0, $42 = 0, $43 = 0, $44 = 0, $45 = Math_fround(0);
|
|
$24 = __stack_pointer;
|
|
$41 = $24;
|
|
$22 = (Math_imul($2, $5) << 2) + 15 & -16;
|
|
$30 = $24 - $22 | 0;
|
|
$24 = $30;
|
|
__stack_pointer = $24;
|
|
$32 = $24 - $22 | 0;
|
|
$29 = $32;
|
|
__stack_pointer = $29;
|
|
$24 = 0;
|
|
$38 = memset($6, 0, $2 << 2);
|
|
$25 = ($4 | 0) < 1;
|
|
if (!$25) {
|
|
$21 = Math_fround(9 - $7 | 0);
|
|
$6 = 0;
|
|
while (1) {
|
|
$22 = $6 << 2;
|
|
$7 = $6 + 5 | 0;
|
|
HEAPF32[$32 + $22 >> 2] = Math_fround(Math_fround(Math_imul($7, $7) | 0) * Math_fround(.006200000178068876)) + Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAP16[($6 << 1) + $8 >> 1]) * Math_fround(.0625)) + Math_fround(.5)) + $21) - HEAPF32[$22 + 32928 >> 2]);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$37 = ($5 | 0) > 1 ? $5 : 1;
|
|
$33 = Math_fround(-31.899999618530273);
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
while (1) {
|
|
if (!$25) {
|
|
$22 = Math_imul($2, $24);
|
|
$6 = 0;
|
|
while (1) {
|
|
$21 = Math_fround(HEAPF32[($6 + $22 << 2) + $0 >> 2] - HEAPF32[($6 << 2) + $32 >> 2]);
|
|
$33 = $21 < $33 ? $33 : $21;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$24 = $24 + 1 | 0;
|
|
if (($37 | 0) != ($24 | 0)) {
|
|
continue;
|
|
}
|
|
$24 = $29;
|
|
$22 = ($2 << 2) + 15 & -16;
|
|
$6 = $24 - $22 | 0;
|
|
__stack_pointer = $6;
|
|
$22 = $6 - $22 | 0;
|
|
__stack_pointer = $22;
|
|
if (($4 | 0) < 1) {
|
|
break label$6;
|
|
}
|
|
$7 = 0;
|
|
while (1) {
|
|
$25 = $7 << 2;
|
|
HEAPF32[$25 + $6 >> 2] = HEAPF32[$0 + $25 >> 2] - HEAPF32[$25 + $32 >> 2];
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!(($5 | 0) != 2 | ($4 | 0) < 1)) {
|
|
$7 = 0;
|
|
while (1) {
|
|
$25 = $7 << 2;
|
|
$8 = $25 + $6 | 0;
|
|
$21 = HEAPF32[$8 >> 2];
|
|
$23 = Math_fround(HEAPF32[($2 + $7 << 2) + $0 >> 2] - HEAPF32[$25 + $32 >> 2]);
|
|
HEAPF32[$8 >> 2] = $21 > $23 ? $21 : $23;
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = memcpy($22, $6, $4 << 2);
|
|
if (($4 | 0) > 1) {
|
|
break label$5;
|
|
}
|
|
$34 = $4 - 2 | 0;
|
|
$35 = 0;
|
|
break label$4;
|
|
}
|
|
$24 = $24 + 1 | 0;
|
|
if (($37 | 0) != ($24 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$24 = $29;
|
|
$22 = ($2 << 2) + 15 & -16;
|
|
$6 = $24 - $22 | 0;
|
|
__stack_pointer = $6;
|
|
$22 = $6 - $22 | 0;
|
|
__stack_pointer = $22;
|
|
}
|
|
memcpy($22, $6, $4 << 2);
|
|
$34 = $4 - 2 | 0;
|
|
$39 = ($5 | 0) == 2;
|
|
break label$3;
|
|
}
|
|
$21 = HEAPF32[$6 >> 2];
|
|
$22 = 1;
|
|
while (1) {
|
|
$7 = ($22 << 2) + $6 | 0;
|
|
$23 = HEAPF32[$7 >> 2];
|
|
$21 = Math_fround($21 + Math_fround(-2));
|
|
$21 = $21 < $23 ? $23 : $21;
|
|
HEAPF32[$7 >> 2] = $21;
|
|
$22 = $22 + 1 | 0;
|
|
if (($22 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$34 = $4 - 2 | 0;
|
|
$35 = 0;
|
|
if (($4 | 0) <= 1) {
|
|
break label$4;
|
|
}
|
|
$22 = $34;
|
|
while (1) {
|
|
$7 = ($22 << 2) + $6 | 0;
|
|
$21 = HEAPF32[$7 >> 2];
|
|
$23 = Math_fround(HEAPF32[$7 + 4 >> 2] + Math_fround(-3));
|
|
HEAPF32[$7 >> 2] = $21 > $23 ? $21 : $23;
|
|
$7 = ($22 | 0) > 0;
|
|
$22 = $22 - 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$35 = 1;
|
|
}
|
|
$39 = ($5 | 0) == 2;
|
|
if (($4 | 0) < 1) {
|
|
break label$3;
|
|
}
|
|
$21 = Math_fround(Math_max(Math_fround($33 + Math_fround(-12)), Math_fround(0)));
|
|
$22 = 0;
|
|
while (1) {
|
|
$7 = $22 << 2;
|
|
$23 = HEAPF32[$7 + $6 >> 2];
|
|
$23 = Math_fround(Math_floor(Math_fround(Math_fround(HEAPF32[$7 + $8 >> 2] - ($21 > $23 ? $21 : $23)) + Math_fround(.5))));
|
|
label$16 : {
|
|
if (Math_fround(Math_abs($23)) < Math_fround(2147483648)) {
|
|
$24 = ~~$23;
|
|
break label$16;
|
|
}
|
|
$24 = -2147483648;
|
|
}
|
|
$29 = $7 + $20 | 0;
|
|
$25 = $24;
|
|
$7 = ($25 | 0) > 0 ? 0 : 0 - $25 | 0;
|
|
HEAP32[$29 >> 2] = 32 >>> (($7 | 0) < 5 ? $7 : 5);
|
|
$22 = $22 + 1 | 0;
|
|
if (($22 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$18 : {
|
|
if (!($16 | (($13 | 0) < 1 | ($14 | 0) < 51))) {
|
|
$42 = $4 - 3 | 0;
|
|
$8 = 0;
|
|
$43 = ($4 | 0) > 4;
|
|
$44 = $4 - 1 << 2;
|
|
$16 = 0;
|
|
while (1) {
|
|
$7 = Math_imul($2, $16);
|
|
$6 = $7 << 2;
|
|
$24 = $30 + $6 | 0;
|
|
$20 = $1 + $6 | 0;
|
|
$36 = HEAPF32[$20 >> 2];
|
|
$6 = HEAP32[$20 >> 2];
|
|
HEAP32[$24 >> 2] = $6;
|
|
$23 = $36;
|
|
$6 = 1;
|
|
if ($35) {
|
|
while (1) {
|
|
$22 = ($6 + $7 << 2) + $1 | 0;
|
|
$26 = HEAPF32[$22 - 4 >> 2];
|
|
$23 = Math_fround($23 + Math_fround(1.5));
|
|
$21 = HEAPF32[$22 >> 2];
|
|
$23 = $21 > $23 ? $23 : $21;
|
|
HEAPF32[($6 << 2) + $24 >> 2] = $23;
|
|
$8 = Math_fround($26 + Math_fround(.5)) < $21 ? $6 : $8;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($8 | 0) >= 1) {
|
|
$21 = HEAPF32[($8 << 2) + $24 >> 2];
|
|
$6 = $8;
|
|
while (1) {
|
|
$22 = $6 - 1 | 0;
|
|
$25 = ($22 << 2) + $24 | 0;
|
|
$23 = HEAPF32[$25 >> 2];
|
|
$21 = Math_fround($21 + Math_fround(2));
|
|
$26 = HEAPF32[($7 + $22 << 2) + $1 >> 2];
|
|
$21 = $21 < $26 ? $21 : $26;
|
|
$21 = $21 > $23 ? $23 : $21;
|
|
HEAPF32[$25 >> 2] = $21;
|
|
$25 = ($6 | 0) > 1;
|
|
$6 = $22;
|
|
if ($25) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = 2;
|
|
if ($43) {
|
|
while (1) {
|
|
$22 = ($6 + $7 << 2) + $1 | 0;
|
|
$25 = $22 - 8 | 0;
|
|
$21 = HEAPF32[$25 >> 2];
|
|
$23 = HEAPF32[$25 + 4 >> 2];
|
|
$25 = $21 > $23;
|
|
$26 = HEAPF32[$22 + 4 >> 2];
|
|
$27 = HEAPF32[$22 + 8 >> 2];
|
|
$29 = $26 > $27;
|
|
$28 = $25 ? $21 : $23;
|
|
$40 = $29 ? $26 : $27;
|
|
$21 = $25 ? $23 : $21;
|
|
$23 = $29 ? $27 : $26;
|
|
$25 = $21 > $23;
|
|
$31 = $25 ? $28 : $40;
|
|
$21 = $25 ? $21 : $23;
|
|
$29 = ($6 << 2) + $24 | 0;
|
|
$23 = HEAPF32[$29 >> 2];
|
|
$45 = $23;
|
|
$26 = HEAPF32[$22 >> 2];
|
|
$27 = $25 ? $40 : $28;
|
|
$22 = $26 > $27 ^ 1;
|
|
label$27 : {
|
|
if (!$22) {
|
|
$28 = $21 > $26 ? $26 : $21;
|
|
if (!($21 > $27 ^ 1)) {
|
|
break label$27;
|
|
}
|
|
$28 = $27 > $31 ? $31 : $27;
|
|
break label$27;
|
|
}
|
|
$28 = $21 > $27 ? $27 : $21;
|
|
if (!($21 > $26 ^ 1)) {
|
|
break label$27;
|
|
}
|
|
$28 = $26 < $31 ? $26 : $31;
|
|
}
|
|
if (!(Math_fround($28 + Math_fround(-1)) < $45)) {
|
|
label$30 : {
|
|
if (!$22) {
|
|
$28 = $21 > $26 ? $26 : $21;
|
|
if (!($21 > $27 ^ 1)) {
|
|
break label$30;
|
|
}
|
|
$28 = $27 > $31 ? $31 : $27;
|
|
break label$30;
|
|
}
|
|
$28 = $21 > $27 ? $27 : $21;
|
|
if (!($21 > $26 ^ 1)) {
|
|
break label$30;
|
|
}
|
|
$28 = $26 < $31 ? $26 : $31;
|
|
}
|
|
$21 = $28;
|
|
$23 = Math_fround($21 + Math_fround(-1));
|
|
}
|
|
HEAPF32[$29 >> 2] = $23;
|
|
$6 = $6 + 1 | 0;
|
|
if (($34 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$21 = HEAPF32[$20 + 4 >> 2];
|
|
$6 = $36 > $21;
|
|
$26 = HEAPF32[$24 >> 2];
|
|
$27 = $6 ? $36 : $21;
|
|
$23 = HEAPF32[$20 + 8 >> 2];
|
|
$21 = $6 ? $21 : $36;
|
|
$21 = Math_fround(($23 > $27 ? $27 : $21 < $23 ? $23 : $21) + Math_fround(-1));
|
|
HEAPF32[$24 >> 2] = $21 < $26 ? $26 : $21;
|
|
$23 = HEAPF32[$24 + 4 >> 2];
|
|
HEAPF32[$24 + 4 >> 2] = $21 < $23 ? $23 : $21;
|
|
$6 = ($34 << 2) + $24 | 0;
|
|
$20 = $6;
|
|
$27 = HEAPF32[$6 >> 2];
|
|
$6 = ($7 + $42 << 2) + $1 | 0;
|
|
$21 = HEAPF32[$6 >> 2];
|
|
$23 = HEAPF32[$6 + 4 >> 2];
|
|
$22 = $21 > $23;
|
|
$31 = $22 ? $21 : $23;
|
|
$26 = HEAPF32[$6 + 8 >> 2];
|
|
$21 = $22 ? $23 : $21;
|
|
$21 = Math_fround(($26 > $31 ? $31 : $21 < $26 ? $26 : $21) + Math_fround(-1));
|
|
HEAPF32[$20 >> 2] = $21 < $27 ? $27 : $21;
|
|
$6 = $24 + $44 | 0;
|
|
$23 = HEAPF32[$6 >> 2];
|
|
HEAPF32[$6 >> 2] = $21 < $23 ? $23 : $21;
|
|
$6 = 0;
|
|
if (($4 | 0) >= 1) {
|
|
while (1) {
|
|
$22 = $6 << 2;
|
|
$7 = $24 + $22 | 0;
|
|
$21 = HEAPF32[$7 >> 2];
|
|
$23 = HEAPF32[$22 + $32 >> 2];
|
|
HEAPF32[$7 >> 2] = $21 > $23 ? $21 : $23;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$16 = $16 + 1 | 0;
|
|
if (($37 | 0) != ($16 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
label$34 : {
|
|
label$35 : {
|
|
if (!$39) {
|
|
if (($3 | 0) >= ($4 | 0)) {
|
|
break label$34;
|
|
}
|
|
$6 = $3;
|
|
while (1) {
|
|
$24 = $6 << 2;
|
|
$22 = $30 + $24 | 0;
|
|
HEAPF32[$22 >> 2] = Math_max(Math_fround(HEAPF32[$0 + $24 >> 2] - HEAPF32[$22 >> 2]), Math_fround(0));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$35;
|
|
}
|
|
if (($3 | 0) >= ($4 | 0)) {
|
|
break label$34;
|
|
}
|
|
$6 = $3;
|
|
while (1) {
|
|
$1 = $2 + $6 << 2;
|
|
$22 = $30 + $1 | 0;
|
|
$21 = HEAPF32[$22 >> 2];
|
|
$7 = $6 << 2;
|
|
$24 = $30 + $7 | 0;
|
|
$23 = Math_fround(HEAPF32[$24 >> 2] + Math_fround(-4));
|
|
$21 = $21 > $23 ? $21 : $23;
|
|
HEAPF32[$22 >> 2] = $21;
|
|
$23 = HEAPF32[$24 >> 2];
|
|
$21 = Math_fround($21 + Math_fround(-4));
|
|
$21 = $21 < $23 ? $23 : $21;
|
|
HEAPF32[$24 >> 2] = $21;
|
|
HEAPF32[$24 >> 2] = Math_fround(Math_fround(Math_max(Math_fround(HEAPF32[$0 + $7 >> 2] - $21), Math_fround(0))) + Math_fround(Math_max(Math_fround(HEAPF32[$0 + $1 >> 2] - HEAPF32[$22 >> 2]), Math_fround(0)))) * Math_fround(.5);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = ($3 | 0) < ($4 | 0);
|
|
if (!$1) {
|
|
break label$34;
|
|
}
|
|
$6 = $3;
|
|
while (1) {
|
|
$24 = $6 << 2;
|
|
$22 = $30 + $24 | 0;
|
|
$21 = HEAPF32[$22 >> 2];
|
|
$23 = HEAPF32[$17 + $24 >> 2];
|
|
HEAPF32[$22 >> 2] = $21 > $23 ? $21 : $23;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!$1) {
|
|
break label$34;
|
|
}
|
|
$6 = $3;
|
|
while (1) {
|
|
$24 = $6 << 2;
|
|
$21 = HEAPF32[$30 + $24 >> 2];
|
|
$21 = Math_fround(Math_floor(Math_fround(Math_fround(Math_fround(exp(+($21 < Math_fround(4) ? $21 : Math_fround(4)) * .6931471805599453)) * Math_fround(13)) + Math_fround(.5))));
|
|
label$41 : {
|
|
if (Math_fround(Math_abs($21)) < Math_fround(2147483648)) {
|
|
$22 = ~~$21;
|
|
break label$41;
|
|
}
|
|
$22 = -2147483648;
|
|
}
|
|
HEAP32[$19 + $24 >> 2] = $22;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = ($3 | 0) >= ($4 | 0);
|
|
if (!(!$11 & ($10 | 0) != 0 | ($9 | $1))) {
|
|
$6 = $3;
|
|
while (1) {
|
|
$24 = ($6 << 2) + $30 | 0;
|
|
HEAPF32[$24 >> 2] = HEAPF32[$24 >> 2] * Math_fround(.5);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$1) {
|
|
$6 = $3;
|
|
while (1) {
|
|
$21 = Math_fround(2);
|
|
label$47 : {
|
|
if (($6 | 0) >= 8) {
|
|
$21 = Math_fround(.5);
|
|
if (($6 | 0) < 12) {
|
|
break label$47;
|
|
}
|
|
}
|
|
$24 = ($6 << 2) + $30 | 0;
|
|
HEAPF32[$24 >> 2] = HEAPF32[$24 >> 2] * $21;
|
|
}
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$49 : {
|
|
if (!HEAP32[$18 >> 2]) {
|
|
break label$49;
|
|
}
|
|
$22 = ($4 | 0) < 19 ? $4 : 19;
|
|
if (($22 | 0) <= ($3 | 0)) {
|
|
break label$49;
|
|
}
|
|
$6 = $3;
|
|
while (1) {
|
|
$24 = ($6 << 2) + $30 | 0;
|
|
HEAPF32[$24 >> 2] = HEAPF32[$24 >> 2] + Math_fround(Math_fround(HEAPU8[($6 + $18 | 0) + 44 | 0]) * Math_fround(.015625));
|
|
$6 = $6 + 1 | 0;
|
|
if (($22 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$22 = 0;
|
|
if ($1) {
|
|
break label$18;
|
|
}
|
|
$8 = ($14 << 1) / 3 | 0;
|
|
$1 = 0;
|
|
$7 = HEAPU16[($3 << 1) + $12 >> 1];
|
|
$29 = (!$10 | !$9 & ($11 | 0) != 0) ^ 1;
|
|
while (1) {
|
|
$25 = $3 << 2;
|
|
$6 = $30 + $25 | 0;
|
|
$21 = HEAPF32[$6 >> 2];
|
|
$21 = $21 < Math_fround(4) ? $21 : Math_fround(4);
|
|
HEAPF32[$6 >> 2] = $21;
|
|
$6 = $7 << 16;
|
|
$24 = $3 + 1 | 0;
|
|
$7 = HEAP16[($24 << 1) + $12 >> 1];
|
|
$22 = Math_imul($7 - ($6 >> 16) | 0, $5) << $13;
|
|
label$52 : {
|
|
if (($22 | 0) <= 5) {
|
|
if (Math_fround(Math_abs($21)) < Math_fround(2147483648)) {
|
|
$6 = ~~$21;
|
|
} else {
|
|
$6 = -2147483648;
|
|
}
|
|
$22 = Math_imul($22, $6) << 3;
|
|
break label$52;
|
|
}
|
|
if (($22 | 0) >= 49) {
|
|
$21 = Math_fround($21 * Math_fround(8));
|
|
label$57 : {
|
|
if (Math_fround(Math_abs($21)) < Math_fround(2147483648)) {
|
|
$6 = ~~$21;
|
|
break label$57;
|
|
}
|
|
$6 = -2147483648;
|
|
}
|
|
$22 = (Math_imul($22, $6) << 3) / 8 | 0;
|
|
break label$52;
|
|
}
|
|
$21 = Math_fround(Math_fround($21 * Math_fround($22 | 0)) / Math_fround(6));
|
|
label$59 : {
|
|
if (Math_fround(Math_abs($21)) < Math_fround(2147483648)) {
|
|
$6 = ~~$21;
|
|
break label$59;
|
|
}
|
|
$6 = -2147483648;
|
|
}
|
|
$22 = Math_imul($6, 48);
|
|
}
|
|
$22 = $22 + $1 | 0;
|
|
if (!($22 >> 6 <= ($8 | 0) | $29)) {
|
|
$22 = $8 << 6;
|
|
HEAP32[($3 << 2) + $38 >> 2] = $22 - $1;
|
|
break label$18;
|
|
}
|
|
HEAP32[$25 + $38 >> 2] = $6;
|
|
$3 = $24;
|
|
$1 = $22;
|
|
if (($4 | 0) != ($24 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$18;
|
|
}
|
|
$22 = 0;
|
|
if (($3 | 0) >= ($4 | 0)) {
|
|
break label$18;
|
|
}
|
|
while (1) {
|
|
HEAP32[($3 << 2) + $19 >> 2] = 13;
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$15 >> 2] = $22;
|
|
__stack_pointer = $41;
|
|
return $33;
|
|
}
|
|
function opus_fft_impl($0, $1) {
|
|
var $2 = 0, $3 = Math_fround(0), $4 = 0, $5 = Math_fround(0), $6 = Math_fround(0), $7 = 0, $8 = Math_fround(0), $9 = 0, $10 = 0, $11 = Math_fround(0), $12 = 0, $13 = Math_fround(0), $14 = 0, $15 = Math_fround(0), $16 = Math_fround(0), $17 = Math_fround(0), $18 = 0, $19 = Math_fround(0), $20 = Math_fround(0), $21 = 0, $22 = Math_fround(0), $23 = Math_fround(0), $24 = Math_fround(0), $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = Math_fround(0), $32 = Math_fround(0), $33 = Math_fround(0), $34 = 0, $35 = 0, $36 = 0, $37 = Math_fround(0), $38 = 0, $39 = 0, $40 = Math_fround(0), $41 = Math_fround(0), $42 = Math_fround(0), $43 = Math_fround(0), $44 = Math_fround(0), $45 = Math_fround(0), $46 = Math_fround(0), $47 = Math_fround(0), $48 = Math_fround(0), $49 = Math_fround(0), $50 = 0;
|
|
$29 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $29;
|
|
$14 = HEAP32[$0 + 8 >> 2];
|
|
HEAP32[$29 >> 2] = 1;
|
|
$7 = $0 + 12 | 0;
|
|
$9 = 1;
|
|
while (1) {
|
|
$2 = $4;
|
|
$10 = $2 << 2;
|
|
$18 = HEAPU16[($10 | 2) + $7 >> 1];
|
|
$4 = $2 + 1 | 0;
|
|
$9 = Math_imul(HEAP16[$7 + $10 >> 1], $9);
|
|
HEAP32[($4 << 2) + $29 >> 2] = $9;
|
|
if (($18 | 0) != 1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$38 = ($14 | 0) > 0 ? $14 : 0;
|
|
$35 = HEAP16[(($4 << 2) + $0 | 0) + 10 >> 1];
|
|
label$2 : {
|
|
while (1) {
|
|
$12 = $35;
|
|
$4 = 0;
|
|
$35 = 1;
|
|
$30 = $2;
|
|
if ($2) {
|
|
$35 = HEAP16[(($30 << 2) + $0 | 0) + 10 >> 1];
|
|
$4 = $30 << 1;
|
|
}
|
|
label$5 : {
|
|
label$6 : {
|
|
switch (HEAP16[(($4 << 1) + $0 | 0) + 12 >> 1] - 2 | 0) {
|
|
case 0:
|
|
if (($12 | 0) != 4) {
|
|
break label$2;
|
|
}
|
|
$4 = 0;
|
|
$2 = $1;
|
|
$10 = HEAP32[($30 << 2) + $29 >> 2];
|
|
if (($10 | 0) <= 0) {
|
|
break label$5;
|
|
}
|
|
while (1) {
|
|
$6 = HEAPF32[$2 >> 2];
|
|
$3 = HEAPF32[$2 + 32 >> 2];
|
|
HEAPF32[$2 + 32 >> 2] = $6 - $3;
|
|
HEAPF32[$2 >> 2] = $3 + $6;
|
|
$7 = $2 + 36 | 0;
|
|
$6 = HEAPF32[$7 >> 2];
|
|
$3 = HEAPF32[$2 + 4 >> 2];
|
|
HEAPF32[$2 + 4 >> 2] = $6 + $3;
|
|
HEAPF32[$2 + 36 >> 2] = $3 - $6;
|
|
$6 = HEAPF32[$2 + 8 >> 2];
|
|
$3 = HEAPF32[$2 + 40 >> 2];
|
|
$7 = $2 + 44 | 0;
|
|
$5 = HEAPF32[$7 >> 2];
|
|
$8 = Math_fround(Math_fround($3 + $5) * Math_fround(.7071067690849304));
|
|
HEAPF32[$2 + 40 >> 2] = $6 - $8;
|
|
$9 = $2 + 12 | 0;
|
|
$11 = HEAPF32[$9 >> 2];
|
|
$3 = Math_fround(Math_fround($5 - $3) * Math_fround(.7071067690849304));
|
|
HEAPF32[$2 + 44 >> 2] = $11 - $3;
|
|
HEAPF32[$2 + 8 >> 2] = $6 + $8;
|
|
HEAPF32[$2 + 12 >> 2] = $3 + $11;
|
|
$6 = HEAPF32[$2 + 48 >> 2];
|
|
$3 = HEAPF32[$2 + 16 >> 2];
|
|
$7 = $2 + 52 | 0;
|
|
$5 = HEAPF32[$7 >> 2];
|
|
HEAPF32[$2 + 48 >> 2] = $3 - $5;
|
|
$9 = $2 + 20 | 0;
|
|
$8 = HEAPF32[$9 >> 2];
|
|
HEAPF32[$2 + 52 >> 2] = $6 + $8;
|
|
HEAPF32[$2 + 20 >> 2] = $8 - $6;
|
|
HEAPF32[$2 + 16 >> 2] = $5 + $3;
|
|
$6 = HEAPF32[$2 + 24 >> 2];
|
|
$7 = $2 + 60 | 0;
|
|
$3 = HEAPF32[$7 >> 2];
|
|
$5 = HEAPF32[$2 + 56 >> 2];
|
|
$8 = Math_fround(Math_fround($3 - $5) * Math_fround(.7071067690849304));
|
|
HEAPF32[$2 + 56 >> 2] = $6 - $8;
|
|
$9 = $2 + 28 | 0;
|
|
$11 = HEAPF32[$9 >> 2];
|
|
$3 = Math_fround(Math_fround($3 + $5) * Math_fround(-.7071067690849304));
|
|
HEAPF32[$2 + 60 >> 2] = $11 - $3;
|
|
HEAPF32[$2 + 28 >> 2] = $3 + $11;
|
|
HEAPF32[$2 + 24 >> 2] = $6 + $8;
|
|
$2 = $2 - -64 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($10 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$5;
|
|
case 2:
|
|
$34 = HEAP32[($30 << 2) + $29 >> 2];
|
|
if (($12 | 0) == 1) {
|
|
$4 = 0;
|
|
$2 = $1;
|
|
if (($34 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
while (1) {
|
|
$6 = HEAPF32[$2 >> 2];
|
|
$3 = HEAPF32[$2 + 16 >> 2];
|
|
$5 = Math_fround($6 + $3);
|
|
$8 = HEAPF32[$2 + 8 >> 2];
|
|
$11 = HEAPF32[$2 + 24 >> 2];
|
|
$15 = Math_fround($8 + $11);
|
|
HEAPF32[$2 + 16 >> 2] = $5 - $15;
|
|
HEAPF32[$2 >> 2] = $5 + $15;
|
|
$7 = $2 + 20 | 0;
|
|
$12 = $7;
|
|
$5 = HEAPF32[$2 + 4 >> 2];
|
|
$15 = HEAPF32[$2 + 20 >> 2];
|
|
$20 = Math_fround($5 + $15);
|
|
$7 = $2 + 12 | 0;
|
|
$22 = HEAPF32[$7 >> 2];
|
|
$9 = $2 + 28 | 0;
|
|
$16 = HEAPF32[$9 >> 2];
|
|
$17 = Math_fround($22 + $16);
|
|
HEAPF32[$12 >> 2] = $20 - $17;
|
|
$5 = Math_fround($5 - $15);
|
|
$8 = Math_fround($8 - $11);
|
|
HEAPF32[$2 + 28 >> 2] = $5 + $8;
|
|
$6 = Math_fround($6 - $3);
|
|
$3 = Math_fround($22 - $16);
|
|
HEAPF32[$2 + 24 >> 2] = $6 - $3;
|
|
HEAPF32[$2 + 12 >> 2] = $5 - $8;
|
|
HEAPF32[$2 + 8 >> 2] = $6 + $3;
|
|
HEAPF32[$2 + 4 >> 2] = $20 + $17;
|
|
$2 = $2 + 32 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($34 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$5;
|
|
}
|
|
if (($34 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$26 = Math_imul($12, 3);
|
|
$27 = $12 << 1;
|
|
$21 = $34 << $38;
|
|
$28 = Math_imul($21, 3);
|
|
$39 = $21 << 1;
|
|
$50 = HEAP32[$0 + 48 >> 2];
|
|
$36 = 0;
|
|
while (1) {
|
|
if (($12 | 0) >= 1) {
|
|
$2 = (Math_imul($35, $36) << 3) + $1 | 0;
|
|
$25 = 0;
|
|
$4 = $50;
|
|
$7 = $4;
|
|
$9 = $4;
|
|
while (1) {
|
|
$10 = ($12 << 3) + $2 | 0;
|
|
$6 = HEAPF32[$10 + 4 >> 2];
|
|
$3 = HEAPF32[$10 >> 2];
|
|
$18 = ($26 << 3) + $2 | 0;
|
|
$5 = HEAPF32[$18 + 4 >> 2];
|
|
$8 = HEAPF32[$18 >> 2];
|
|
$11 = HEAPF32[$9 >> 2];
|
|
$15 = HEAPF32[$9 + 4 >> 2];
|
|
$20 = HEAPF32[$4 >> 2];
|
|
$22 = HEAPF32[$4 + 4 >> 2];
|
|
$16 = HEAPF32[$7 >> 2];
|
|
$14 = ($27 << 3) + $2 | 0;
|
|
$17 = HEAPF32[$14 + 4 >> 2];
|
|
$13 = HEAPF32[$14 >> 2];
|
|
$19 = HEAPF32[$7 + 4 >> 2];
|
|
$31 = Math_fround(Math_fround($16 * $17) + Math_fround($13 * $19));
|
|
$23 = HEAPF32[$2 + 4 >> 2];
|
|
$24 = Math_fround($31 + $23);
|
|
HEAPF32[$2 + 4 >> 2] = $24;
|
|
$16 = Math_fround(Math_fround($13 * $16) - Math_fround($17 * $19));
|
|
$17 = HEAPF32[$2 >> 2];
|
|
$13 = Math_fround($16 + $17);
|
|
HEAPF32[$2 >> 2] = $13;
|
|
$19 = Math_fround(Math_fround($11 * $6) + Math_fround($3 * $15));
|
|
$32 = Math_fround(Math_fround($20 * $5) + Math_fround($8 * $22));
|
|
$33 = Math_fround($19 + $32);
|
|
HEAPF32[$14 + 4 >> 2] = $24 - $33;
|
|
$6 = Math_fround(Math_fround($3 * $11) - Math_fround($6 * $15));
|
|
$3 = Math_fround(Math_fround($8 * $20) - Math_fround($5 * $22));
|
|
$5 = Math_fround($6 + $3);
|
|
HEAPF32[$14 >> 2] = $13 - $5;
|
|
HEAPF32[$2 >> 2] = $5 + HEAPF32[$2 >> 2];
|
|
HEAPF32[$2 + 4 >> 2] = $33 + HEAPF32[$2 + 4 >> 2];
|
|
$5 = Math_fround($23 - $31);
|
|
$6 = Math_fround($6 - $3);
|
|
HEAPF32[$10 + 4 >> 2] = $5 - $6;
|
|
$3 = Math_fround($17 - $16);
|
|
$8 = Math_fround($19 - $32);
|
|
HEAPF32[$10 >> 2] = $3 + $8;
|
|
HEAPF32[$18 + 4 >> 2] = $5 + $6;
|
|
HEAPF32[$18 >> 2] = $3 - $8;
|
|
$2 = $2 + 8 | 0;
|
|
$4 = ($28 << 3) + $4 | 0;
|
|
$7 = ($39 << 3) + $7 | 0;
|
|
$9 = ($21 << 3) + $9 | 0;
|
|
$25 = $25 + 1 | 0;
|
|
if (($25 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$36 = $36 + 1 | 0;
|
|
if (($36 | 0) != ($34 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$5;
|
|
case 1:
|
|
$28 = HEAP32[($30 << 2) + $29 >> 2];
|
|
if (($28 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$25 = $12 << 1;
|
|
$27 = HEAP32[$0 + 48 >> 2];
|
|
$14 = $28 << $38;
|
|
$6 = HEAPF32[($27 + (Math_imul($14, $12) << 3) | 0) + 4 >> 2];
|
|
$21 = $14 << 1;
|
|
$26 = 0;
|
|
while (1) {
|
|
$2 = (Math_imul($26, $35) << 3) + $1 | 0;
|
|
$7 = $27;
|
|
$9 = $7;
|
|
$18 = $12;
|
|
while (1) {
|
|
$4 = ($12 << 3) + $2 | 0;
|
|
$3 = HEAPF32[$4 >> 2];
|
|
$5 = HEAPF32[$9 >> 2];
|
|
$8 = HEAPF32[$4 + 4 >> 2];
|
|
$11 = HEAPF32[$9 + 4 >> 2];
|
|
$15 = Math_fround(Math_fround($3 * $5) - Math_fround($8 * $11));
|
|
$10 = ($25 << 3) + $2 | 0;
|
|
$20 = HEAPF32[$10 >> 2];
|
|
$22 = HEAPF32[$7 >> 2];
|
|
$16 = HEAPF32[$10 + 4 >> 2];
|
|
$17 = HEAPF32[$7 + 4 >> 2];
|
|
$13 = Math_fround(Math_fround($20 * $22) - Math_fround($16 * $17));
|
|
$19 = Math_fround($15 + $13);
|
|
HEAPF32[$4 >> 2] = HEAPF32[$2 >> 2] - Math_fround($19 * Math_fround(.5));
|
|
$3 = Math_fround(Math_fround($5 * $8) + Math_fround($3 * $11));
|
|
$5 = Math_fround(Math_fround($22 * $16) + Math_fround($20 * $17));
|
|
$8 = Math_fround($3 + $5);
|
|
HEAPF32[$4 + 4 >> 2] = HEAPF32[$2 + 4 >> 2] - Math_fround($8 * Math_fround(.5));
|
|
HEAPF32[$2 >> 2] = $19 + HEAPF32[$2 >> 2];
|
|
HEAPF32[$2 + 4 >> 2] = $8 + HEAPF32[$2 + 4 >> 2];
|
|
$3 = Math_fround($6 * Math_fround($3 - $5));
|
|
HEAPF32[$10 >> 2] = $3 + HEAPF32[$4 >> 2];
|
|
$5 = Math_fround($6 * Math_fround($15 - $13));
|
|
HEAPF32[$10 + 4 >> 2] = HEAPF32[$4 + 4 >> 2] - $5;
|
|
HEAPF32[$4 >> 2] = HEAPF32[$4 >> 2] - $3;
|
|
HEAPF32[$4 + 4 >> 2] = $5 + HEAPF32[$4 + 4 >> 2];
|
|
$2 = $2 + 8 | 0;
|
|
$7 = ($21 << 3) + $7 | 0;
|
|
$9 = ($14 << 3) + $9 | 0;
|
|
$18 = $18 - 1 | 0;
|
|
if ($18) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$26 = $26 + 1 | 0;
|
|
if (($28 | 0) != ($26 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$5;
|
|
case 3:
|
|
break label$6;
|
|
default:
|
|
break label$5;
|
|
}
|
|
}
|
|
$28 = HEAP32[($30 << 2) + $29 >> 2];
|
|
if (($28 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$18 = HEAP32[$0 + 48 >> 2];
|
|
$26 = $28 << $38;
|
|
$2 = Math_imul($26, $12);
|
|
$4 = $18 + ($2 << 4) | 0;
|
|
$6 = HEAPF32[$4 + 4 >> 2];
|
|
$3 = HEAPF32[$4 >> 2];
|
|
$2 = ($2 << 3) + $18 | 0;
|
|
$5 = HEAPF32[$2 + 4 >> 2];
|
|
$8 = HEAPF32[$2 >> 2];
|
|
$39 = $12 << 2;
|
|
$36 = Math_imul($12, 3);
|
|
$34 = $12 << 1;
|
|
$27 = 0;
|
|
while (1) {
|
|
if (($12 | 0) >= 1) {
|
|
$2 = (Math_imul($27, $35) << 3) + $1 | 0;
|
|
$4 = $2 + ($12 << 3) | 0;
|
|
$7 = ($34 << 3) + $2 | 0;
|
|
$9 = ($36 << 3) + $2 | 0;
|
|
$10 = ($39 << 3) + $2 | 0;
|
|
$25 = 0;
|
|
while (1) {
|
|
$11 = HEAPF32[$2 >> 2];
|
|
$15 = HEAPF32[$2 + 4 >> 2];
|
|
$14 = Math_imul($25, $26);
|
|
$21 = ($14 << 4) + $18 | 0;
|
|
$16 = HEAPF32[$21 >> 2];
|
|
$17 = HEAPF32[$7 + 4 >> 2];
|
|
$13 = HEAPF32[$7 >> 2];
|
|
$19 = HEAPF32[$21 + 4 >> 2];
|
|
$31 = Math_fround(Math_fround($16 * $17) + Math_fround($13 * $19));
|
|
$21 = Math_imul($14, 24) + $18 | 0;
|
|
$23 = HEAPF32[$21 >> 2];
|
|
$24 = HEAPF32[$9 + 4 >> 2];
|
|
$32 = HEAPF32[$9 >> 2];
|
|
$33 = HEAPF32[$21 + 4 >> 2];
|
|
$37 = Math_fround(Math_fround($23 * $24) + Math_fround($32 * $33));
|
|
$20 = Math_fround($31 + $37);
|
|
$21 = ($14 << 3) + $18 | 0;
|
|
$40 = HEAPF32[$21 >> 2];
|
|
$41 = HEAPF32[$4 + 4 >> 2];
|
|
$42 = HEAPF32[$4 >> 2];
|
|
$43 = HEAPF32[$21 + 4 >> 2];
|
|
$44 = Math_fround(Math_fround($40 * $41) + Math_fround($42 * $43));
|
|
$14 = ($14 << 5) + $18 | 0;
|
|
$45 = HEAPF32[$14 >> 2];
|
|
$46 = HEAPF32[$10 + 4 >> 2];
|
|
$47 = HEAPF32[$10 >> 2];
|
|
$48 = HEAPF32[$14 + 4 >> 2];
|
|
$49 = Math_fround(Math_fround($45 * $46) + Math_fround($47 * $48));
|
|
$22 = Math_fround($44 + $49);
|
|
HEAPF32[$2 + 4 >> 2] = $15 + Math_fround($20 + $22);
|
|
$13 = Math_fround(Math_fround($13 * $16) - Math_fround($17 * $19));
|
|
$19 = Math_fround(Math_fround($32 * $23) - Math_fround($24 * $33));
|
|
$16 = Math_fround($13 + $19);
|
|
$23 = Math_fround(Math_fround($42 * $40) - Math_fround($41 * $43));
|
|
$24 = Math_fround(Math_fround($47 * $45) - Math_fround($46 * $48));
|
|
$17 = Math_fround($23 + $24);
|
|
HEAPF32[$2 >> 2] = $11 + Math_fround($16 + $17);
|
|
$13 = Math_fround($13 - $19);
|
|
$19 = Math_fround($23 - $24);
|
|
$23 = Math_fround(Math_fround($6 * $13) + Math_fround($5 * $19));
|
|
$24 = Math_fround($15 + Math_fround(Math_fround($3 * $20) + Math_fround($8 * $22)));
|
|
HEAPF32[$4 + 4 >> 2] = $23 + $24;
|
|
$32 = Math_fround($11 + Math_fround(Math_fround($3 * $16) + Math_fround($8 * $17)));
|
|
$31 = Math_fround($31 - $37);
|
|
$33 = Math_fround($44 - $49);
|
|
$37 = Math_fround(Math_fround($6 * $31) + Math_fround($5 * $33));
|
|
HEAPF32[$4 >> 2] = $32 - $37;
|
|
HEAPF32[$10 + 4 >> 2] = $24 - $23;
|
|
HEAPF32[$10 >> 2] = $37 + $32;
|
|
$13 = Math_fround(Math_fround($6 * $19) - Math_fround($5 * $13));
|
|
$15 = Math_fround($15 + Math_fround(Math_fround($8 * $20) + Math_fround($3 * $22)));
|
|
HEAPF32[$7 + 4 >> 2] = $13 + $15;
|
|
$20 = Math_fround(Math_fround($5 * $31) - Math_fround($6 * $33));
|
|
$11 = Math_fround($11 + Math_fround(Math_fround($8 * $16) + Math_fround($3 * $17)));
|
|
HEAPF32[$7 >> 2] = $20 + $11;
|
|
HEAPF32[$9 + 4 >> 2] = $15 - $13;
|
|
HEAPF32[$9 >> 2] = $11 - $20;
|
|
$10 = $10 + 8 | 0;
|
|
$9 = $9 + 8 | 0;
|
|
$7 = $7 + 8 | 0;
|
|
$4 = $4 + 8 | 0;
|
|
$2 = $2 + 8 | 0;
|
|
$25 = $25 + 1 | 0;
|
|
if (($25 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$27 = $27 + 1 | 0;
|
|
if (($28 | 0) != ($27 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$2 = $30 - 1 | 0;
|
|
if (($30 | 0) > 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
__stack_pointer = $29 + 32 | 0;
|
|
return;
|
|
}
|
|
celt_fatal(42449, 42433, 76);
|
|
abort();
|
|
}
|
|
function clt_compute_allocation($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18) {
|
|
var $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $40 = 0, $41 = 0, $42 = 0;
|
|
$19 = __stack_pointer;
|
|
$41 = $19;
|
|
$8 = ($8 | 0) > 0 ? $8 : 0;
|
|
$39 = (($8 | 0) > 7) << 3;
|
|
$33 = $8 - $39 | 0;
|
|
$37 = HEAP32[$0 + 8 >> 2];
|
|
label$1 : {
|
|
if (($13 | 0) != 2) {
|
|
break label$1;
|
|
}
|
|
$35 = HEAPU8[($2 - $1 | 0) + 42192 | 0];
|
|
if (($35 | 0) > ($33 | 0)) {
|
|
$35 = 0;
|
|
break label$1;
|
|
}
|
|
$8 = $33 - $35 | 0;
|
|
$36 = (($8 | 0) > 7) << 3;
|
|
$33 = $8 - $36 | 0;
|
|
}
|
|
$8 = ($37 << 2) + 15 & -16;
|
|
$23 = $19 - $8 | 0;
|
|
$19 = $23;
|
|
__stack_pointer = $19;
|
|
$30 = $19 - $8 | 0;
|
|
$19 = $30;
|
|
__stack_pointer = $19;
|
|
$27 = $19 - $8 | 0;
|
|
$19 = $27;
|
|
__stack_pointer = $19;
|
|
$28 = $13 << 3;
|
|
$34 = $19 - $8 | 0;
|
|
__stack_pointer = $34;
|
|
$38 = ($1 | 0) >= ($2 | 0);
|
|
if (!$38) {
|
|
$25 = $14 + 3 | 0;
|
|
$24 = Math_imul(($5 - $14 | 0) - 5 | 0, $13);
|
|
$26 = HEAP32[$0 + 32 >> 2];
|
|
$20 = HEAPU16[$26 + ($1 << 1) >> 1];
|
|
$8 = $1;
|
|
while (1) {
|
|
$5 = $20 << 16;
|
|
$21 = $8 << 2;
|
|
$19 = $8 + 1 | 0;
|
|
$20 = HEAP16[($19 << 1) + $26 >> 1];
|
|
$5 = $20 - ($5 >> 16) | 0;
|
|
$22 = Math_imul($5, 3) << $14 << 3 >> 4;
|
|
HEAP32[$27 + $21 >> 2] = ($22 | 0) < ($28 | 0) ? $28 : $22;
|
|
HEAP32[$21 + $34 >> 2] = (Math_imul(Math_imul(($8 ^ -1) + $2 | 0, $24), $5) << $25 >> 6) - ($5 << $14 == 1 ? $28 : 0);
|
|
$8 = $19;
|
|
if (($2 | 0) != ($19 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$40 = HEAP32[$0 + 48 >> 2];
|
|
$32 = $40 - 1 | 0;
|
|
$29 = 1;
|
|
label$6 : {
|
|
while (1) {
|
|
$31 = $29 + $32 >> 1;
|
|
if (!$38) {
|
|
$25 = Math_imul($31, $37);
|
|
$24 = HEAP32[$0 + 32 >> 2];
|
|
$21 = HEAPU16[$24 + ($2 << 1) >> 1];
|
|
$26 = HEAP32[$0 + 52 >> 2];
|
|
$20 = 0;
|
|
$8 = $2;
|
|
$22 = 0;
|
|
while (1) {
|
|
$5 = $21 << 16 >> 16;
|
|
$8 = $8 - 1 | 0;
|
|
$21 = HEAP16[($8 << 1) + $24 >> 1];
|
|
$5 = Math_imul(Math_imul($5 - $21 | 0, $13), HEAPU8[($8 + $25 | 0) + $26 | 0]) << $14;
|
|
$19 = $5 >> 2;
|
|
$22 = !$22;
|
|
if (($5 | 0) >= 4) {
|
|
$19 = HEAP32[($8 << 2) + $34 >> 2] + $19 | 0;
|
|
$19 = ($19 | 0) > 0 ? $19 : 0;
|
|
}
|
|
$5 = $8 << 2;
|
|
$19 = HEAP32[$5 + $3 >> 2] + $19 | 0;
|
|
label$11 : {
|
|
if (!(($19 | 0) < HEAP32[$5 + $27 >> 2] ? $22 : 0)) {
|
|
$5 = HEAP32[$4 + $5 >> 2];
|
|
$19 = ($5 | 0) > ($19 | 0) ? $19 : $5;
|
|
$22 = 1;
|
|
break label$11;
|
|
}
|
|
$19 = ($19 | 0) < ($28 | 0) ? 0 : $28;
|
|
$22 = 0;
|
|
}
|
|
$20 = $20 + $19 | 0;
|
|
if (($1 | 0) < ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = ($20 | 0) > ($33 | 0);
|
|
$29 = $8 ? $29 : $31 + 1 | 0;
|
|
$32 = $8 ? $31 - 1 | 0 : $32;
|
|
if (($29 | 0) <= ($32 | 0)) {
|
|
continue;
|
|
}
|
|
$31 = $1;
|
|
if ($38) {
|
|
break label$6;
|
|
}
|
|
$42 = Math_imul($29, $37);
|
|
$26 = Math_imul($29 - 1 | 0, $37);
|
|
$32 = HEAP32[$0 + 32 >> 2];
|
|
$25 = HEAPU16[$32 + ($1 << 1) >> 1];
|
|
$24 = HEAP32[$0 + 52 >> 2];
|
|
$8 = $1;
|
|
$31 = $8;
|
|
while (1) {
|
|
$19 = $25 << 16;
|
|
$5 = $8 + 1 | 0;
|
|
$25 = HEAP16[($5 << 1) + $32 >> 1];
|
|
$19 = Math_imul($25 - ($19 >> 16) | 0, $13);
|
|
$20 = Math_imul($19, HEAPU8[($8 + $26 | 0) + $24 | 0]) << $14;
|
|
if (($29 | 0) >= ($40 | 0)) {
|
|
$19 = HEAP32[($8 << 2) + $4 >> 2];
|
|
} else {
|
|
$19 = Math_imul(HEAPU8[($8 + $42 | 0) + $24 | 0], $19) << $14 >> 2;
|
|
}
|
|
$21 = $20 >> 2;
|
|
if (($20 | 0) >= 4) {
|
|
$20 = HEAP32[($8 << 2) + $34 >> 2] + $21 | 0;
|
|
$21 = ($20 | 0) > 0 ? $20 : 0;
|
|
}
|
|
if (($19 | 0) >= 1) {
|
|
$19 = HEAP32[($8 << 2) + $34 >> 2] + $19 | 0;
|
|
$19 = ($19 | 0) > 0 ? $19 : 0;
|
|
}
|
|
$20 = $8 << 2;
|
|
$22 = HEAP32[$20 + $3 >> 2];
|
|
$21 = (($29 | 0) > 1 ? $22 : 0) + $21 | 0;
|
|
HEAP32[$20 + $23 >> 2] = $21;
|
|
$19 = ($19 - $21 | 0) + $22 | 0;
|
|
HEAP32[$20 + $30 >> 2] = ($19 | 0) > 0 ? $19 : 0;
|
|
$31 = ($22 | 0) > 0 ? $8 : $31;
|
|
$8 = $5;
|
|
if (($8 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$6;
|
|
}
|
|
$8 = ($33 | 0) < 0;
|
|
$29 = $8 ? $29 : $31 + 1 | 0;
|
|
$32 = $8 ? $31 - 1 | 0 : $32;
|
|
if (($29 | 0) <= ($32 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$31 = $1;
|
|
}
|
|
$3 = ($13 | 0) > 1;
|
|
$24 = 64;
|
|
$25 = 0;
|
|
$26 = 0;
|
|
while (1) {
|
|
label$20 : {
|
|
$22 = $24 + $25 >> 1;
|
|
$5 = $2;
|
|
$20 = 0;
|
|
$21 = 0;
|
|
if (!$38) {
|
|
while (1) {
|
|
$5 = $5 - 1 | 0;
|
|
$8 = $5 << 2;
|
|
$19 = (Math_imul(HEAP32[$30 + $8 >> 2], $22) >> 6) + HEAP32[$8 + $23 >> 2] | 0;
|
|
label$23 : {
|
|
if (!(($19 | 0) < HEAP32[$8 + $27 >> 2] ? !$21 : 0)) {
|
|
$8 = HEAP32[$4 + $8 >> 2];
|
|
$8 = ($8 | 0) > ($19 | 0) ? $19 : $8;
|
|
$21 = 1;
|
|
break label$23;
|
|
}
|
|
$8 = ($19 | 0) < ($28 | 0) ? 0 : $28;
|
|
$21 = 0;
|
|
}
|
|
$20 = $20 + $8 | 0;
|
|
if (($1 | 0) < ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = ($20 | 0) > ($33 | 0);
|
|
$25 = $8 ? $25 : $22;
|
|
$24 = $8 ? $22 : $24;
|
|
$26 = $26 + 1 | 0;
|
|
if (($26 | 0) != 6) {
|
|
continue;
|
|
}
|
|
$8 = 0;
|
|
$20 = $2;
|
|
$21 = 0;
|
|
while (1) {
|
|
$20 = $20 - 1 | 0;
|
|
$19 = $20 << 2;
|
|
$5 = HEAP32[$19 + $23 >> 2] + (Math_imul(HEAP32[$19 + $30 >> 2], $25) >> 6) | 0;
|
|
$22 = ($5 | 0) >= HEAP32[$19 + $27 >> 2];
|
|
$24 = $19 + $10 | 0;
|
|
$5 = $21 ? $5 : $22 ? $5 : ($5 | 0) < ($28 | 0) ? 0 : $28;
|
|
$19 = HEAP32[$4 + $19 >> 2];
|
|
$19 = ($5 | 0) < ($19 | 0) ? $5 : $19;
|
|
HEAP32[$24 >> 2] = $19;
|
|
$8 = $8 + $19 | 0;
|
|
$21 = $21 | $22;
|
|
if (($1 | 0) < ($20 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$20;
|
|
}
|
|
$8 = 0;
|
|
$19 = ($33 | 0) < 0;
|
|
$25 = $19 ? $25 : $22;
|
|
$24 = $19 ? $22 : $24;
|
|
$26 = $26 + 1 | 0;
|
|
if (($26 | 0) != 6) {
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
$22 = $2 - 1 | 0;
|
|
label$27 : {
|
|
label$28 : {
|
|
if (($31 | 0) >= ($22 | 0)) {
|
|
$5 = $2;
|
|
$19 = $35;
|
|
break label$28;
|
|
}
|
|
$32 = $1 + 2 | 0;
|
|
$30 = $28 + 8 | 0;
|
|
$21 = $2;
|
|
while (1) {
|
|
$19 = HEAP32[$0 + 32 >> 2];
|
|
$20 = HEAP16[$19 + ($21 << 1) >> 1];
|
|
$5 = $22;
|
|
$25 = HEAP16[($5 << 1) + $19 >> 1];
|
|
$29 = $20 - $25 | 0;
|
|
$34 = $5 << 2;
|
|
$22 = $34 + $10 | 0;
|
|
$23 = HEAP32[$22 >> 2];
|
|
$24 = $33 - $8 | 0;
|
|
$19 = HEAP16[($1 << 1) + $19 >> 1];
|
|
$26 = ($24 >>> 0) / ($20 - $19 >>> 0) | 0;
|
|
$19 = Math_imul($19 - $20 | 0, $26) + $24 + ($19 - $25) | 0;
|
|
$20 = ($23 + Math_imul($29, $26) | 0) + (($19 | 0) > 0 ? $19 : 0) | 0;
|
|
$19 = HEAP32[$27 + $34 >> 2];
|
|
if (($20 | 0) >= ((($19 | 0) > ($30 | 0) ? $19 : $30) | 0)) {
|
|
label$32 : {
|
|
label$33 : {
|
|
if ($16) {
|
|
if (!(($21 | 0) <= ($32 | 0) | (Math_imul(($21 | 0) > 17 ? ($17 | 0) < ($21 | 0) ? 9 : 7 : 0, $29) << $14 << 3 >> 4 < ($20 | 0) ? ($5 | 0) <= ($18 | 0) : 0))) {
|
|
ec_enc_bit_logp($15, 0, 1);
|
|
break label$32;
|
|
}
|
|
ec_enc_bit_logp($15, 1, 1);
|
|
break label$33;
|
|
}
|
|
if (!ec_dec_bit_logp($15, 1)) {
|
|
break label$32;
|
|
}
|
|
}
|
|
$5 = $21;
|
|
$19 = $35;
|
|
break label$27;
|
|
}
|
|
$20 = $20 - 8 | 0;
|
|
$23 = HEAP32[$22 >> 2];
|
|
$8 = $8 + 8 | 0;
|
|
}
|
|
$19 = $35;
|
|
if (($19 | 0) >= 1) {
|
|
$19 = HEAPU8[($5 - $1 | 0) + 42192 | 0];
|
|
}
|
|
$20 = ($20 | 0) < ($28 | 0) ? 0 : $28;
|
|
HEAP32[$22 >> 2] = $20;
|
|
$8 = (($8 - ($23 + $35 | 0) | 0) + $20 | 0) + $19 | 0;
|
|
$35 = $19;
|
|
$21 = $5;
|
|
$22 = $21 - 1 | 0;
|
|
if (($31 | 0) < ($22 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$33 = $33 + $39 | 0;
|
|
}
|
|
label$38 : {
|
|
label$39 : {
|
|
label$40 : {
|
|
if (($1 | 0) < ($5 | 0)) {
|
|
label$42 : {
|
|
label$43 : {
|
|
label$44 : {
|
|
label$45 : {
|
|
$17 = $36;
|
|
label$46 : {
|
|
if (($19 | 0) >= 1) {
|
|
if (!$16) {
|
|
break label$45;
|
|
}
|
|
$19 = HEAP32[$6 >> 2];
|
|
$19 = ($5 | 0) > ($19 | 0) ? $19 : $5;
|
|
HEAP32[$6 >> 2] = $19;
|
|
ec_enc_uint($15, $19 - $1 | 0, ($5 - $1 | 0) + 1 | 0);
|
|
$19 = HEAP32[$6 >> 2];
|
|
break label$46;
|
|
}
|
|
HEAP32[$6 >> 2] = 0;
|
|
$19 = 0;
|
|
}
|
|
$20 = ($19 | 0) > ($1 | 0);
|
|
$19 = $20 ? 0 : $17;
|
|
if (!$36 | !$20) {
|
|
break label$43;
|
|
}
|
|
if (!$16) {
|
|
break label$44;
|
|
}
|
|
ec_enc_bit_logp($15, HEAP32[$7 >> 2], 1);
|
|
break label$42;
|
|
}
|
|
$19 = ec_dec_uint($15, ($5 - $1 | 0) + 1 | 0) + $1 | 0;
|
|
HEAP32[$6 >> 2] = $19;
|
|
$20 = ($1 | 0) < ($19 | 0);
|
|
$19 = $20 ? 0 : $36;
|
|
if (!$36 | !$20) {
|
|
break label$43;
|
|
}
|
|
}
|
|
HEAP32[$7 >> 2] = ec_dec_bit_logp($15, 1);
|
|
break label$42;
|
|
}
|
|
HEAP32[$7 >> 2] = 0;
|
|
}
|
|
$31 = $14 << 3;
|
|
$22 = HEAP32[$0 + 32 >> 2];
|
|
$30 = HEAP16[$22 + ($1 << 1) >> 1];
|
|
$25 = ($33 - $8 | 0) + $19 | 0;
|
|
$20 = HEAP16[($5 << 1) + $22 >> 1];
|
|
$23 = ($25 >>> 0) / ($20 - $30 >>> 0) | 0;
|
|
$24 = Math_imul($23, $30 - $20 | 0);
|
|
$20 = $30;
|
|
$8 = $1;
|
|
while (1) {
|
|
$21 = $20 << 16;
|
|
$27 = ($8 << 2) + $10 | 0;
|
|
$19 = $8 + 1 | 0;
|
|
$20 = HEAP16[($19 << 1) + $22 >> 1];
|
|
HEAP32[$27 >> 2] = HEAP32[$27 >> 2] + Math_imul($20 - ($21 >> 16) | 0, $23);
|
|
$8 = $19;
|
|
if (($5 | 0) != ($19 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = $24 + $25 | 0;
|
|
$21 = $30;
|
|
$19 = $1;
|
|
while (1) {
|
|
$27 = $21 << 16;
|
|
$23 = ($19 << 2) + $10 | 0;
|
|
$20 = $19 + 1 | 0;
|
|
$21 = HEAP16[($20 << 1) + $22 >> 1];
|
|
$19 = $21 - ($27 >> 16) | 0;
|
|
$19 = ($8 | 0) < ($19 | 0) ? $8 : $19;
|
|
HEAP32[$23 >> 2] = $19 + HEAP32[$23 >> 2];
|
|
$8 = $8 - $19 | 0;
|
|
$19 = $20;
|
|
if (($19 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$29 = ($13 | 0) > 1 ? 4 : 3;
|
|
$27 = 0;
|
|
label$50 : {
|
|
while (1) {
|
|
if (($1 | 0) == ($5 | 0)) {
|
|
break label$50;
|
|
}
|
|
$8 = $1 << 2;
|
|
$19 = $10 + $8 | 0;
|
|
$20 = HEAP32[$19 >> 2];
|
|
if (($20 | 0) <= -1) {
|
|
break label$40;
|
|
}
|
|
$23 = $30 << 16;
|
|
$21 = $20 + $27 | 0;
|
|
$25 = $1 + 1 | 0;
|
|
$30 = HEAP16[($25 << 1) + $22 >> 1];
|
|
$23 = $30 - ($23 >> 16) << $14;
|
|
label$52 : {
|
|
if (($23 | 0) >= 2) {
|
|
$26 = 0;
|
|
$20 = $21 - HEAP32[$4 + $8 >> 2] | 0;
|
|
$20 = ($20 | 0) > 0 ? $20 : 0;
|
|
$24 = $21 - $20 | 0;
|
|
HEAP32[$19 >> 2] = $24;
|
|
$21 = Math_imul($13, $23);
|
|
if (!(HEAP32[$7 >> 2] | (($23 | 0) == 2 | ($13 | 0) != 2))) {
|
|
$26 = HEAP32[$6 >> 2] > ($1 | 0);
|
|
}
|
|
$21 = $21 + $26 | 0;
|
|
$26 = $21 << 3;
|
|
$15 = (($23 | 0) == 2 ? $26 >> 2 : 0) + Math_imul($21, -21) | 0;
|
|
$23 = Math_imul(HEAP16[HEAP32[$0 + 56 >> 2] + ($1 << 1) >> 1] + $31 | 0, $21);
|
|
$1 = $15 + ($23 >> 1) | 0;
|
|
$34 = $24 + $1 | 0;
|
|
label$55 : {
|
|
if (($34 | 0) < $21 << 4) {
|
|
$1 = ($23 >> 2) + $1 | 0;
|
|
break label$55;
|
|
}
|
|
if ((Math_imul($21, 24) | 0) <= ($34 | 0)) {
|
|
break label$55;
|
|
}
|
|
$1 = ($23 >> 3) + $1 | 0;
|
|
}
|
|
$23 = $8 + $11 | 0;
|
|
$24 = (($21 << 2) + $24 | 0) + $1 | 0;
|
|
$21 = ((($24 | 0) > 0 ? $24 : 0) >>> 0) / ($21 >>> 0) >>> 3 | 0;
|
|
HEAP32[$23 >> 2] = $21;
|
|
$24 = HEAP32[$19 >> 2];
|
|
if ((Math_imul($13, $21) | 0) > $24 >> 3) {
|
|
$21 = $24 >> $3 >> 3;
|
|
HEAP32[$23 >> 2] = $21;
|
|
}
|
|
$21 = ($21 | 0) < 8 ? $21 : 8;
|
|
HEAP32[$23 >> 2] = $21;
|
|
HEAP32[$8 + $12 >> 2] = (HEAP32[$19 >> 2] + $1 | 0) <= (Math_imul($21, $26) | 0);
|
|
HEAP32[$19 >> 2] = HEAP32[$19 >> 2] - Math_imul(HEAP32[$23 >> 2], $28);
|
|
break label$52;
|
|
}
|
|
$1 = $21 - $28 | 0;
|
|
$20 = ($1 | 0) > 0 ? $1 : 0;
|
|
HEAP32[$19 >> 2] = $21 - $20;
|
|
HEAP32[$8 + $11 >> 2] = 0;
|
|
HEAP32[$8 + $12 >> 2] = 1;
|
|
}
|
|
if ($20) {
|
|
$1 = $8 + $11 | 0;
|
|
$15 = $1;
|
|
$21 = $20 >>> $29 | 0;
|
|
$1 = HEAP32[$1 >> 2];
|
|
$23 = 8 - $1 | 0;
|
|
$21 = ($21 | 0) < ($23 | 0) ? $21 : $23;
|
|
HEAP32[$15 >> 2] = $1 + $21;
|
|
$1 = Math_imul($21, $28);
|
|
HEAP32[$8 + $12 >> 2] = ($1 | 0) >= ($20 - $27 | 0);
|
|
$27 = $20 - $1 | 0;
|
|
} else {
|
|
$27 = 0;
|
|
}
|
|
if (HEAP32[$19 >> 2] <= -1) {
|
|
break label$39;
|
|
}
|
|
$1 = $25;
|
|
if (HEAP32[$8 + $11 >> 2] > -1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
celt_fatal(42296, 42253, 514);
|
|
abort();
|
|
}
|
|
HEAP32[$9 >> 2] = $27;
|
|
if (($2 | 0) > ($5 | 0)) {
|
|
$8 = $5;
|
|
while (1) {
|
|
$19 = $8 << 2;
|
|
$20 = $19 + $11 | 0;
|
|
$1 = $10 + $19 | 0;
|
|
$21 = HEAP32[$1 >> 2] >> $3 >> 3;
|
|
HEAP32[$20 >> 2] = $21;
|
|
if (HEAP32[$1 >> 2] != (Math_imul($21, $28) | 0)) {
|
|
break label$38;
|
|
}
|
|
HEAP32[$1 >> 2] = 0;
|
|
HEAP32[$12 + $19 >> 2] = HEAP32[$20 >> 2] < 1;
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $41;
|
|
return $5;
|
|
}
|
|
celt_fatal(42216, 42253, 391);
|
|
abort();
|
|
}
|
|
celt_fatal(42265, 42253, 442);
|
|
abort();
|
|
}
|
|
celt_fatal(42265, 42253, 513);
|
|
abort();
|
|
}
|
|
celt_fatal(42328, 42253, 524);
|
|
abort();
|
|
}
|
|
function compute_theta($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = Math_fround(0), $16 = Math_fround(0), $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = Math_fround(0), $22 = 0, $23 = 0, $24 = 0, $25 = 0;
|
|
$22 = HEAP32[$0 + 36 >> 2];
|
|
$14 = HEAP32[$0 + 28 >> 2];
|
|
$12 = HEAP32[$0 + 16 >> 2];
|
|
$23 = HEAP32[$0 >> 2];
|
|
$11 = 1;
|
|
$19 = HEAP32[$5 >> 2];
|
|
$24 = HEAP32[$0 + 8 >> 2];
|
|
$20 = HEAP32[$0 + 12 >> 2];
|
|
$8 = HEAP16[HEAP32[$24 + 56 >> 2] + ($20 << 1) >> 1] + ($8 << 3) | 0;
|
|
$13 = ($19 - $8 | 0) - 32 | 0;
|
|
$17 = $8 >> 1;
|
|
$8 = ($4 | 0) == 2 & ($9 | 0) != 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
label$10 : {
|
|
label$11 : {
|
|
label$12 : {
|
|
$17 = $17 + ($8 ? -16 : -4) | 0;
|
|
$8 = ($4 << 1) + ($8 ? -2 : -1) | 0;
|
|
$8 = (Math_imul($17, $8) + $19 | 0) / ($8 | 0) | 0;
|
|
$8 = ($8 | 0) > ($13 | 0) ? $13 : $8;
|
|
$8 = ($8 | 0) < 64 ? $8 : 64;
|
|
if (($8 | 0) >= 4) {
|
|
$11 = (HEAP16[(($8 & 7) << 1) + 42144 >> 1] >> 14 - ($8 >>> 3 | 0)) + 1 & -2;
|
|
if (($11 | 0) >= 257) {
|
|
break label$12;
|
|
}
|
|
}
|
|
$11 = ($12 | 0) > ($20 | 0) ? $11 : $9 ? 1 : $11;
|
|
label$14 : {
|
|
label$15 : {
|
|
label$16 : {
|
|
if ($23) {
|
|
$8 = stereo_itheta($2, $3, $9, $4, HEAP32[$0 + 44 >> 2]);
|
|
$19 = ec_tell_frac($14);
|
|
if (($11 | 0) == 1) {
|
|
break label$14;
|
|
}
|
|
label$18 : {
|
|
label$19 : {
|
|
if ($9) {
|
|
$0 = HEAP32[$0 + 48 >> 2];
|
|
if ($0) {
|
|
break label$19;
|
|
}
|
|
$0 = Math_imul($8, $11) - -8192 >> 14;
|
|
break label$18;
|
|
}
|
|
$8 = Math_imul($8, $11);
|
|
$13 = $8 - -8192 | 0;
|
|
$12 = $13 >> 14;
|
|
label$21 : {
|
|
if (($12 | 0) >= ($11 | 0)) {
|
|
$0 = $12;
|
|
break label$21;
|
|
}
|
|
if (($8 | 0) < 8192) {
|
|
$0 = $12;
|
|
break label$21;
|
|
}
|
|
if (!HEAP32[$0 + 56 >> 2]) {
|
|
$0 = $12;
|
|
break label$21;
|
|
}
|
|
$0 = $11;
|
|
$13 = (($13 & -16384) >>> 0) / ($0 >>> 0) << 16;
|
|
$8 = Math_imul($13 >> 13, $13 >> 16) + 32768 >> 16;
|
|
$18 = ((Math_imul($8, ((Math_imul((Math_imul($8, -626) + 16384 >> 15) + 8277 | 0, $8) << 1) + 32768 & -65536) - 501415936 >> 16) + 16384 >>> 15 | 0) - $8 << 16) - -2147483648 >> 16;
|
|
$17 = Math_clz32($18);
|
|
$8 = 1073741824 - $13 | 0;
|
|
$8 = Math_imul($8 >> 13, $8 >> 16) + 32768 >> 16;
|
|
$8 = ((Math_imul($8, ((Math_imul((Math_imul($8, -626) + 16384 >> 15) + 8277 | 0, $8) << 1) + 32768 & -65536) - 501415936 >> 16) + 16384 >>> 15 | 0) - $8 << 16) - -2147483648 >> 16;
|
|
$13 = Math_clz32($8);
|
|
$18 = $18 << $17 - 17 << 16 >> 16;
|
|
$8 = $8 << $13 - 17 << 16 >> 16;
|
|
$8 = Math_imul(($17 - $13 << 11) - (Math_imul($18, (Math_imul($18, -2597) + 16384 >> 15) + 7932 | 0) + 16384 >>> 15 | 0) + (Math_imul($8, (Math_imul($8, -2597) + 16384 >> 15) + 7932 | 0) + 16384 >>> 15) << 16 >> 16, ($4 << 23) - 8388608 >> 16) + 16384 >> 15;
|
|
$13 = HEAP32[$5 >> 2];
|
|
if (($8 | 0) > ($13 | 0)) {
|
|
break label$21;
|
|
}
|
|
$0 = (0 - $13 | 0) > ($8 | 0) ? 0 : $12;
|
|
}
|
|
if (($7 | 0) < 2) {
|
|
break label$16;
|
|
}
|
|
break label$9;
|
|
}
|
|
$8 = Math_imul($8, $11) + (((($8 | 0) > 8192 ? 32767 : -32767) | 0) / ($11 | 0) | 0) | 0;
|
|
$8 = ($8 | 0) < 0 ? 0 : $8 >> 14;
|
|
$0 = (($0 ^ -1) >>> 31 | 0) + (($8 | 0) < ($11 | 0) ? $8 : $11 - 1 | 0) | 0;
|
|
}
|
|
if (($4 | 0) <= 2) {
|
|
break label$9;
|
|
}
|
|
$8 = ($11 | 0) / 2 | 0;
|
|
$12 = Math_imul($8, 3) + 3 | 0;
|
|
$13 = Math_imul($0, 3);
|
|
$7 = ($0 | 0) > ($8 | 0);
|
|
ec_encode($14, $7 ? ($12 + ($8 ^ -1) | 0) + $0 | 0 : $13, $7 ? ($12 - $8 | 0) + $0 | 0 : $13 + 3 | 0, $8 + $12 | 0);
|
|
break label$8;
|
|
}
|
|
$19 = ec_tell_frac($14);
|
|
if (($11 | 0) == 1) {
|
|
break label$11;
|
|
}
|
|
if (!(!$9 | ($4 | 0) < 3)) {
|
|
$17 = $14;
|
|
$8 = ($11 | 0) / 2 | 0;
|
|
$7 = $8 + 1 | 0;
|
|
$12 = Math_imul($7, 3);
|
|
$13 = $8 + $12 | 0;
|
|
$0 = ec_decode($14, $13);
|
|
label$26 : {
|
|
if (($12 | 0) > ($0 | 0)) {
|
|
$0 = ($0 | 0) / 3 | 0;
|
|
break label$26;
|
|
}
|
|
$0 = $0 - ($7 << 1) | 0;
|
|
}
|
|
$7 = Math_imul($0, 3);
|
|
$18 = ($0 | 0) > ($8 | 0);
|
|
ec_dec_update($17, $18 ? (($8 ^ -1) + $12 | 0) + $0 | 0 : $7, $18 ? ($12 - $8 | 0) + $0 | 0 : $7 + 3 | 0, $13);
|
|
break label$8;
|
|
}
|
|
if ($9 ? 0 : ($7 | 0) <= 1) {
|
|
break label$15;
|
|
}
|
|
$0 = ec_dec_uint($14, $11 + 1 | 0);
|
|
break label$8;
|
|
}
|
|
$18 = $11 - $0 | 0;
|
|
$17 = $18 + 1 | 0;
|
|
$25 = $0 + 1 | 0;
|
|
$8 = $11 >> 1;
|
|
$13 = ($8 | 0) < ($0 | 0);
|
|
$7 = $13 ? $17 : $25;
|
|
$8 = $8 + 1 | 0;
|
|
$12 = Math_imul($8, $8);
|
|
$8 = $13 ? $12 - (Math_imul($18 + 2 | 0, $17) >> 1) | 0 : Math_imul($0, $25) >> 1;
|
|
ec_encode($14, $8, $7 + $8 | 0, $12);
|
|
break label$8;
|
|
}
|
|
$7 = $14;
|
|
$2 = $11 >> 1;
|
|
$9 = $2 + 1 | 0;
|
|
$3 = Math_imul($9, $9);
|
|
$0 = ec_decode($14, $3);
|
|
label$30 : {
|
|
if (($0 | 0) < Math_imul($2, $9) >> 1) {
|
|
$9 = isqrt32($0 << 3 | 1) - 1 >>> 1 | 0;
|
|
$0 = $9 + 1 | 0;
|
|
$2 = Math_imul($0, $9) >>> 1 | 0;
|
|
break label$30;
|
|
}
|
|
$9 = $11 + 1 | 0;
|
|
$2 = $9;
|
|
$9 = ($9 << 1) - isqrt32(($0 ^ -1) + $3 << 3 | 1) >>> 1 | 0;
|
|
$0 = $2 - $9 | 0;
|
|
$2 = $3 - (Math_imul($0, ($11 - $9 | 0) + 2 | 0) >> 1) | 0;
|
|
}
|
|
ec_dec_update($7, $2, $0 + $2 | 0, $3);
|
|
$8 = ($9 << 14 >>> 0) / ($11 >>> 0) | 0;
|
|
break label$5;
|
|
}
|
|
if (!$9) {
|
|
break label$5;
|
|
}
|
|
$9 = 0;
|
|
$12 = 0;
|
|
label$32 : {
|
|
if (($8 | 0) < 8193) {
|
|
break label$32;
|
|
}
|
|
$11 = HEAP32[$0 + 52 >> 2];
|
|
if ($11) {
|
|
break label$32;
|
|
}
|
|
$12 = 1;
|
|
if (($4 | 0) < 1) {
|
|
break label$32;
|
|
}
|
|
$12 = !$11;
|
|
$11 = 0;
|
|
while (1) {
|
|
$8 = ($11 << 2) + $3 | 0;
|
|
HEAPF32[$8 >> 2] = -HEAPF32[$8 >> 2];
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($4 | 0) < 1) {
|
|
break label$10;
|
|
}
|
|
$15 = HEAPF32[($20 << 2) + $22 >> 2];
|
|
$16 = HEAPF32[(HEAP32[$24 + 8 >> 2] + $20 << 2) + $22 >> 2];
|
|
$21 = Math_fround(Math_fround(Math_sqrt(Math_fround(Math_fround(Math_fround($15 * $15) + Math_fround(1.0000000036274937e-15)) + Math_fround($16 * $16)))) + Math_fround(1.0000000036274937e-15));
|
|
$16 = Math_fround($16 / $21);
|
|
$15 = Math_fround($15 / $21);
|
|
while (1) {
|
|
$11 = $9 << 2;
|
|
$8 = $11 + $2 | 0;
|
|
HEAPF32[$8 >> 2] = Math_fround($15 * HEAPF32[$8 >> 2]) + Math_fround($16 * HEAPF32[$3 + $11 >> 2]);
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$10;
|
|
}
|
|
celt_fatal(42160, 41800, 669);
|
|
abort();
|
|
}
|
|
$12 = 0;
|
|
if (!$9) {
|
|
break label$7;
|
|
}
|
|
}
|
|
$4 = 0;
|
|
label$35 : {
|
|
if (HEAP32[$5 >> 2] < 17) {
|
|
break label$35;
|
|
}
|
|
$4 = 0;
|
|
if (HEAP32[$0 + 32 >> 2] < 17) {
|
|
break label$35;
|
|
}
|
|
if ($23) {
|
|
ec_enc_bit_logp($14, $12, 2);
|
|
$4 = $12;
|
|
break label$35;
|
|
}
|
|
$4 = ec_dec_bit_logp($14, 2);
|
|
}
|
|
$12 = HEAP32[$0 + 52 >> 2] ? 0 : $4;
|
|
break label$7;
|
|
}
|
|
ec_enc_uint($14, $0, $11 + 1 | 0);
|
|
}
|
|
if (($0 | 0) <= -1) {
|
|
break label$6;
|
|
}
|
|
$0 = $0 << 14;
|
|
$8 = ($0 >>> 0) / ($11 >>> 0) | 0;
|
|
if (!$9 | !$23) {
|
|
break label$5;
|
|
}
|
|
if ($0 >>> 0 < $11 >>> 0) {
|
|
$12 = 0;
|
|
if (($4 | 0) < 1) {
|
|
break label$7;
|
|
}
|
|
$15 = HEAPF32[($20 << 2) + $22 >> 2];
|
|
$16 = HEAPF32[(HEAP32[$24 + 8 >> 2] + $20 << 2) + $22 >> 2];
|
|
$21 = Math_fround(Math_fround(Math_sqrt(Math_fround(Math_fround(Math_fround($15 * $15) + Math_fround(1.0000000036274937e-15)) + Math_fround($16 * $16)))) + Math_fround(1.0000000036274937e-15));
|
|
$16 = Math_fround($16 / $21);
|
|
$15 = Math_fround($15 / $21);
|
|
$9 = 0;
|
|
while (1) {
|
|
$0 = $9 << 2;
|
|
$11 = $2 + $0 | 0;
|
|
HEAPF32[$11 >> 2] = Math_fround($15 * HEAPF32[$11 >> 2]) + Math_fround($16 * HEAPF32[$0 + $3 >> 2]);
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$7;
|
|
}
|
|
if (($4 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$9 = 0;
|
|
while (1) {
|
|
$0 = $9 << 2;
|
|
$11 = $2 + $0 | 0;
|
|
$16 = Math_fround(HEAPF32[$11 >> 2] * Math_fround(.7071067690849304));
|
|
$0 = $0 + $3 | 0;
|
|
$15 = Math_fround(HEAPF32[$0 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$11 >> 2] = $16 + $15;
|
|
HEAPF32[$0 >> 2] = $15 - $16;
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$5;
|
|
}
|
|
$4 = ec_tell_frac($14);
|
|
$0 = $4 - $19 | 0;
|
|
HEAP32[$5 >> 2] = HEAP32[$5 >> 2] - $0;
|
|
break label$4;
|
|
}
|
|
celt_fatal(42104, 41800, 838);
|
|
abort();
|
|
}
|
|
$9 = ec_tell_frac($14);
|
|
$0 = $9 - $19 | 0;
|
|
HEAP32[$5 >> 2] = HEAP32[$5 >> 2] - $0;
|
|
$9 = 16384;
|
|
if (($8 | 0) == 16384) {
|
|
break label$3;
|
|
}
|
|
if ($8) {
|
|
break label$2;
|
|
}
|
|
$12 = $8;
|
|
}
|
|
HEAP32[$10 >> 2] = HEAP32[$10 >> 2] & (-1 << $6 ^ -1);
|
|
$4 = -16384;
|
|
$3 = 32767;
|
|
$9 = 0;
|
|
$2 = 0;
|
|
break label$1;
|
|
}
|
|
HEAP32[$10 >> 2] = HEAP32[$10 >> 2] & (-1 << $6 ^ -1) << $6;
|
|
$2 = 32767;
|
|
$12 = 0;
|
|
$3 = 0;
|
|
$4 = 16384;
|
|
break label$1;
|
|
}
|
|
$2 = $8 << 16;
|
|
$9 = Math_imul($2 >> 13, $2 >> 16) + 32768 >> 16;
|
|
$3 = ((Math_imul($9, ((Math_imul((Math_imul($9, -626) + 16384 >> 15) + 8277 | 0, $9) << 1) + 32768 & -65536) - 501415936 >> 16) + 16384 >>> 15 | 0) - $9 << 16) - -2147483648 >> 16;
|
|
$11 = Math_clz32($3);
|
|
$9 = 1073741824 - $2 | 0;
|
|
$9 = Math_imul($9 >> 13, $9 >> 16) + 32768 >> 16;
|
|
$2 = ((Math_imul($9, ((Math_imul((Math_imul($9, -626) + 16384 >> 15) + 8277 | 0, $9) << 1) + 32768 & -65536) - 501415936 >> 16) + 16384 >>> 15 | 0) - $9 << 16) - -2147483648 >> 16;
|
|
$9 = Math_clz32($2);
|
|
$5 = $11 - $9 << 11;
|
|
$11 = $3 << $11 - 17 << 16 >> 16;
|
|
$9 = $2 << $9 - 17 << 16 >> 16;
|
|
$4 = Math_imul($5 - (Math_imul($11, (Math_imul($11, -2597) + 16384 >> 15) + 7932 | 0) + 16384 >>> 15 | 0) + (Math_imul($9, (Math_imul($9, -2597) + 16384 >> 15) + 7932 | 0) + 16384 >>> 15) << 16 >> 16, ($4 << 23) - 8388608 >> 16) + 16384 >> 15;
|
|
$12 = 0;
|
|
$9 = $8;
|
|
}
|
|
HEAP32[$1 + 20 >> 2] = $0;
|
|
HEAP32[$1 + 16 >> 2] = $9;
|
|
HEAP32[$1 + 12 >> 2] = $4;
|
|
HEAP32[$1 + 8 >> 2] = $2;
|
|
HEAP32[$1 + 4 >> 2] = $3;
|
|
HEAP32[$1 >> 2] = $12;
|
|
}
|
|
function silk_noise_shape_analysis_FLP($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0, $12 = Math_fround(0), $13 = 0, $14 = Math_fround(0), $15 = 0, $16 = Math_fround(0), $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = Math_fround(0), $22 = Math_fround(0), $23 = Math_fround(0), $24 = 0, $25 = 0, $26 = 0;
|
|
$11 = __stack_pointer - 1184 | 0;
|
|
__stack_pointer = $11;
|
|
$13 = HEAP32[$0 + 4600 >> 2];
|
|
$4 = HEAP32[$0 + 4716 >> 2];
|
|
$5 = Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4700 >> 2] + HEAP32[$0 + 4696 >> 2] | 0) * Math_fround(.5)) * Math_fround(30517578125e-15));
|
|
HEAPF32[$1 + 696 >> 2] = $5;
|
|
$10 = Math_fround($4 | 0);
|
|
$12 = Math_fround($10 * Math_fround(.0078125));
|
|
$9 = Math_fround(1 / (exp(+Math_fround(Math_fround($12 + Math_fround(-20)) * Math_fround(-.25))) + 1));
|
|
HEAPF32[$1 + 700 >> 2] = $9;
|
|
if (!HEAP32[$0 + 4676 >> 2]) {
|
|
$14 = Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4532 >> 2]) * Math_fround(-.00390625)) + Math_fround(1));
|
|
$12 = Math_fround($12 - Math_fround($14 * Math_fround($14 * Math_fround(Math_fround(Math_fround($5 * Math_fround(.5)) + Math_fround(.5)) * Math_fround($9 + $9)))));
|
|
}
|
|
label$2 : {
|
|
if (HEAPU8[$0 + 4765 | 0] == 2) {
|
|
HEAP8[$0 + 4766 | 0] = 0;
|
|
$5 = HEAPF32[$0 + 10060 >> 2];
|
|
$21 = Math_fround($12 + Math_fround($5 + $5));
|
|
break label$2;
|
|
}
|
|
$16 = Math_fround(Math_fround(Math_fround(Math_fround($10 * Math_fround(-.4000000059604645)) * Math_fround(.0078125)) + Math_fround(6)) * Math_fround(Math_fround(1) - $5));
|
|
$4 = Math_imul(HEAP16[$0 + 4580 >> 1], 5);
|
|
$6 = ($4 | 0) / 2 | 0;
|
|
$5 = Math_fround(0);
|
|
if (($4 | 0) >= 2) {
|
|
$7 = HEAP32[$0 + 4576 >> 2] << 1;
|
|
$14 = Math_fround($7 | 0);
|
|
$9 = Math_fround(0);
|
|
$4 = 0;
|
|
$8 = $7 << 2;
|
|
while (1) {
|
|
$10 = Math_fround(log10(+Math_fround($14 + Math_fround(silk_energy_FLP($2, $7)))) * 3.32192809488736);
|
|
$5 = $4 ? Math_fround($5 + Math_fround(Math_abs(Math_fround($10 - $9)))) : $5;
|
|
$2 = $2 + $8 | 0;
|
|
$9 = $10;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$21 = Math_fround($16 + $12);
|
|
if (!(Math_fround(Math_fround($6 - 1 | 0) * Math_fround(.6000000238418579)) < $5 ^ 1)) {
|
|
HEAP8[$0 + 4766 | 0] = 0;
|
|
break label$2;
|
|
}
|
|
HEAP8[$0 + 4766 | 0] = 1;
|
|
}
|
|
$2 = HEAP32[$0 + 4580 >> 2];
|
|
label$7 : {
|
|
if (($2 | 0) < 1) {
|
|
$4 = 0;
|
|
break label$7;
|
|
}
|
|
$15 = $3 - ($13 << 2) | 0;
|
|
$5 = Math_fround(HEAPF32[$1 + 704 >> 2] * Math_fround(.0010000000474974513));
|
|
$23 = Math_fround(Math_fround(.9399999976158142) / Math_fround(Math_fround($5 * $5) + Math_fround(1)));
|
|
$10 = Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4672 >> 2]) * Math_fround(152587890625e-16)) + Math_fround(HEAPF32[$1 + 700 >> 2] * Math_fround(.009999999776482582)));
|
|
$22 = Math_fround(Math_fround(1) - Math_fround($10 * $10));
|
|
$16 = Math_fround(-$10);
|
|
while (1) {
|
|
$4 = HEAP32[$0 + 4576 >> 2];
|
|
$6 = Math_imul($4, 3);
|
|
$2 = (HEAP32[$0 + 4604 >> 2] - $6 | 0) / 2 | 0;
|
|
silk_apply_sine_window_FLP($11 + 224 | 0, $15, 1, $2);
|
|
$7 = $2 << 2;
|
|
memcpy($7 + ($11 + 224 | 0) | 0, $7 + $15 | 0, Math_imul($4, 12));
|
|
$4 = $2 + $6 << 2;
|
|
silk_apply_sine_window_FLP($4 + ($11 + 224 | 0) | 0, $4 + $15 | 0, 2, $2);
|
|
$8 = HEAP32[$0 + 4588 >> 2];
|
|
$2 = HEAP32[$0 + 4636 >> 2];
|
|
$4 = HEAP32[$0 + 4604 >> 2];
|
|
label$10 : {
|
|
if (HEAP32[$0 + 4672 >> 2] >= 1) {
|
|
silk_warped_autocorrelation_FLP($11 + 112 | 0, $11 + 224 | 0, $10, $4, $2);
|
|
break label$10;
|
|
}
|
|
silk_autocorrelation_FLP($11 + 112 | 0, $11 + 224 | 0, $4, $2 + 1 | 0);
|
|
}
|
|
$5 = HEAPF32[$11 + 112 >> 2];
|
|
HEAPF32[$11 + 112 >> 2] = $5 + Math_fround(Math_fround($5 * Math_fround(29999999242136255e-21)) + Math_fround(1));
|
|
$5 = silk_schur_FLP($11, $11 + 112 | 0, HEAP32[$0 + 4636 >> 2]);
|
|
$2 = (Math_imul($17, 96) + $1 | 0) + 244 | 0;
|
|
silk_k2a_FLP($2, $11, HEAP32[$0 + 4636 >> 2]);
|
|
$3 = ($17 << 2) + $1 | 0;
|
|
$9 = Math_fround(Math_sqrt($5));
|
|
HEAPF32[$3 >> 2] = $9;
|
|
$7 = HEAP32[$0 + 4636 >> 2];
|
|
if (HEAP32[$0 + 4672 >> 2] >= 1) {
|
|
$5 = Math_fround(HEAPF32[(($7 << 2) + $2 | 0) - 4 >> 2] * $16);
|
|
if (($7 | 0) >= 2) {
|
|
$4 = $7 - 2 | 0;
|
|
while (1) {
|
|
$5 = Math_fround(Math_fround($5 + HEAPF32[($4 << 2) + $2 >> 2]) * $16);
|
|
$6 = ($4 | 0) > 0;
|
|
$4 = $4 - 1 | 0;
|
|
if ($6) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$3 >> 2] = $9 * Math_fround(Math_fround(1) / Math_fround(Math_fround(1) - $5));
|
|
}
|
|
$24 = $8 << 2;
|
|
silk_bwexpander_FLP($2, $7, $23);
|
|
$6 = HEAP32[$0 + 4636 >> 2];
|
|
label$15 : {
|
|
if (HEAP32[$0 + 4672 >> 2] >= 1) {
|
|
$18 = $6 - 1 | 0;
|
|
$20 = ($6 | 0) < 2;
|
|
if (!$20) {
|
|
$5 = HEAPF32[($18 << 2) + $2 >> 2];
|
|
$4 = $18;
|
|
while (1) {
|
|
$7 = $4 - 1 | 0;
|
|
$8 = ($7 << 2) + $2 | 0;
|
|
$5 = Math_fround(HEAPF32[$8 >> 2] - Math_fround($10 * $5));
|
|
HEAPF32[$8 >> 2] = $5;
|
|
$8 = ($4 | 0) > 1;
|
|
$4 = $7;
|
|
if ($8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = ($6 | 0) < 1;
|
|
if ($7) {
|
|
break label$15;
|
|
}
|
|
$5 = HEAPF32[$2 >> 2];
|
|
$12 = Math_fround($22 / Math_fround(Math_fround($10 * $5) + Math_fround(1)));
|
|
HEAPF32[$2 >> 2] = $12 * $5;
|
|
$13 = 1;
|
|
if (($6 | 0) != 1) {
|
|
while (1) {
|
|
$4 = ($13 << 2) + $2 | 0;
|
|
HEAPF32[$4 >> 2] = $12 * HEAPF32[$4 >> 2];
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($7) {
|
|
break label$15;
|
|
}
|
|
$13 = ($6 | 0) == 1;
|
|
}
|
|
$25 = ($18 << 2) + $2 | 0;
|
|
$19 = 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$5 = Math_fround(-1);
|
|
$4 = 0;
|
|
while (1) {
|
|
$9 = Math_fround(Math_abs(HEAPF32[($4 << 2) + $2 >> 2]));
|
|
$8 = $9 > $5;
|
|
$5 = $8 ? $9 : $5;
|
|
$7 = $8 ? $4 : $7;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($5 <= Math_fround(3.999000072479248)) {
|
|
break label$15;
|
|
}
|
|
if (!$20) {
|
|
$9 = HEAPF32[$2 >> 2];
|
|
$4 = 1;
|
|
while (1) {
|
|
$8 = ($4 << 2) + $2 | 0;
|
|
$14 = HEAPF32[$8 >> 2];
|
|
HEAPF32[$8 - 4 >> 2] = $9 + Math_fround($10 * $14);
|
|
$9 = $14;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = Math_fround(Math_fround(1) / $12);
|
|
$4 = 0;
|
|
while (1) {
|
|
$8 = ($4 << 2) + $2 | 0;
|
|
HEAPF32[$8 >> 2] = $9 * HEAPF32[$8 >> 2];
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
silk_bwexpander_FLP($2, $6, Math_fround(Math_fround(.9900000095367432) - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($19 | 0) * Math_fround(.10000000149011612)) + Math_fround(.800000011920929)) * Math_fround($5 + Math_fround(-3.999000072479248))) / Math_fround($5 * Math_fround($7 + 1 | 0)))));
|
|
if (!$20) {
|
|
$5 = HEAPF32[$25 >> 2];
|
|
$4 = $18;
|
|
while (1) {
|
|
$8 = $4 - 1 | 0;
|
|
$3 = ($8 << 2) + $2 | 0;
|
|
$5 = Math_fround(HEAPF32[$3 >> 2] - Math_fround($10 * $5));
|
|
HEAPF32[$3 >> 2] = $5;
|
|
$3 = ($4 | 0) > 1;
|
|
$4 = $8;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = HEAPF32[$2 >> 2];
|
|
$12 = Math_fround($22 / Math_fround(Math_fround($10 * $5) + Math_fround(1)));
|
|
HEAPF32[$2 >> 2] = $12 * $5;
|
|
$4 = 1;
|
|
if (!$13) {
|
|
while (1) {
|
|
$8 = ($4 << 2) + $2 | 0;
|
|
HEAPF32[$8 >> 2] = $12 * HEAPF32[$8 >> 2];
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$19 = $19 + 1 | 0;
|
|
if (($19 | 0) != 10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$15;
|
|
}
|
|
$3 = 0;
|
|
$7 = 0;
|
|
if (($6 | 0) < 1) {
|
|
break label$15;
|
|
}
|
|
while (1) {
|
|
$5 = Math_fround(-1);
|
|
$4 = 0;
|
|
while (1) {
|
|
$9 = Math_fround(Math_abs(HEAPF32[($4 << 2) + $2 >> 2]));
|
|
$8 = $9 > $5;
|
|
$5 = $8 ? $9 : $5;
|
|
$7 = $8 ? $4 : $7;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($5 <= Math_fround(3.999000072479248)) {
|
|
break label$15;
|
|
}
|
|
silk_bwexpander_FLP($2, $6, Math_fround(Math_fround(.9900000095367432) - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($3 | 0) * Math_fround(.10000000149011612)) + Math_fround(.800000011920929)) * Math_fround($5 + Math_fround(-3.999000072479248))) / Math_fround($5 * Math_fround($7 + 1 | 0)))));
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != 10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$15 = $15 + $24 | 0;
|
|
$2 = HEAP32[$0 + 4580 >> 2];
|
|
$17 = $17 + 1 | 0;
|
|
if (($2 | 0) > ($17 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
$26 = exp2(+Math_fround($21 * Math_fround(-.1599999964237213)));
|
|
if (($2 | 0) < 1) {
|
|
break label$7;
|
|
}
|
|
$7 = ($2 | 0) > 0;
|
|
$5 = Math_fround($26);
|
|
while (1) {
|
|
$6 = ($4 << 2) + $1 | 0;
|
|
HEAPF32[$6 >> 2] = Math_fround(HEAPF32[$6 >> 2] * $5) + Math_fround(1.2483305931091309);
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $7;
|
|
}
|
|
$14 = Math_fround(HEAP32[$0 + 4532 >> 2]);
|
|
$9 = Math_fround(Math_fround($14 * Math_fround(.00390625)) * Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4696 >> 2]) * Math_fround(30517578125e-15)) + Math_fround(-1)) * Math_fround(.5)) + Math_fround(1)) * Math_fround(4)));
|
|
$13 = HEAPU8[$0 + 4765 | 0];
|
|
label$33 : {
|
|
label$34 : {
|
|
label$35 : {
|
|
if (($13 | 0) == 2) {
|
|
if ($4) {
|
|
$10 = Math_fround(Math_fround(.20000000298023224) / Math_fround(HEAP32[$0 + 4576 >> 2]));
|
|
$6 = 0;
|
|
while (1) {
|
|
$7 = ($6 << 2) + $1 | 0;
|
|
$5 = Math_fround($10 + Math_fround(Math_fround(3) / Math_fround(HEAP32[$7 + 228 >> 2])));
|
|
HEAPF32[$7 + 628 >> 2] = $5 + Math_fround(-1);
|
|
HEAPF32[$7 + 644 >> 2] = Math_fround(Math_fround(1) - $5) - Math_fround($9 * $5);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = Math_fround(Math_fround(Math_fround($14 * Math_fround(-.26249998807907104)) * Math_fround(.00390625)) + Math_fround(-.25));
|
|
break label$35;
|
|
}
|
|
$5 = Math_fround(Math_fround(1.2999999523162842) / Math_fround(HEAP32[$0 + 4576 >> 2]));
|
|
$10 = Math_fround($5 + Math_fround(-1));
|
|
HEAPF32[$1 + 628 >> 2] = $10;
|
|
HEAPF32[$1 + 644 >> 2] = Math_fround(Math_fround(1) - $5) + Math_fround(Math_fround($9 * $5) * Math_fround(-.6000000238418579));
|
|
if (($2 | 0) <= 1) {
|
|
if (!$4) {
|
|
break label$33;
|
|
}
|
|
$9 = Math_fround(-.25);
|
|
$10 = Math_fround(0);
|
|
break label$34;
|
|
}
|
|
HEAPF32[$1 + 632 >> 2] = $10;
|
|
HEAP32[$1 + 648 >> 2] = HEAP32[$1 + 644 >> 2];
|
|
$6 = 2;
|
|
$9 = Math_fround(-.25);
|
|
if (($2 | 0) == 2) {
|
|
break label$35;
|
|
}
|
|
$8 = $1 + 628 | 0;
|
|
$3 = $1 + 644 | 0;
|
|
while (1) {
|
|
$7 = $6 << 2;
|
|
HEAP32[$8 + $7 >> 2] = HEAP32[$1 + 628 >> 2];
|
|
HEAP32[$3 + $7 >> 2] = HEAP32[$1 + 644 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($13 | 0) == 2) {
|
|
if (!$4) {
|
|
break label$33;
|
|
}
|
|
$10 = Math_fround(Math_fround(Math_sqrt(HEAPF32[$0 + 10060 >> 2])) * Math_fround(Math_fround(Math_fround(Math_fround(1) - Math_fround(Math_fround(Math_fround(1) - HEAPF32[$1 + 700 >> 2]) * HEAPF32[$1 + 696 >> 2])) * Math_fround(.20000000298023224)) + Math_fround(.30000001192092896)));
|
|
break label$34;
|
|
}
|
|
$10 = Math_fround(0);
|
|
if (!$4) {
|
|
break label$33;
|
|
}
|
|
}
|
|
$4 = 0;
|
|
while (1) {
|
|
$5 = HEAPF32[$0 + 7172 >> 2];
|
|
$5 = Math_fround($5 + Math_fround(Math_fround($10 - $5) * Math_fround(.4000000059604645)));
|
|
HEAPF32[$0 + 7172 >> 2] = $5;
|
|
$6 = ($4 << 2) + $1 | 0;
|
|
HEAPF32[$6 + 676 >> 2] = $5;
|
|
$5 = HEAPF32[$0 + 7176 >> 2];
|
|
$5 = Math_fround($5 + Math_fround(Math_fround($9 - $5) * Math_fround(.4000000059604645)));
|
|
HEAPF32[$0 + 7176 >> 2] = $5;
|
|
HEAPF32[$6 + 660 >> 2] = $5;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $11 + 1184 | 0;
|
|
}
|
|
function silk_VAD_GetSA_Q8_c($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
|
|
$4 = __stack_pointer - 48 | 0;
|
|
$10 = $4;
|
|
__stack_pointer = $4;
|
|
$2 = HEAP32[$0 + 4584 >> 2];
|
|
if (($2 | 0) < 321) {
|
|
if (($2 & -8) == ($2 | 0)) {
|
|
HEAP32[$10 >> 2] = 0;
|
|
$3 = $2 >> 3;
|
|
$6 = $2 >> 2;
|
|
$7 = $3 + $6 | 0;
|
|
HEAP32[$10 + 4 >> 2] = $7;
|
|
$8 = $3 + $7 | 0;
|
|
HEAP32[$10 + 8 >> 2] = $8;
|
|
$9 = $6 + $8 | 0;
|
|
HEAP32[$10 + 12 >> 2] = $9;
|
|
$13 = $2 >> 1;
|
|
$5 = $4 - (($13 + $9 << 1) + 15 & -16) | 0;
|
|
__stack_pointer = $5;
|
|
silk_ana_filt_bank_1($1, $0 + 36 | 0, $5, ($9 << 1) + $5 | 0, HEAP32[$0 + 4584 >> 2]);
|
|
silk_ana_filt_bank_1($5, $0 + 44 | 0, $5, ($8 << 1) + $5 | 0, $13);
|
|
silk_ana_filt_bank_1($5, $0 + 52 | 0, $5, ($7 << 1) + $5 | 0, $6);
|
|
$4 = $3 - 1 | 0;
|
|
$3 = ($4 << 1) + $5 | 0;
|
|
$8 = HEAP16[$3 >> 1] >> 1;
|
|
HEAP16[$3 >> 1] = $8;
|
|
if (($2 | 0) >= 16) {
|
|
$3 = $8;
|
|
while (1) {
|
|
$6 = $4 - 1 | 0;
|
|
$2 = ($6 << 1) + $5 | 0;
|
|
$1 = $2;
|
|
$2 = HEAP16[$2 >> 1] >> 1;
|
|
HEAP16[$1 >> 1] = $2;
|
|
HEAP16[($4 << 1) + $5 >> 1] = $3 - $2;
|
|
$7 = ($4 | 0) > 1;
|
|
$3 = $2;
|
|
$4 = $6;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $0 + 92 | 0;
|
|
HEAP16[$5 >> 1] = HEAPU16[$5 >> 1] - HEAPU16[$4 >> 1];
|
|
HEAP16[$0 + 92 >> 1] = $8;
|
|
while (1) {
|
|
$2 = HEAP32[$0 + 4584 >> 2];
|
|
$4 = $11 << 2;
|
|
$13 = $4 + ($10 + 32 | 0) | 0;
|
|
$16 = $0 + $4 | 0;
|
|
$9 = $16 + 60 | 0;
|
|
$9 = HEAP32[$9 >> 2];
|
|
HEAP32[$13 >> 2] = $9;
|
|
$3 = 4 - $11 | 0;
|
|
$12 = $2 >> ($3 >>> 0 < 3 ? $3 : 3);
|
|
$15 = ($12 | 0) > 3;
|
|
label$6 : {
|
|
if (!$15) {
|
|
$1 = ($9 | 0) > -1 ? $9 : 2147483647;
|
|
$4 = 0;
|
|
break label$6;
|
|
}
|
|
$8 = $12 >> 2;
|
|
$6 = ($8 | 0) > 1 ? $8 : 1;
|
|
$14 = $4 + $10 | 0;
|
|
$7 = HEAP32[$14 >> 2];
|
|
$4 = 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$3 = HEAP16[($4 + $7 << 1) + $5 >> 1] >> 3;
|
|
$2 = Math_imul($3, $3) + $2 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $2 + $9 | 0;
|
|
$1 = ($4 | 0) > -1 ? $4 : 2147483647;
|
|
$4 = 0;
|
|
if (!$15) {
|
|
break label$6;
|
|
}
|
|
$7 = HEAP32[$14 >> 2];
|
|
$2 = 0;
|
|
while (1) {
|
|
$3 = HEAP16[(($4 + $8 | 0) + $7 << 1) + $5 >> 1] >> 3;
|
|
$2 = Math_imul($3, $3) + $2 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $1 + $2 | 0;
|
|
$1 = ($4 | 0) > -1 ? $4 : 2147483647;
|
|
$4 = 0;
|
|
$12 = ($12 | 0) < 4;
|
|
if ($12) {
|
|
break label$6;
|
|
}
|
|
$7 = $8 << 1;
|
|
$9 = HEAP32[$14 >> 2];
|
|
$2 = 0;
|
|
while (1) {
|
|
$3 = HEAP16[(($4 + $7 | 0) + $9 << 1) + $5 >> 1] >> 3;
|
|
$2 = Math_imul($3, $3) + $2 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $1 + $2 | 0;
|
|
$1 = ($4 | 0) > -1 ? $4 : 2147483647;
|
|
$4 = 0;
|
|
if ($12) {
|
|
break label$6;
|
|
}
|
|
$7 = Math_imul($8, 3);
|
|
$8 = HEAP32[$14 >> 2];
|
|
$2 = 0;
|
|
while (1) {
|
|
$3 = HEAP16[(($2 + $7 | 0) + $8 << 1) + $5 >> 1] >> 3;
|
|
$4 = Math_imul($3, $3) + $4 | 0;
|
|
$2 = $2 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$2 = ($4 >>> 1 | 0) + $1 | 0;
|
|
HEAP32[$13 >> 2] = ($2 | 0) > -1 ? $2 : 2147483647;
|
|
HEAP32[$16 + 60 >> 2] = $4;
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) != 4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
$2 = HEAP32[$0 + 144 >> 2];
|
|
if (($2 | 0) <= 999) {
|
|
HEAP32[$0 + 144 >> 2] = $2 + 1;
|
|
$4 = 32767 / (($2 >> 4) + 1 | 0) | 0;
|
|
}
|
|
$2 = 128;
|
|
$12 = HEAP32[$10 + 32 >> 2];
|
|
$3 = $12 + HEAP32[$0 + 128 >> 2] | 0;
|
|
$6 = ($3 | 0) > -1 ? $3 : 2147483647;
|
|
$5 = 2147483647 / ($6 | 0) | 0;
|
|
$3 = 128;
|
|
$7 = HEAP32[$0 + 96 >> 2];
|
|
label$13 : {
|
|
if ($7 << 3 < ($6 | 0)) {
|
|
break label$13;
|
|
}
|
|
$3 = 1024;
|
|
if (($6 | 0) < ($7 | 0)) {
|
|
break label$13;
|
|
}
|
|
$3 = $7 << 16 >> 16;
|
|
$3 = (Math_imul($3, $5 >> 16) + Math_imul(($7 >> 15) + 1 >> 1, $5) | 0) + (Math_imul($5 & 65535, $3) >> 16) | 0;
|
|
$3 = $3 >> 16 << 11 | $3 >>> 5 & 2047;
|
|
}
|
|
$6 = $0 + 112 | 0;
|
|
$1 = $6;
|
|
$6 = HEAP32[$0 + 112 >> 2];
|
|
$5 = $5 - $6 | 0;
|
|
$3 = (($3 | 0) > ($4 | 0) ? $3 : $4) << 16 >> 16;
|
|
$3 = (Math_imul($3, $5 >> 16) + $6 | 0) + (Math_imul($5 & 65535, $3) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $3;
|
|
$3 = 2147483647 / ($3 | 0) | 0;
|
|
$5 = ($3 | 0) < 16777215 ? $3 : 16777215;
|
|
HEAP32[$0 + 96 >> 2] = $5;
|
|
$15 = HEAP32[$10 + 36 >> 2];
|
|
$3 = $15 + HEAP32[$0 + 132 >> 2] | 0;
|
|
$6 = ($3 | 0) > -1 ? $3 : 2147483647;
|
|
$3 = 2147483647 / ($6 | 0) | 0;
|
|
$7 = HEAP32[$0 + 100 >> 2];
|
|
label$14 : {
|
|
if ($7 << 3 < ($6 | 0)) {
|
|
break label$14;
|
|
}
|
|
$2 = 1024;
|
|
if (($6 | 0) < ($7 | 0)) {
|
|
break label$14;
|
|
}
|
|
$2 = $7 << 16 >> 16;
|
|
$2 = (Math_imul($2, $3 >> 16) + Math_imul(($7 >> 15) + 1 >> 1, $3) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$2 = $2 >> 16 << 11 | $2 >>> 5 & 2047;
|
|
}
|
|
$6 = $0 + 116 | 0;
|
|
$1 = $6;
|
|
$6 = HEAP32[$0 + 116 >> 2];
|
|
$3 = $3 - $6 | 0;
|
|
$2 = (($2 | 0) > ($4 | 0) ? $2 : $4) << 16 >> 16;
|
|
$2 = (Math_imul($2, $3 >> 16) + $6 | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $2;
|
|
$2 = 2147483647 / ($2 | 0) | 0;
|
|
HEAP32[$0 + 100 >> 2] = ($2 | 0) < 16777215 ? $2 : 16777215;
|
|
$14 = HEAP32[$10 + 40 >> 2];
|
|
$2 = $14 + HEAP32[$0 + 136 >> 2] | 0;
|
|
$7 = ($2 | 0) > -1 ? $2 : 2147483647;
|
|
$6 = 2147483647 / ($7 | 0) | 0;
|
|
$2 = 128;
|
|
$3 = 128;
|
|
$8 = HEAP32[$0 + 104 >> 2];
|
|
label$15 : {
|
|
if ($8 << 3 < ($7 | 0)) {
|
|
break label$15;
|
|
}
|
|
$3 = 1024;
|
|
if (($7 | 0) < ($8 | 0)) {
|
|
break label$15;
|
|
}
|
|
$3 = $8 << 16 >> 16;
|
|
$3 = (Math_imul($3, $6 >> 16) + Math_imul(($8 >> 15) + 1 >> 1, $6) | 0) + (Math_imul($6 & 65535, $3) >> 16) | 0;
|
|
$3 = $3 >> 16 << 11 | $3 >>> 5 & 2047;
|
|
}
|
|
$7 = $0 + 120 | 0;
|
|
$1 = $7;
|
|
$7 = HEAP32[$0 + 120 >> 2];
|
|
$6 = $6 - $7 | 0;
|
|
$3 = (($3 | 0) > ($4 | 0) ? $3 : $4) << 16 >> 16;
|
|
$3 = (Math_imul($3, $6 >> 16) + $7 | 0) + (Math_imul($6 & 65535, $3) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $3;
|
|
$3 = 2147483647 / ($3 | 0) | 0;
|
|
HEAP32[$0 + 104 >> 2] = ($3 | 0) < 16777215 ? $3 : 16777215;
|
|
$17 = HEAP32[$10 + 44 >> 2];
|
|
$3 = $17 + HEAP32[$0 + 140 >> 2] | 0;
|
|
$6 = ($3 | 0) > -1 ? $3 : 2147483647;
|
|
$3 = 2147483647 / ($6 | 0) | 0;
|
|
$7 = HEAP32[$0 + 108 >> 2];
|
|
label$16 : {
|
|
if ($7 << 3 < ($6 | 0)) {
|
|
break label$16;
|
|
}
|
|
$2 = 1024;
|
|
if (($6 | 0) < ($7 | 0)) {
|
|
break label$16;
|
|
}
|
|
$2 = $7 << 16 >> 16;
|
|
$2 = (Math_imul($2, $3 >> 16) + Math_imul(($7 >> 15) + 1 >> 1, $3) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$2 = $2 >> 16 << 11 | $2 >>> 5 & 2047;
|
|
}
|
|
$4 = (($2 | 0) > ($4 | 0) ? $2 : $4) << 16 >> 16;
|
|
$2 = HEAP32[$0 + 124 >> 2];
|
|
$3 = $3 - $2 | 0;
|
|
$6 = $0 + 124 | 0;
|
|
$4 = (Math_imul($3 >> 16, $4) + $2 | 0) + (Math_imul($3 & 65535, $4) >> 16) | 0;
|
|
HEAP32[$6 >> 2] = $4;
|
|
$4 = 2147483647 / ($4 | 0) | 0;
|
|
HEAP32[$0 + 108 >> 2] = ($4 | 0) < 16777215 ? $4 : 16777215;
|
|
$3 = $12;
|
|
$7 = 0;
|
|
$6 = 0;
|
|
$4 = 0;
|
|
while (1) {
|
|
$2 = $3 - $5 | 0;
|
|
label$18 : {
|
|
if (($2 | 0) >= 1) {
|
|
$8 = $4 << 2;
|
|
$9 = $3 >>> 0 < 8388608;
|
|
$3 = (($9 ? $3 << 8 : $3) | 0) / (($9 ? $5 : $5 >> 8) + 1 | 0) | 0;
|
|
HEAP32[$8 + ($10 + 16 | 0) >> 2] = $3;
|
|
$3 = (silk_lin2log($3) << 16) - 67108864 >> 16;
|
|
$9 = Math_imul($3, $3);
|
|
$6 = $9 + $6 | 0;
|
|
if (($2 | 0) <= 1048575) {
|
|
$5 = Math_clz32($2);
|
|
$1 = 24 - $5 | 0;
|
|
$9 = 0 - $1 | 0;
|
|
$11 = $2;
|
|
label$21 : {
|
|
if (!$1) {
|
|
break label$21;
|
|
}
|
|
$11 = $2 << $9 | $2 >>> 56 - $5;
|
|
if ($2 >>> 0 <= 127) {
|
|
break label$21;
|
|
}
|
|
$11 = $2 << $5 + 8 | $2 >>> $1;
|
|
}
|
|
$16 = Math_imul($11 & 127, 13959168) >>> 16 | 0;
|
|
$11 = ($5 & 1 ? 32768 : 46214) >>> ($5 >>> 1) | 0;
|
|
$13 = Math_imul($11 + (Math_imul($11, $16) >>> 16 | 0) >>> 10 | 0, $3);
|
|
label$22 : {
|
|
if (!$1) {
|
|
break label$22;
|
|
}
|
|
if ($2 >>> 0 <= 127) {
|
|
$2 = $2 << $9 | $2 >>> 56 - $5;
|
|
break label$22;
|
|
}
|
|
$2 = $2 << $5 + 8 | $2 >>> $1;
|
|
}
|
|
$3 = Math_imul((Math_imul(Math_imul($2 & 127, 13959168) >>> 16 | 0, $11) >>> 16 | 0) + $11 << 6 & 65472, $3) + ($13 << 16) >> 16;
|
|
}
|
|
$2 = HEAP32[$8 + 1936 >> 2];
|
|
$7 = (Math_imul($2 >> 16, $3) + $7 | 0) + (Math_imul($2 & 65535, $3) >> 16) | 0;
|
|
break label$18;
|
|
}
|
|
HEAP32[($10 + 16 | 0) + ($4 << 2) >> 2] = 256;
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != 4) {
|
|
$2 = $4 << 2;
|
|
$3 = HEAP32[$2 + ($10 + 32 | 0) >> 2];
|
|
$5 = HEAP32[($0 + $2 | 0) + 96 >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = ($6 | 0) / 4 | 0;
|
|
$2 = -128;
|
|
if (($6 | 0) >= 4) {
|
|
$2 = Math_clz32($4);
|
|
$3 = 24 - $2 | 0;
|
|
label$27 : {
|
|
if (!$3) {
|
|
break label$27;
|
|
}
|
|
if ($4 >>> 0 <= 127) {
|
|
$4 = $4 << 0 - $3 | $4 >>> 56 - $2;
|
|
break label$27;
|
|
}
|
|
$4 = $4 << $2 + 8 | $4 >>> $3;
|
|
}
|
|
$1 = Math_imul($4 & 127, 13959168) >>> 16 | 0;
|
|
$4 = ($2 & 1 ? 32768 : 46214) >>> ($2 >>> 1) | 0;
|
|
$2 = (Math_imul(Math_imul($4 + (Math_imul($4, $1) >>> 16 | 0) | 0, 196608) >> 16, 45e3) >> 16) - 128 | 0;
|
|
}
|
|
$4 = silk_sigm_Q15($2);
|
|
HEAP32[$0 + 4712 >> 2] = (silk_sigm_Q15($7) << 1) - 32768;
|
|
$2 = HEAP32[$0 + 4584 >> 2];
|
|
$3 = HEAP32[$0 + 4576 >> 2];
|
|
$5 = ((($15 - HEAP32[$0 + 100 >> 2] >> 4 << 1) + ($12 - HEAP32[$0 + 96 >> 2] >> 4) | 0) + Math_imul($14 - HEAP32[$0 + 104 >> 2] >> 4, 3) | 0) + ($17 - HEAP32[$0 + 108 >> 2] >> 4 << 2) >> (($2 | 0) == (Math_imul($3, 20) | 0));
|
|
label$29 : {
|
|
if (($5 | 0) <= 0) {
|
|
$4 = $4 >> 1;
|
|
break label$29;
|
|
}
|
|
if (($5 | 0) > 16383) {
|
|
break label$29;
|
|
}
|
|
$4 = $4 << 16 >> 16;
|
|
$6 = $5 << 16;
|
|
$5 = Math_clz32($6);
|
|
$7 = ($5 & 1 ? 32768 : 46214) >>> ($5 >>> 1) | 0;
|
|
$5 = ($7 + (Math_imul((wasm2js_i32$0 = 0, wasm2js_i32$1 = Math_imul(__wasm_rotl_i32($6, $5 + 8 | 0) & 127, 13959168) >>> 16 | 0, wasm2js_i32$2 = ($5 | 0) == 24, wasm2js_i32$2 ? wasm2js_i32$0 : wasm2js_i32$1), $7) >>> 16 | 0) | 0) + 32768 | 0;
|
|
$4 = (Math_imul($4, $5 & 65535) >> 16) + Math_imul($5 >>> 16 | 0, $4) | 0;
|
|
}
|
|
$5 = $4 >> 7;
|
|
HEAP32[$0 + 4532 >> 2] = ($5 | 0) < 255 ? $5 : 255;
|
|
$5 = $0 + 76 | 0;
|
|
$1 = $5;
|
|
$5 = HEAP32[$0 + 76 >> 2];
|
|
$6 = HEAP32[$10 + 16 >> 2] - $5 | 0;
|
|
$4 = Math_imul($4 << 16 >> 16, $4) >> ((Math_imul($3, 10) | 0) == ($2 | 0) ? 21 : 20);
|
|
$2 = (Math_imul($4, $6 >> 16) + $5 | 0) + (Math_imul($6 & 65535, $4) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $2;
|
|
HEAP32[$0 + 4696 >> 2] = silk_sigm_Q15(Math_imul(silk_lin2log($2), 3) - 5120 >> 4);
|
|
$2 = $0 + 80 | 0;
|
|
$1 = $2;
|
|
$2 = HEAP32[$0 + 80 >> 2];
|
|
$3 = HEAP32[$10 + 20 >> 2] - $2 | 0;
|
|
$2 = (Math_imul($3 >> 16, $4) + $2 | 0) + (Math_imul($3 & 65535, $4) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $2;
|
|
HEAP32[$0 + 4700 >> 2] = silk_sigm_Q15(Math_imul(silk_lin2log($2), 3) - 5120 >> 4);
|
|
$2 = $0 + 84 | 0;
|
|
$1 = $2;
|
|
$2 = HEAP32[$0 + 84 >> 2];
|
|
$3 = HEAP32[$10 + 24 >> 2] - $2 | 0;
|
|
$2 = (Math_imul($3 >> 16, $4) + $2 | 0) + (Math_imul($3 & 65535, $4) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $2;
|
|
HEAP32[$0 + 4704 >> 2] = silk_sigm_Q15(Math_imul(silk_lin2log($2), 3) - 5120 >> 4);
|
|
$2 = $0 + 88 | 0;
|
|
$1 = $2;
|
|
$2 = HEAP32[$0 + 88 >> 2];
|
|
$3 = HEAP32[$10 + 28 >> 2] - $2 | 0;
|
|
$4 = (Math_imul($3 >> 16, $4) + $2 | 0) + (Math_imul($3 & 65535, $4) >> 16) | 0;
|
|
HEAP32[$1 >> 2] = $4;
|
|
HEAP32[$0 + 4708 >> 2] = silk_sigm_Q15(Math_imul(silk_lin2log($4), 3) - 5120 >> 4);
|
|
__stack_pointer = $10 + 48 | 0;
|
|
return 0;
|
|
}
|
|
celt_fatal(1846, 1835, 106);
|
|
abort();
|
|
}
|
|
celt_fatal(1776, 1835, 104);
|
|
abort();
|
|
}
|
|
function opus_custom_encoder_ctl($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
|
|
$3 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $3;
|
|
HEAP32[$3 + 12 >> 2] = $2;
|
|
$2 = -5;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
label$10 : {
|
|
label$11 : {
|
|
label$12 : {
|
|
label$13 : {
|
|
label$14 : {
|
|
label$15 : {
|
|
label$16 : {
|
|
label$17 : {
|
|
label$18 : {
|
|
label$19 : {
|
|
label$20 : {
|
|
label$21 : {
|
|
label$22 : {
|
|
label$23 : {
|
|
switch ($1 - 4002 | 0) {
|
|
default:
|
|
switch ($1 - 10002 | 0) {
|
|
case 6:
|
|
break label$15;
|
|
case 0:
|
|
break label$20;
|
|
case 10:
|
|
break label$21;
|
|
case 8:
|
|
break label$22;
|
|
case 24:
|
|
break label$3;
|
|
case 22:
|
|
break label$4;
|
|
case 13:
|
|
break label$6;
|
|
case 26:
|
|
break label$7;
|
|
case 20:
|
|
break label$8;
|
|
case 14:
|
|
break label$9;
|
|
default:
|
|
break label$1;
|
|
}
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
case 17:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 27:
|
|
case 28:
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
break label$1;
|
|
case 26:
|
|
break label$10;
|
|
case 45:
|
|
break label$11;
|
|
case 44:
|
|
break label$12;
|
|
case 35:
|
|
break label$13;
|
|
case 34:
|
|
break label$14;
|
|
case 0:
|
|
break label$16;
|
|
case 4:
|
|
break label$17;
|
|
case 18:
|
|
break label$18;
|
|
case 12:
|
|
break label$19;
|
|
case 8:
|
|
break label$23;
|
|
case 29:
|
|
break label$5;
|
|
}
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 10) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 24 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if (($1 | 0) < 0 | HEAP32[HEAP32[$0 >> 2] + 8 >> 2] <= ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 32 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if (($1 | 0) < 1 | HEAP32[HEAP32[$0 >> 2] + 8 >> 2] < ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 2) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 12 >> 2] = !$1;
|
|
HEAP32[$0 + 20 >> 2] = ($1 | 0) != 2;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 100) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 56 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
HEAP32[$0 + 52 >> 2] = HEAP32[$2 >> 2];
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$2 >> 2];
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
$1 = HEAP32[$2 >> 2];
|
|
if (($1 | 0) <= 500) {
|
|
$2 = -1;
|
|
if (($1 | 0) != -1) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$2 = Math_imul(HEAP32[$0 + 4 >> 2], 26e4);
|
|
HEAP32[$0 + 40 >> 2] = ($1 | 0) < ($2 | 0) ? $1 : $2;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 - 1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 - 8 >>> 0 > 16) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 60 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
HEAP32[HEAP32[$2 >> 2] >> 2] = HEAP32[$0 + 60 >> 2];
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = -1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if ($1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 68 >> 2] = $1;
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 68 >> 2];
|
|
break label$2;
|
|
}
|
|
$2 = 0;
|
|
$1 = HEAP32[$0 + 4 >> 2];
|
|
$5 = HEAP32[$0 >> 2];
|
|
$4 = HEAP32[$5 + 4 >> 2];
|
|
$6 = HEAP32[$5 + 8 >> 2];
|
|
memset($0 + 76 | 0, 0, Math_imul($1, (($4 << 2) + ($6 << 4) | 0) + 4096 | 0) + 168 | 0);
|
|
$5 = Math_imul(HEAP32[$5 + 8 >> 2], $1);
|
|
if (($5 | 0) >= 1) {
|
|
$4 = (Math_imul($4 + 1024 | 0, $1) << 2) + $0 | 0;
|
|
$1 = Math_imul($1, $6) << 2;
|
|
$4 = ($4 + $1 | 0) + 244 | 0;
|
|
$6 = $1 + $4 | 0;
|
|
while (1) {
|
|
$1 = $2 << 2;
|
|
HEAP32[$6 + $1 >> 2] = -1042284544;
|
|
HEAP32[$1 + $4 >> 2] = -1042284544;
|
|
$2 = $2 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$2 = 0;
|
|
HEAP32[$0 + 216 >> 2] = 0;
|
|
HEAP32[$0 + 96 >> 2] = 0;
|
|
HEAP32[$0 + 100 >> 2] = 0;
|
|
HEAP32[$0 + 88 >> 2] = 256;
|
|
HEAP32[$0 + 80 >> 2] = 2;
|
|
HEAP32[$0 + 84 >> 2] = 1065353216;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
HEAP32[$0 + 48 >> 2] = HEAP32[$2 >> 2];
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = 0;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if (!$1) {
|
|
break label$1;
|
|
}
|
|
$5 = HEAP32[$1 + 4 >> 2];
|
|
$4 = HEAP32[$1 >> 2];
|
|
HEAP32[$0 + 120 >> 2] = $4;
|
|
HEAP32[$0 + 124 >> 2] = $5;
|
|
$4 = HEAP32[$1 + 60 >> 2];
|
|
$5 = HEAP32[$1 + 56 >> 2];
|
|
HEAP32[$0 + 176 >> 2] = $5;
|
|
HEAP32[$0 + 180 >> 2] = $4;
|
|
$5 = HEAP32[$1 + 52 >> 2];
|
|
$4 = HEAP32[$1 + 48 >> 2];
|
|
HEAP32[$0 + 168 >> 2] = $4;
|
|
HEAP32[$0 + 172 >> 2] = $5;
|
|
$4 = HEAP32[$1 + 44 >> 2];
|
|
$5 = HEAP32[$1 + 40 >> 2];
|
|
HEAP32[$0 + 160 >> 2] = $5;
|
|
HEAP32[$0 + 164 >> 2] = $4;
|
|
$5 = HEAP32[$1 + 36 >> 2];
|
|
$4 = HEAP32[$1 + 32 >> 2];
|
|
HEAP32[$0 + 152 >> 2] = $4;
|
|
HEAP32[$0 + 156 >> 2] = $5;
|
|
$4 = HEAP32[$1 + 28 >> 2];
|
|
$5 = HEAP32[$1 + 24 >> 2];
|
|
HEAP32[$0 + 144 >> 2] = $5;
|
|
HEAP32[$0 + 148 >> 2] = $4;
|
|
$5 = HEAP32[$1 + 20 >> 2];
|
|
$4 = HEAP32[$1 + 16 >> 2];
|
|
HEAP32[$0 + 136 >> 2] = $4;
|
|
HEAP32[$0 + 140 >> 2] = $5;
|
|
$4 = HEAP32[$1 + 12 >> 2];
|
|
$5 = HEAP32[$1 + 8 >> 2];
|
|
HEAP32[$0 + 128 >> 2] = $5;
|
|
HEAP32[$0 + 132 >> 2] = $4;
|
|
break label$1;
|
|
}
|
|
$1 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $1 + 4;
|
|
$2 = 0;
|
|
$1 = HEAP32[$1 >> 2];
|
|
if (!$1) {
|
|
break label$1;
|
|
}
|
|
$5 = HEAP32[$1 + 4 >> 2];
|
|
$4 = HEAP32[$1 >> 2];
|
|
HEAP32[$0 + 184 >> 2] = $4;
|
|
HEAP32[$0 + 188 >> 2] = $5;
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 >> 2];
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
$2 = HEAP32[$2 >> 2];
|
|
if (!$2) {
|
|
$2 = -1;
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = HEAP32[$0 + 76 >> 2];
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
HEAP32[$0 + 64 >> 2] = HEAP32[$2 >> 2];
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $2 + 4;
|
|
HEAP32[$0 + 236 >> 2] = HEAP32[$2 >> 2];
|
|
}
|
|
$2 = 0;
|
|
}
|
|
__stack_pointer = $3 + 16 | 0;
|
|
return $2;
|
|
}
|
|
function silk_resampler_private_down_FIR($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0;
|
|
$10 = __stack_pointer;
|
|
$20 = $10;
|
|
$6 = HEAP32[$0 + 268 >> 2];
|
|
$8 = HEAP32[$0 + 276 >> 2];
|
|
$10 = $10 - (($6 + $8 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $10;
|
|
$17 = $0 + 24 | 0;
|
|
$12 = memcpy($10, $17, $8 << 2);
|
|
$10 = HEAP32[$0 + 296 >> 2];
|
|
$18 = $10 + 4 | 0;
|
|
$15 = HEAP32[$0 + 272 >> 2];
|
|
$5 = $10;
|
|
while (1) {
|
|
$13 = ($3 | 0) < ($6 | 0) ? $3 : $6;
|
|
silk_resampler_private_AR2($0, ($8 << 2) + $12 | 0, $2, $5, $13);
|
|
$14 = $13 << 16;
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
$16 = HEAP32[$0 + 276 >> 2];
|
|
switch ($16 - 18 | 0) {
|
|
case 18:
|
|
break label$3;
|
|
case 6:
|
|
break label$5;
|
|
case 0:
|
|
break label$6;
|
|
default:
|
|
break label$4;
|
|
}
|
|
}
|
|
if (($14 | 0) < 1) {
|
|
break label$2;
|
|
}
|
|
$19 = HEAP32[$0 + 280 >> 2];
|
|
$21 = $19 << 16 >> 16;
|
|
$5 = 0;
|
|
while (1) {
|
|
$7 = Math_imul($5 & 65535, $21) >> 16;
|
|
$8 = Math_imul($7, 18) + $18 | 0;
|
|
$9 = HEAP16[$8 >> 1];
|
|
$6 = ($5 >> 16 << 2) + $12 | 0;
|
|
$4 = HEAP32[$6 >> 2];
|
|
$11 = (Math_imul($9, $4 & 65535) >> 16) + Math_imul($4 >> 16, $9) | 0;
|
|
$9 = HEAP16[$8 + 2 >> 1];
|
|
$4 = HEAP32[$6 + 4 >> 2];
|
|
$11 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$9 = HEAP16[$8 + 4 >> 1];
|
|
$4 = HEAP32[$6 + 8 >> 2];
|
|
$11 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$9 = HEAP16[$8 + 6 >> 1];
|
|
$4 = HEAP32[$6 + 12 >> 2];
|
|
$11 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$9 = HEAP16[$8 + 8 >> 1];
|
|
$4 = HEAP32[$6 + 16 >> 2];
|
|
$11 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$9 = HEAP16[$8 + 10 >> 1];
|
|
$4 = HEAP32[$6 + 20 >> 2];
|
|
$11 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$9 = HEAP16[$8 + 12 >> 1];
|
|
$4 = HEAP32[$6 + 24 >> 2];
|
|
$11 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$9 = HEAP16[$8 + 14 >> 1];
|
|
$4 = HEAP32[$6 + 28 >> 2];
|
|
$9 = ($11 + Math_imul($9, $4 >> 16) | 0) + (Math_imul($4 & 65535, $9) >> 16) | 0;
|
|
$8 = HEAP16[$8 + 16 >> 1];
|
|
$4 = HEAP32[$6 + 32 >> 2];
|
|
$9 = ($9 + Math_imul($8, $4 >> 16) | 0) + (Math_imul($4 & 65535, $8) >> 16) | 0;
|
|
$8 = Math_imul(($7 ^ -1) + $19 | 0, 18) + $18 | 0;
|
|
$7 = HEAP16[$8 >> 1];
|
|
$4 = HEAP32[$6 + 68 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 2 >> 1];
|
|
$4 = HEAP32[$6 + 64 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 4 >> 1];
|
|
$4 = HEAP32[$6 + 60 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 6 >> 1];
|
|
$4 = HEAP32[$6 + 56 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 8 >> 1];
|
|
$4 = HEAP32[$6 + 52 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 10 >> 1];
|
|
$4 = HEAP32[$6 + 48 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 12 >> 1];
|
|
$4 = HEAP32[$6 + 44 >> 2];
|
|
$9 = ($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0;
|
|
$7 = HEAP16[$8 + 14 >> 1];
|
|
$4 = HEAP32[$6 + 40 >> 2];
|
|
$8 = HEAP16[$8 + 16 >> 1];
|
|
$6 = HEAP32[$6 + 36 >> 2];
|
|
$6 = ((($9 + Math_imul($7, $4 >> 16) | 0) + (Math_imul($4 & 65535, $7) >> 16) | 0) + Math_imul($8, $6 >> 16) | 0) + (Math_imul($6 & 65535, $8) >> 16) | 0;
|
|
$8 = ($6 >> 5) + 1 >> 1;
|
|
HEAP16[$1 >> 1] = ($6 | 0) > 2097119 ? 32767 : ($8 | 0) > -32768 ? $8 : -32768;
|
|
$1 = $1 + 2 | 0;
|
|
$5 = $5 + $15 | 0;
|
|
if (($14 | 0) > ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$2;
|
|
}
|
|
$8 = 0;
|
|
if (($14 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
while (1) {
|
|
$4 = HEAP16[$10 + 4 >> 1];
|
|
$6 = ($8 >> 16 << 2) + $12 | 0;
|
|
$5 = HEAP32[$6 + 92 >> 2] + HEAP32[$6 >> 2] | 0;
|
|
$7 = (Math_imul($4, $5 & 65535) >> 16) + Math_imul($5 >> 16, $4) | 0;
|
|
$4 = HEAP16[$10 + 6 >> 1];
|
|
$5 = HEAP32[$6 + 88 >> 2] + HEAP32[$6 + 4 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 8 >> 1];
|
|
$5 = HEAP32[$6 + 84 >> 2] + HEAP32[$6 + 8 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 10 >> 1];
|
|
$5 = HEAP32[$6 + 80 >> 2] + HEAP32[$6 + 12 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 12 >> 1];
|
|
$5 = HEAP32[$6 + 76 >> 2] + HEAP32[$6 + 16 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 14 >> 1];
|
|
$5 = HEAP32[$6 + 72 >> 2] + HEAP32[$6 + 20 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 16 >> 1];
|
|
$5 = HEAP32[$6 + 68 >> 2] + HEAP32[$6 + 24 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 18 >> 1];
|
|
$5 = HEAP32[$6 + 64 >> 2] + HEAP32[$6 + 28 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 20 >> 1];
|
|
$5 = HEAP32[$6 + 60 >> 2] + HEAP32[$6 + 32 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 22 >> 1];
|
|
$5 = HEAP32[$6 + 56 >> 2] + HEAP32[$6 + 36 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 24 >> 1];
|
|
$5 = HEAP32[$6 + 52 >> 2] + HEAP32[$6 + 40 >> 2] | 0;
|
|
$4 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$5 = HEAP16[$10 + 26 >> 1];
|
|
$6 = HEAP32[$6 + 48 >> 2] + HEAP32[$6 + 44 >> 2] | 0;
|
|
$6 = ($4 + Math_imul($5, $6 >> 16) | 0) + (Math_imul($6 & 65535, $5) >> 16) | 0;
|
|
$5 = ($6 >> 5) + 1 >> 1;
|
|
HEAP16[$1 >> 1] = ($6 | 0) > 2097119 ? 32767 : ($5 | 0) > -32768 ? $5 : -32768;
|
|
$1 = $1 + 2 | 0;
|
|
$8 = $8 + $15 | 0;
|
|
if (($14 | 0) > ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$2;
|
|
}
|
|
celt_fatal(6400, 6420, 139);
|
|
abort();
|
|
}
|
|
$8 = 0;
|
|
if (($14 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
while (1) {
|
|
$4 = HEAP16[$10 + 4 >> 1];
|
|
$6 = ($8 >> 16 << 2) + $12 | 0;
|
|
$5 = HEAP32[$6 + 140 >> 2] + HEAP32[$6 >> 2] | 0;
|
|
$7 = (Math_imul($4, $5 & 65535) >> 16) + Math_imul($5 >> 16, $4) | 0;
|
|
$4 = HEAP16[$10 + 6 >> 1];
|
|
$5 = HEAP32[$6 + 136 >> 2] + HEAP32[$6 + 4 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 8 >> 1];
|
|
$5 = HEAP32[$6 + 132 >> 2] + HEAP32[$6 + 8 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 10 >> 1];
|
|
$5 = HEAP32[$6 + 128 >> 2] + HEAP32[$6 + 12 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 12 >> 1];
|
|
$5 = HEAP32[$6 + 124 >> 2] + HEAP32[$6 + 16 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 14 >> 1];
|
|
$5 = HEAP32[$6 + 120 >> 2] + HEAP32[$6 + 20 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 16 >> 1];
|
|
$5 = HEAP32[$6 + 116 >> 2] + HEAP32[$6 + 24 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 18 >> 1];
|
|
$5 = HEAP32[$6 + 112 >> 2] + HEAP32[$6 + 28 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 20 >> 1];
|
|
$5 = HEAP32[$6 + 108 >> 2] + HEAP32[$6 + 32 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 22 >> 1];
|
|
$5 = HEAP32[$6 + 104 >> 2] + HEAP32[$6 + 36 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 24 >> 1];
|
|
$5 = HEAP32[$6 + 100 >> 2] + HEAP32[$6 + 40 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 26 >> 1];
|
|
$5 = HEAP32[$6 + 96 >> 2] + HEAP32[$6 + 44 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 28 >> 1];
|
|
$5 = HEAP32[$6 + 92 >> 2] + HEAP32[$6 + 48 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 30 >> 1];
|
|
$5 = HEAP32[$6 + 88 >> 2] + HEAP32[$6 + 52 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 32 >> 1];
|
|
$5 = HEAP32[$6 + 84 >> 2] + HEAP32[$6 + 56 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 34 >> 1];
|
|
$5 = HEAP32[$6 + 80 >> 2] + HEAP32[$6 + 60 >> 2] | 0;
|
|
$7 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$4 = HEAP16[$10 + 36 >> 1];
|
|
$5 = HEAP32[$6 + 76 >> 2] + HEAP32[$6 + 64 >> 2] | 0;
|
|
$4 = ($7 + Math_imul($4, $5 >> 16) | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$5 = HEAP16[$10 + 38 >> 1];
|
|
$6 = HEAP32[$6 + 72 >> 2] + HEAP32[$6 + 68 >> 2] | 0;
|
|
$6 = ($4 + Math_imul($5, $6 >> 16) | 0) + (Math_imul($6 & 65535, $5) >> 16) | 0;
|
|
$5 = ($6 >> 5) + 1 >> 1;
|
|
HEAP16[$1 >> 1] = ($6 | 0) > 2097119 ? 32767 : ($5 | 0) > -32768 ? $5 : -32768;
|
|
$1 = $1 + 2 | 0;
|
|
$8 = $8 + $15 | 0;
|
|
if (($14 | 0) > ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $3 - $13 | 0;
|
|
if (($3 | 0) >= 2) {
|
|
memcpy($12, ($13 << 2) + $12 | 0, $16 << 2);
|
|
$2 = ($13 << 1) + $2 | 0;
|
|
$5 = HEAP32[$0 + 296 >> 2];
|
|
$8 = HEAP32[$0 + 276 >> 2];
|
|
$6 = HEAP32[$0 + 268 >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
memcpy($17, ($13 << 2) + $12 | 0, $16 << 2);
|
|
__stack_pointer = $20;
|
|
}
|
|
function silk_stereo_LR_to_MS($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0;
|
|
$11 = __stack_pointer - 16 | 0;
|
|
$16 = $11;
|
|
__stack_pointer = $11;
|
|
$23 = $1 - 4 | 0;
|
|
$13 = $10 + 2 | 0;
|
|
$24 = $11 - (($13 << 1) + 15 & -16) | 0;
|
|
$18 = $24;
|
|
__stack_pointer = $18;
|
|
if (($10 | 0) >= -1) {
|
|
$21 = ($13 | 0) > 1 ? $13 : 1;
|
|
$11 = 0;
|
|
while (1) {
|
|
$13 = $11 << 1;
|
|
$15 = $13 - 4 | 0;
|
|
$12 = HEAP16[$15 + $2 >> 1];
|
|
$15 = HEAP16[$1 + $15 >> 1];
|
|
$14 = $15 + $12 | 0;
|
|
HEAP16[$13 + $23 >> 1] = ($14 >>> 1 | 0) + ($14 & 1);
|
|
$19 = $13 + $24 | 0;
|
|
$13 = $15 - $12 | 0;
|
|
$13 = ($13 >> 1) + ($13 & 1) | 0;
|
|
$13 = ($13 | 0) > -32768 ? $13 : -32768;
|
|
HEAP16[$19 >> 1] = ($13 | 0) < 32767 ? $13 : 32767;
|
|
$11 = $11 + 1 | 0;
|
|
if (($21 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$19 = HEAP32[$0 + 4 >> 2];
|
|
HEAP16[$23 >> 1] = $19;
|
|
HEAP16[$23 + 2 >> 1] = $19 >>> 16;
|
|
$14 = HEAP32[$0 + 8 >> 2];
|
|
HEAP32[$24 >> 2] = $14;
|
|
$11 = $10 << 1;
|
|
$19 = $23 + $11 | 0;
|
|
HEAP32[$0 + 4 >> 2] = HEAPU16[$19 >> 1] | HEAPU16[$19 + 2 >> 1] << 16;
|
|
$19 = $11 + $24 | 0;
|
|
HEAP32[$0 + 8 >> 2] = HEAPU16[$19 >> 1] | HEAPU16[$19 + 2 >> 1] << 16;
|
|
$13 = $11 + 15 & -16;
|
|
$18 = $18 - $13 | 0;
|
|
$15 = $18;
|
|
__stack_pointer = $15;
|
|
$11 = 0;
|
|
$17 = $15 - $13 | 0;
|
|
$20 = $17;
|
|
__stack_pointer = $17;
|
|
label$3 : {
|
|
if (($10 | 0) <= 0) {
|
|
$11 = ($10 << 1) + 15 & -16;
|
|
$20 = $20 - $11 | 0;
|
|
$13 = $20;
|
|
__stack_pointer = $13;
|
|
$22 = $13 - $11 | 0;
|
|
__stack_pointer = $22;
|
|
break label$3;
|
|
}
|
|
$21 = $14 >>> 16 | 0;
|
|
$13 = HEAPU16[$23 >> 1];
|
|
while (1) {
|
|
$15 = $11 << 1;
|
|
$19 = HEAP16[$15 + $1 >> 1] + ($13 << 16 >> 16) | 0;
|
|
$11 = $11 + 1 | 0;
|
|
$13 = HEAP16[($11 << 1) + $23 >> 1];
|
|
$12 = (($13 << 1) + $19 >>> 1 | 0) + 1 >>> 1 | 0;
|
|
HEAP16[$15 + $18 >> 1] = $12;
|
|
HEAP16[$15 + $17 >> 1] = $13 - $12;
|
|
if (($10 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$11 = ($10 << 1) + 15 & -16;
|
|
$20 = $20 - $11 | 0;
|
|
$13 = $20;
|
|
__stack_pointer = $13;
|
|
$22 = $13 - $11 | 0;
|
|
__stack_pointer = $22;
|
|
if (($10 | 0) < 1) {
|
|
break label$3;
|
|
}
|
|
$13 = 0;
|
|
while (1) {
|
|
$11 = $21;
|
|
$15 = $13 << 1;
|
|
$21 = HEAP16[($24 + $15 | 0) + 4 >> 1];
|
|
$12 = (($21 + ($14 << 16 >> 16) | 0) + ($11 << 16 >> 16 << 1) >>> 1 | 0) + 1 >>> 1 | 0;
|
|
HEAP16[$15 + $20 >> 1] = $12;
|
|
HEAP16[$15 + $22 >> 1] = $11 - $12;
|
|
$14 = $11;
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$11 = (Math_imul($9, 10) | 0) == ($10 | 0);
|
|
$13 = $11 ? 328 : 655;
|
|
$15 = $7 << 16 >> 16;
|
|
$15 = Math_imul($15, $15);
|
|
$13 = (Math_imul($13, $15 & 65535) >>> 16 | 0) + Math_imul($15 >>> 16 | 0, $13) | 0;
|
|
$7 = silk_stereo_find_predictor($16 + 4 | 0, $18, $20, $0 + 12 | 0, $10, $13);
|
|
HEAP32[$16 + 8 >> 2] = $7;
|
|
$26 = silk_stereo_find_predictor($16, $17, $22, $0 + 20 | 0, $10, $13);
|
|
HEAP32[$16 + 12 >> 2] = $26;
|
|
$21 = ($11 ? -1200 : -600) + $6 | 0;
|
|
$15 = ($21 | 0) > 1 ? $21 : 1;
|
|
$14 = Math_clz32($15);
|
|
$12 = $15 << $14 - 1;
|
|
$17 = $12;
|
|
$11 = HEAP32[$16 >> 2] + Math_imul(HEAP16[$16 + 4 >> 1], 3) | 0;
|
|
$22 = ($11 | 0) < 65536 ? $11 : 65536;
|
|
$20 = Math_imul($22, 3);
|
|
$11 = $20 + 851968 | 0;
|
|
$18 = $11 >> 31;
|
|
$18 = Math_clz32($18 ^ $11 + $18);
|
|
$11 = $11 << $18 - 1;
|
|
$27 = $11;
|
|
$6 = $11 >> 31;
|
|
$25 = $6;
|
|
$11 = 536870911 / ($11 >> 16) << 16 >> 16;
|
|
$12 = (Math_imul($11, $12 & 65535) >> 16) + Math_imul($12 >> 16, $11) | 0;
|
|
$6 = $12 >> 31;
|
|
$19 = $6;
|
|
$6 = $25;
|
|
$19 = __wasm_i64_mul($27, $6, $12, $19);
|
|
$25 = $19;
|
|
$6 = i64toi32_i32$HIGH_BITS;
|
|
$17 = $17 - ((($6 & 536870911) << 3 | $25 >>> 29) & -8) | 0;
|
|
$12 = (Math_imul($17 >> 16, $11) + $12 | 0) + (Math_imul($17 & 65535, $11) >> 16) | 0;
|
|
$11 = Math_imul($9 << 16 >> 16, 600) + 2e3 | 0;
|
|
$6 = $5;
|
|
$14 = ($14 - $18 | 0) + 10 | 0;
|
|
label$7 : {
|
|
if (($14 | 0) <= -1) {
|
|
$14 = 0 - $14 | 0;
|
|
$18 = 2147483647 >>> $14 | 0;
|
|
$17 = -2147483648 >> $14;
|
|
$12 = (($12 | 0) > ($18 | 0) ? $18 : ($12 | 0) < ($17 | 0) ? $17 : $12) << $14;
|
|
break label$7;
|
|
}
|
|
$12 = ($14 | 0) < 32 ? $12 >> $14 : 0;
|
|
}
|
|
HEAP32[$6 >> 2] = $12;
|
|
label$9 : {
|
|
if (($11 | 0) > ($12 | 0)) {
|
|
HEAP32[$5 >> 2] = $11;
|
|
$12 = $15 - $11 | 0;
|
|
HEAP32[$5 + 4 >> 2] = $12;
|
|
$12 = ($12 << 1) - $11 | 0;
|
|
$14 = $12 >> 31;
|
|
$18 = Math_clz32($14 ^ $12 + $14);
|
|
$14 = $12 << $18 - 1;
|
|
$27 = $14;
|
|
$17 = $11 << 16 >> 16;
|
|
$12 = $20 + 65536 | 0;
|
|
$12 = (Math_imul($17, $12 & 65535) >> 16) + Math_imul($12 >> 16, $17) | 0;
|
|
$17 = $12 >> 31;
|
|
$17 = Math_clz32($17 ^ $12 + $17);
|
|
$20 = $12 << $17 - 1;
|
|
$12 = 536870911 / ($20 >> 16) << 16 >> 16;
|
|
$14 = (Math_imul($12, $14 & 65535) >> 16) + Math_imul($14 >> 16, $12) | 0;
|
|
$19 = $14 >> 31;
|
|
$6 = $19;
|
|
$19 = $20 >> 31;
|
|
$25 = $19;
|
|
$19 = $6;
|
|
$25 = __wasm_i64_mul($14, $19, $20, $25);
|
|
$6 = $25;
|
|
$19 = i64toi32_i32$HIGH_BITS;
|
|
$20 = $27 - ((($19 & 536870911) << 3 | $6 >>> 29) & -8) | 0;
|
|
$12 = (Math_imul($20 >> 16, $12) + $14 | 0) + (Math_imul($20 & 65535, $12) >> 16) | 0;
|
|
$14 = ($18 - $17 | 0) + 13 | 0;
|
|
label$11 : {
|
|
if (($14 | 0) <= -1) {
|
|
$14 = 0 - $14 | 0;
|
|
$18 = 2147483647 >>> $14 | 0;
|
|
$17 = -2147483648 >> $14;
|
|
$12 = (($12 | 0) > ($18 | 0) ? $18 : ($12 | 0) < ($17 | 0) ? $17 : $12) << $14;
|
|
break label$11;
|
|
}
|
|
$12 = ($14 | 0) < 32 ? $12 >> $14 : 0;
|
|
}
|
|
$12 = ($12 | 0) > 0 ? $12 : 0;
|
|
$12 = ($12 | 0) < 16384 ? $12 : 16384;
|
|
break label$9;
|
|
}
|
|
HEAP32[$5 + 4 >> 2] = $15 - $12;
|
|
$12 = 16384;
|
|
}
|
|
$14 = HEAP16[$0 + 28 >> 1];
|
|
$12 = $12 - $14 | 0;
|
|
HEAP16[$0 + 28 >> 1] = (Math_imul($12 >>> 16 | 0, $13) + (Math_imul($12 & 65535, $13 << 16 >> 16) >>> 16 | 0) | 0) + $14;
|
|
$6 = 0;
|
|
HEAP8[$4 | 0] = 0;
|
|
label$13 : {
|
|
label$14 : {
|
|
label$15 : {
|
|
label$16 : {
|
|
label$17 : {
|
|
label$18 : {
|
|
if ($8) {
|
|
HEAP32[$16 + 8 >> 2] = 0;
|
|
HEAP32[$16 + 12 >> 2] = 0;
|
|
silk_stereo_quant_pred($16 + 8 | 0, $3);
|
|
break label$18;
|
|
}
|
|
$13 = $15 << 3;
|
|
label$20 : {
|
|
if (!HEAPU16[$0 + 30 >> 1]) {
|
|
label$22 : {
|
|
if ((Math_imul($11, 13) | 0) > ($13 | 0)) {
|
|
$11 = HEAP16[$0 + 28 >> 1];
|
|
break label$22;
|
|
}
|
|
$11 = HEAP16[$0 + 28 >> 1];
|
|
if (((Math_imul($11, $22 & 65535) >> 16) + Math_imul($22 >> 16, $11) | 0) > 818) {
|
|
break label$20;
|
|
}
|
|
}
|
|
HEAP32[$16 + 12 >> 2] = Math_imul($26 << 16 >> 16, $11) >> 14;
|
|
HEAP32[$16 + 8 >> 2] = Math_imul($7 << 16 >> 16, $11) >> 14;
|
|
silk_stereo_quant_pred($16 + 8 | 0, $3);
|
|
HEAP32[$16 + 8 >> 2] = 0;
|
|
HEAP32[$16 + 12 >> 2] = 0;
|
|
HEAP32[$5 + 4 >> 2] = 0;
|
|
HEAP32[$5 >> 2] = $15;
|
|
HEAP8[$4 | 0] = 1;
|
|
break label$17;
|
|
}
|
|
label$24 : {
|
|
if ((Math_imul($11, 11) | 0) > ($13 | 0)) {
|
|
$11 = HEAP16[$0 + 28 >> 1];
|
|
break label$24;
|
|
}
|
|
$11 = HEAP16[$0 + 28 >> 1];
|
|
if (((Math_imul($11, $22 & 65535) >> 16) + Math_imul($22 >> 16, $11) | 0) > 327) {
|
|
break label$20;
|
|
}
|
|
}
|
|
HEAP32[$16 + 12 >> 2] = Math_imul($26 << 16 >> 16, $11) >> 14;
|
|
HEAP32[$16 + 8 >> 2] = Math_imul($7 << 16 >> 16, $11) >> 14;
|
|
silk_stereo_quant_pred($16 + 8 | 0, $3);
|
|
HEAP32[$16 + 8 >> 2] = 0;
|
|
HEAP32[$16 + 12 >> 2] = 0;
|
|
break label$18;
|
|
}
|
|
if (($11 | 0) >= 15566) {
|
|
silk_stereo_quant_pred($16 + 8 | 0, $3);
|
|
$6 = 16384;
|
|
break label$18;
|
|
}
|
|
HEAP32[$16 + 12 >> 2] = Math_imul($26 << 16 >> 16, $11) >> 14;
|
|
HEAP32[$16 + 8 >> 2] = Math_imul($7 << 16 >> 16, $11) >> 14;
|
|
silk_stereo_quant_pred($16 + 8 | 0, $3);
|
|
$6 = HEAP16[$0 + 28 >> 1];
|
|
}
|
|
if (HEAPU8[$4 | 0] != 1) {
|
|
break label$16;
|
|
}
|
|
}
|
|
$11 = HEAPU16[$0 + 32 >> 1] + ($10 - ($9 << 3) | 0) | 0;
|
|
HEAP16[$0 + 32 >> 1] = $11;
|
|
if ((Math_imul($9, 5) | 0) > $11 << 16 >> 16) {
|
|
HEAP8[$4 | 0] = 0;
|
|
break label$14;
|
|
}
|
|
HEAP16[$0 + 32 >> 1] = 1e4;
|
|
break label$15;
|
|
}
|
|
HEAP16[$0 + 32 >> 1] = 0;
|
|
}
|
|
if (HEAPU8[$4 | 0]) {
|
|
break label$13;
|
|
}
|
|
}
|
|
if (HEAP32[$5 + 4 >> 2] > 0) {
|
|
break label$13;
|
|
}
|
|
HEAP32[$5 + 4 >> 2] = 1;
|
|
HEAP32[$5 >> 2] = ($15 | 0) > 2 ? $21 - 1 | 0 : 1;
|
|
}
|
|
$11 = $9 << 3;
|
|
$13 = 65536 / ($11 | 0) | 0;
|
|
$7 = HEAP32[$16 + 12 >> 2];
|
|
$8 = HEAP32[$16 + 8 >> 2];
|
|
if (($9 | 0) >= 1) {
|
|
$13 = $13 << 16 >> 16;
|
|
$15 = HEAP16[$0 + 30 >> 1];
|
|
$12 = $6 - $15 | 0;
|
|
$22 = (Math_imul($13, $12 & 65535) >> 16) + Math_imul($12 >> 16, $13) << 10;
|
|
$12 = HEAP16[$0 + 2 >> 1];
|
|
$9 = (Math_imul($7 - $12 << 16 >> 16, $13) >> 15) + 1 >> 1;
|
|
$14 = HEAP16[$0 >> 1];
|
|
$5 = (Math_imul($8 - $14 << 16 >> 16, $13) >> 15) + 1 >> 1;
|
|
$4 = ($11 | 0) > 1 ? $11 : 1;
|
|
$13 = 0;
|
|
$21 = 0 - $14 | 0;
|
|
$18 = 0 - $12 | 0;
|
|
$15 = $15 << 10;
|
|
while (1) {
|
|
$12 = $13 << 1;
|
|
$14 = $13 + 1 | 0;
|
|
$13 = $14 << 1;
|
|
$17 = HEAP16[$24 + $13 >> 1];
|
|
$15 = $15 + $22 | 0;
|
|
$18 = $18 - $9 | 0;
|
|
$20 = $18 << 16 >> 16;
|
|
$13 = HEAP16[$13 + $23 >> 1];
|
|
$19 = ((Math_imul($17, $15 >> 16) + Math_imul($20, $13 >> 5) | 0) + (Math_imul($15 & 64512, $17) >> 16) | 0) + (Math_imul($13 << 11 & 63488, $20) >> 16) | 0;
|
|
$13 = (HEAP16[$1 + $12 >> 1] + HEAP16[$12 + $23 >> 1] | 0) + ($13 << 1) | 0;
|
|
$3 = ($12 + $2 | 0) - 2 | 0;
|
|
$21 = $21 - $5 | 0;
|
|
$12 = $21 << 16 >> 16;
|
|
$13 = (Math_imul($12, $13 >> 7) + $19 | 0) + (Math_imul($13 << 9 & 65024, $12) >> 16) | 0;
|
|
$12 = ($13 >> 7) + 1 >> 1;
|
|
HEAP16[$3 >> 1] = ($13 | 0) > 8388479 ? 32767 : ($12 | 0) > -32768 ? $12 : -32768;
|
|
$13 = $14;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($10 | 0) > ($11 | 0)) {
|
|
$18 = $6 >> 6;
|
|
$17 = $6 << 10 & 64512;
|
|
$12 = 0 - ($7 << 16) >> 16;
|
|
$14 = 0 - ($8 << 16) >> 16;
|
|
while (1) {
|
|
$13 = $11 << 1;
|
|
$3 = ($13 + $2 | 0) - 2 | 0;
|
|
$11 = $11 + 1 | 0;
|
|
$15 = $11 << 1;
|
|
$21 = HEAP16[$24 + $15 >> 1];
|
|
$15 = HEAP16[$15 + $23 >> 1];
|
|
$13 = (HEAP16[$1 + $13 >> 1] + HEAP16[$13 + $23 >> 1] | 0) + ($15 << 1) | 0;
|
|
$13 = ((((Math_imul($18, $21) + Math_imul($15 >> 5, $12) | 0) + (Math_imul($17, $21) >> 16) | 0) + (Math_imul($15 << 11 & 63488, $12) >> 16) | 0) + Math_imul($13 >> 7, $14) | 0) + (Math_imul($13 << 9 & 65024, $14) >> 16) | 0;
|
|
$15 = ($13 >> 7) + 1 >> 1;
|
|
HEAP16[$3 >> 1] = ($13 | 0) > 8388479 ? 32767 : ($15 | 0) > -32768 ? $15 : -32768;
|
|
if (($10 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP16[$0 + 30 >> 1] = $6;
|
|
HEAP16[$0 + 2 >> 1] = $7;
|
|
HEAP16[$0 >> 1] = $8;
|
|
__stack_pointer = $16 + 16 | 0;
|
|
}
|
|
function __rem_pio2_large($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0;
|
|
$8 = __stack_pointer - 560 | 0;
|
|
__stack_pointer = $8;
|
|
$7 = ($2 - 3 | 0) / 24 | 0;
|
|
$19 = ($7 | 0) > 0 ? $7 : 0;
|
|
$13 = Math_imul($19, -24) + $2 | 0;
|
|
$12 = HEAP32[($4 << 2) + 33424 >> 2];
|
|
$15 = $3 - 1 | 0;
|
|
if (($12 + $15 | 0) >= 0) {
|
|
$6 = $3 + $12 | 0;
|
|
$2 = $19 - $15 | 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$5 = ($2 | 0) < 0 ? 0 : +HEAP32[($2 << 2) + 33440 >> 2];
|
|
HEAPF64[($8 + 320 | 0) + ($7 << 3) >> 3] = $5;
|
|
$2 = $2 + 1 | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$18 = $13 - 24 | 0;
|
|
$6 = 0;
|
|
$10 = ($12 | 0) > 0 ? $12 : 0;
|
|
$11 = ($3 | 0) < 1;
|
|
while (1) {
|
|
label$6 : {
|
|
if ($11) {
|
|
$5 = 0;
|
|
break label$6;
|
|
}
|
|
$7 = $6 + $15 | 0;
|
|
$2 = 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$5 = $5 + HEAPF64[($2 << 3) + $0 >> 3] * HEAPF64[($8 + 320 | 0) + ($7 - $2 << 3) >> 3];
|
|
$2 = $2 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[($6 << 3) + $8 >> 3] = $5;
|
|
$2 = ($6 | 0) == ($10 | 0);
|
|
$6 = $6 + 1 | 0;
|
|
if (!$2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$23 = 47 - $13 | 0;
|
|
$21 = 48 - $13 | 0;
|
|
$24 = $13 - 25 | 0;
|
|
$6 = $12;
|
|
label$9 : {
|
|
while (1) {
|
|
$5 = HEAPF64[($6 << 3) + $8 >> 3];
|
|
$2 = 0;
|
|
$7 = $6;
|
|
$15 = ($6 | 0) < 1;
|
|
if (!$15) {
|
|
while (1) {
|
|
$10 = $2 << 2;
|
|
$10 = $10 + ($8 + 480 | 0) | 0;
|
|
$16 = $5;
|
|
$9 = $5 * 5.960464477539063e-8;
|
|
label$14 : {
|
|
if (Math_abs($9) < 2147483648) {
|
|
$11 = ~~$9;
|
|
break label$14;
|
|
}
|
|
$11 = -2147483648;
|
|
}
|
|
$9 = +($11 | 0);
|
|
$5 = $16 + $9 * -16777216;
|
|
label$13 : {
|
|
if (Math_abs($5) < 2147483648) {
|
|
$11 = ~~$5;
|
|
break label$13;
|
|
}
|
|
$11 = -2147483648;
|
|
}
|
|
HEAP32[$10 >> 2] = $11;
|
|
$7 = $7 - 1 | 0;
|
|
$5 = HEAPF64[($7 << 3) + $8 >> 3] + $9;
|
|
$2 = $2 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = scalbn($5, $18);
|
|
$5 = $5 + floor($5 * .125) * -8;
|
|
label$17 : {
|
|
if (Math_abs($5) < 2147483648) {
|
|
$17 = ~~$5;
|
|
break label$17;
|
|
}
|
|
$17 = -2147483648;
|
|
}
|
|
$5 = $5 - +($17 | 0);
|
|
label$19 : {
|
|
label$20 : {
|
|
label$21 : {
|
|
$22 = ($18 | 0) < 1;
|
|
label$22 : {
|
|
if (!$22) {
|
|
$7 = ($6 << 2) + $8 | 0;
|
|
$2 = $7 + 476 | 0;
|
|
$11 = $2;
|
|
$2 = HEAP32[$7 + 476 >> 2];
|
|
$7 = $2;
|
|
$2 = $2 >> $21;
|
|
$7 = $7 - ($2 << $21) | 0;
|
|
HEAP32[$11 >> 2] = $7;
|
|
$17 = $2 + $17 | 0;
|
|
$14 = $7 >> $23;
|
|
break label$22;
|
|
}
|
|
if ($18) {
|
|
break label$21;
|
|
}
|
|
$14 = HEAP32[(($6 << 2) + $8 | 0) + 476 >> 2] >> 23;
|
|
}
|
|
if (($14 | 0) < 1) {
|
|
break label$19;
|
|
}
|
|
break label$20;
|
|
}
|
|
$14 = 2;
|
|
if (!($5 >= .5 ^ 1)) {
|
|
break label$20;
|
|
}
|
|
$14 = 0;
|
|
break label$19;
|
|
}
|
|
$2 = 0;
|
|
$11 = 0;
|
|
if (!$15) {
|
|
while (1) {
|
|
$15 = ($8 + 480 | 0) + ($2 << 2) | 0;
|
|
$7 = HEAP32[$15 >> 2];
|
|
$10 = 16777215;
|
|
label$26 : {
|
|
label$27 : {
|
|
if ($11) {
|
|
break label$27;
|
|
}
|
|
$10 = 16777216;
|
|
if ($7) {
|
|
break label$27;
|
|
}
|
|
$11 = 0;
|
|
break label$26;
|
|
}
|
|
HEAP32[$15 >> 2] = $10 - $7;
|
|
$11 = 1;
|
|
}
|
|
$2 = $2 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$28 : {
|
|
if ($22) {
|
|
break label$28;
|
|
}
|
|
label$29 : {
|
|
switch ($24 | 0) {
|
|
case 0:
|
|
$7 = ($6 << 2) + $8 | 0;
|
|
$2 = $7 + 476 | 0;
|
|
HEAP32[$2 >> 2] = HEAP32[$7 + 476 >> 2] & 8388607;
|
|
break label$28;
|
|
case 1:
|
|
break label$29;
|
|
default:
|
|
break label$28;
|
|
}
|
|
}
|
|
$7 = ($6 << 2) + $8 | 0;
|
|
$2 = $7 + 476 | 0;
|
|
HEAP32[$2 >> 2] = HEAP32[$7 + 476 >> 2] & 4194303;
|
|
}
|
|
$17 = $17 + 1 | 0;
|
|
if (($14 | 0) != 2) {
|
|
break label$19;
|
|
}
|
|
$5 = 1 - $5;
|
|
$14 = 2;
|
|
if (!$11) {
|
|
break label$19;
|
|
}
|
|
$5 = $5 - scalbn(1, $18);
|
|
}
|
|
if ($5 == 0) {
|
|
$7 = 0;
|
|
label$32 : {
|
|
$2 = $6;
|
|
if (($12 | 0) >= ($2 | 0)) {
|
|
break label$32;
|
|
}
|
|
while (1) {
|
|
$2 = $2 - 1 | 0;
|
|
$7 = HEAP32[($8 + 480 | 0) + ($2 << 2) >> 2] | $7;
|
|
if (($2 | 0) > ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!$7) {
|
|
break label$32;
|
|
}
|
|
$13 = $18;
|
|
while (1) {
|
|
$13 = $13 - 24 | 0;
|
|
$6 = $6 - 1 | 0;
|
|
if (!HEAP32[($8 + 480 | 0) + ($6 << 2) >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$9;
|
|
}
|
|
$2 = 1;
|
|
while (1) {
|
|
$7 = $2;
|
|
$2 = $2 + 1 | 0;
|
|
if (!HEAP32[($8 + 480 | 0) + ($12 - $7 << 2) >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$10 = $6 + $7 | 0;
|
|
while (1) {
|
|
$7 = $3 + $6 | 0;
|
|
$6 = $6 + 1 | 0;
|
|
HEAPF64[($8 + 320 | 0) + ($7 << 3) >> 3] = HEAP32[($19 + $6 << 2) + 33440 >> 2];
|
|
$2 = 0;
|
|
$5 = 0;
|
|
if (($3 | 0) >= 1) {
|
|
while (1) {
|
|
$5 = $5 + HEAPF64[($2 << 3) + $0 >> 3] * HEAPF64[($8 + 320 | 0) + ($7 - $2 << 3) >> 3];
|
|
$2 = $2 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[($6 << 3) + $8 >> 3] = $5;
|
|
if (($6 | 0) < ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = $10;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = scalbn($5, 24 - $13 | 0);
|
|
label$39 : {
|
|
if (!($5 >= 16777216 ^ 1)) {
|
|
$3 = $6 << 2;
|
|
$3 = $3 + ($8 + 480 | 0) | 0;
|
|
$16 = $5;
|
|
$9 = $5 * 5.960464477539063e-8;
|
|
label$42 : {
|
|
if (Math_abs($9) < 2147483648) {
|
|
$2 = ~~$9;
|
|
break label$42;
|
|
}
|
|
$2 = -2147483648;
|
|
}
|
|
$5 = $16 + +($2 | 0) * -16777216;
|
|
label$41 : {
|
|
if (Math_abs($5) < 2147483648) {
|
|
$7 = ~~$5;
|
|
break label$41;
|
|
}
|
|
$7 = -2147483648;
|
|
}
|
|
HEAP32[$3 >> 2] = $7;
|
|
$6 = $6 + 1 | 0;
|
|
break label$39;
|
|
}
|
|
if (Math_abs($5) < 2147483648) {
|
|
$2 = ~~$5;
|
|
} else {
|
|
$2 = -2147483648;
|
|
}
|
|
$13 = $18;
|
|
}
|
|
HEAP32[($8 + 480 | 0) + ($6 << 2) >> 2] = $2;
|
|
}
|
|
$5 = scalbn(1, $13);
|
|
label$47 : {
|
|
if (($6 | 0) <= -1) {
|
|
break label$47;
|
|
}
|
|
$2 = $6;
|
|
while (1) {
|
|
HEAPF64[($2 << 3) + $8 >> 3] = $5 * +HEAP32[($8 + 480 | 0) + ($2 << 2) >> 2];
|
|
$5 = $5 * 5.960464477539063e-8;
|
|
$3 = ($2 | 0) > 0;
|
|
$2 = $2 - 1 | 0;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$10 = 0;
|
|
if (($6 | 0) < 0) {
|
|
break label$47;
|
|
}
|
|
$12 = ($12 | 0) > 0 ? $12 : 0;
|
|
$7 = $6;
|
|
while (1) {
|
|
$0 = $10 >>> 0 > $12 >>> 0 ? $12 : $10;
|
|
$11 = $6 - $7 | 0;
|
|
$2 = 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$5 = $5 + HEAPF64[($2 << 3) + 36208 >> 3] * HEAPF64[($2 + $7 << 3) + $8 >> 3];
|
|
$3 = ($0 | 0) != ($2 | 0);
|
|
$2 = $2 + 1 | 0;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF64[($8 + 160 | 0) + ($11 << 3) >> 3] = $5;
|
|
$7 = $7 - 1 | 0;
|
|
$2 = ($6 | 0) != ($10 | 0);
|
|
$10 = $10 + 1 | 0;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$51 : {
|
|
label$52 : {
|
|
label$53 : {
|
|
switch ($4 | 0) {
|
|
case 3:
|
|
label$56 : {
|
|
if (($6 | 0) < 1) {
|
|
break label$56;
|
|
}
|
|
$5 = HEAPF64[($8 + 160 | 0) + ($6 << 3) >> 3];
|
|
$2 = $6;
|
|
while (1) {
|
|
$3 = $2 - 1 | 0;
|
|
$7 = ($8 + 160 | 0) + ($3 << 3) | 0;
|
|
$9 = HEAPF64[$7 >> 3];
|
|
$16 = $9;
|
|
$9 = $9 + $5;
|
|
HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3] = $5 + ($16 - $9);
|
|
HEAPF64[$7 >> 3] = $9;
|
|
$7 = ($2 | 0) > 1;
|
|
$5 = $9;
|
|
$2 = $3;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($6 | 0) < 2) {
|
|
break label$56;
|
|
}
|
|
$5 = HEAPF64[($8 + 160 | 0) + ($6 << 3) >> 3];
|
|
$2 = $6;
|
|
while (1) {
|
|
$3 = $2 - 1 | 0;
|
|
$7 = ($8 + 160 | 0) + ($3 << 3) | 0;
|
|
$9 = HEAPF64[$7 >> 3];
|
|
$16 = $9;
|
|
$9 = $9 + $5;
|
|
HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3] = $5 + ($16 - $9);
|
|
HEAPF64[$7 >> 3] = $9;
|
|
$7 = ($2 | 0) > 2;
|
|
$5 = $9;
|
|
$2 = $3;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($6 | 0) <= 1) {
|
|
break label$56;
|
|
}
|
|
while (1) {
|
|
$20 = $20 + HEAPF64[($8 + 160 | 0) + ($6 << 3) >> 3];
|
|
$2 = ($6 | 0) > 2;
|
|
$6 = $6 - 1 | 0;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = HEAPF64[$8 + 160 >> 3];
|
|
if ($14) {
|
|
break label$52;
|
|
}
|
|
HEAPF64[$1 >> 3] = $5;
|
|
$5 = HEAPF64[$8 + 168 >> 3];
|
|
HEAPF64[$1 + 16 >> 3] = $20;
|
|
HEAPF64[$1 + 8 >> 3] = $5;
|
|
break label$51;
|
|
case 0:
|
|
$5 = 0;
|
|
if (($6 | 0) >= 0) {
|
|
while (1) {
|
|
$5 = $5 + HEAPF64[($8 + 160 | 0) + ($6 << 3) >> 3];
|
|
$2 = ($6 | 0) > 0;
|
|
$6 = $6 - 1 | 0;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[$1 >> 3] = $14 ? -$5 : $5;
|
|
break label$51;
|
|
case 1:
|
|
case 2:
|
|
break label$53;
|
|
default:
|
|
break label$51;
|
|
}
|
|
}
|
|
$5 = 0;
|
|
if (($6 | 0) >= 0) {
|
|
$2 = $6;
|
|
while (1) {
|
|
$5 = $5 + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3];
|
|
$3 = ($2 | 0) > 0;
|
|
$2 = $2 - 1 | 0;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[$1 >> 3] = $14 ? -$5 : $5;
|
|
$5 = HEAPF64[$8 + 160 >> 3] - $5;
|
|
$2 = 1;
|
|
if (($6 | 0) >= 1) {
|
|
while (1) {
|
|
$5 = $5 + HEAPF64[($8 + 160 | 0) + ($2 << 3) >> 3];
|
|
$3 = ($2 | 0) != ($6 | 0);
|
|
$2 = $2 + 1 | 0;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[$1 + 8 >> 3] = $14 ? -$5 : $5;
|
|
break label$51;
|
|
}
|
|
HEAPF64[$1 >> 3] = -$5;
|
|
$5 = HEAPF64[$8 + 168 >> 3];
|
|
HEAPF64[$1 + 16 >> 3] = -$20;
|
|
HEAPF64[$1 + 8 >> 3] = -$5;
|
|
}
|
|
__stack_pointer = $8 + 560 | 0;
|
|
return $17 & 7;
|
|
}
|
|
function silk_NLSF_del_dec_quant($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
var $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0;
|
|
$10 = __stack_pointer - 320 | 0;
|
|
__stack_pointer = $10;
|
|
$16 = $6 << 16 >> 16;
|
|
$6 = -10;
|
|
while (1) {
|
|
$11 = $6 << 10;
|
|
label$2 : {
|
|
if (($6 | 0) >= 1) {
|
|
$13 = $11 | 922;
|
|
$11 = $11 - 102 | 0;
|
|
break label$2;
|
|
}
|
|
if (!$6) {
|
|
$13 = $11 | 922;
|
|
break label$2;
|
|
}
|
|
$12 = $11 + 1024 | 0;
|
|
$13 = ($6 | 0) == -1 ? $12 : $12 | 102;
|
|
$11 = $11 | 102;
|
|
}
|
|
$12 = ($6 << 2) + 40 | 0;
|
|
HEAP32[$12 + $10 >> 2] = Math_imul($13 << 16 >> 16, $16) >> 16;
|
|
HEAP32[($10 + 80 | 0) + $12 >> 2] = Math_imul($11 << 16 >> 16, $16) >> 16;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != 10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP16[$10 + 224 >> 1] = 0;
|
|
HEAP32[$10 + 192 >> 2] = 0;
|
|
if (($9 | 0) < 1) {
|
|
$20 = 0;
|
|
} else {
|
|
$20 = $8 << 16 >> 16;
|
|
$8 = $9;
|
|
$16 = 1;
|
|
while (1) {
|
|
$24 = $8;
|
|
$8 = $8 - 1 | 0;
|
|
label$8 : {
|
|
label$9 : {
|
|
label$10 : {
|
|
$23 = ($16 | 0) < 1;
|
|
label$11 : {
|
|
if ($23) {
|
|
break label$11;
|
|
}
|
|
$6 = $8 << 1;
|
|
$22 = HEAP16[$6 + $4 >> 1] + $5 | 0;
|
|
$12 = HEAPU16[$1 + $6 >> 1];
|
|
$21 = HEAPU8[$3 + $8 | 0];
|
|
$15 = HEAP16[$2 + $6 >> 1];
|
|
$6 = 0;
|
|
while (1) {
|
|
$17 = ($10 + 224 | 0) + ($6 << 1) | 0;
|
|
$13 = Math_imul(HEAP16[$17 >> 1], $21) >> 8;
|
|
$11 = Math_imul($12 - $13 << 16 >> 16, $7) >> 16;
|
|
$11 = ($11 | 0) > -10 ? $11 : -10;
|
|
$11 = ($11 | 0) < 9 ? $11 : 9;
|
|
HEAP8[(($10 + 240 | 0) + ($6 << 4) | 0) + $8 | 0] = $11;
|
|
$14 = ($11 << 2) + 40 | 0;
|
|
$18 = HEAP32[$14 + ($10 + 80 | 0) >> 2] + $13 | 0;
|
|
HEAP16[$17 >> 1] = $18;
|
|
$17 = $6 + $16 | 0;
|
|
$13 = HEAP32[$10 + $14 >> 2] + $13 | 0;
|
|
HEAP16[($10 + 224 | 0) + ($17 << 1) >> 1] = $13;
|
|
label$13 : {
|
|
if (($11 | 0) >= 3) {
|
|
if (($11 | 0) == 3) {
|
|
$19 = 280;
|
|
$14 = HEAPU8[$22 + 7 | 0];
|
|
break label$13;
|
|
}
|
|
$11 = Math_imul($11, 43);
|
|
$19 = $11 + 151 | 0;
|
|
$14 = $11 + 108 | 0;
|
|
break label$13;
|
|
}
|
|
if (($11 | 0) <= -4) {
|
|
if (($11 | 0) == -4) {
|
|
$19 = HEAPU8[$22 + 1 | 0];
|
|
$14 = 280;
|
|
break label$13;
|
|
}
|
|
$11 = Math_imul($11, -43);
|
|
$19 = $11 + 65 | 0;
|
|
$14 = $11 + 108 | 0;
|
|
break label$13;
|
|
}
|
|
$11 = $11 + $22 | 0;
|
|
$19 = HEAPU8[$11 + 5 | 0];
|
|
$14 = HEAPU8[$11 + 4 | 0];
|
|
}
|
|
$11 = ($10 + 192 | 0) + ($6 << 2) | 0;
|
|
$25 = $11;
|
|
$11 = HEAP32[$11 >> 2];
|
|
$26 = $11 + Math_imul($20, $14) | 0;
|
|
$14 = $12 - $18 << 16 >> 16;
|
|
HEAP32[$25 >> 2] = $26 + Math_imul(Math_imul($14, $14), $15);
|
|
$14 = Math_imul($19, $20) + $11 | 0;
|
|
$11 = $12 - $13 << 16 >> 16;
|
|
HEAP32[($10 + 192 | 0) + ($17 << 2) >> 2] = $14 + Math_imul(Math_imul($11, $11), $15);
|
|
$6 = $6 + 1 | 0;
|
|
if (($16 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($16 | 0) >= 3) {
|
|
$11 = 0;
|
|
$6 = HEAP32[$10 + 208 >> 2];
|
|
$12 = HEAP32[$10 + 192 >> 2];
|
|
if (($6 | 0) < ($12 | 0)) {
|
|
break label$10;
|
|
}
|
|
$15 = $6;
|
|
$6 = $12;
|
|
break label$9;
|
|
}
|
|
$6 = 0;
|
|
if ($23) {
|
|
break label$11;
|
|
}
|
|
while (1) {
|
|
HEAP8[(($10 + 240 | 0) + ($6 + $16 << 4) | 0) + $8 | 0] = HEAPU8[(($10 + 240 | 0) + ($6 << 4) | 0) + $8 | 0] + 1;
|
|
$6 = $6 + 1 | 0;
|
|
if (($16 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$16 = $16 << 1;
|
|
$6 = $16;
|
|
if (($6 | 0) > 3) {
|
|
break label$8;
|
|
}
|
|
while (1) {
|
|
HEAP8[(($10 + 240 | 0) + ($6 << 4) | 0) + $8 | 0] = HEAPU8[(($10 + 240 | 0) + ($6 - $16 << 4) | 0) + $8 | 0];
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != 4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$8;
|
|
}
|
|
HEAP32[$10 + 208 >> 2] = $12;
|
|
HEAP32[$10 + 192 >> 2] = $6;
|
|
$11 = HEAPU16[$10 + 224 >> 1];
|
|
HEAP16[$10 + 224 >> 1] = HEAPU16[$10 + 232 >> 1];
|
|
HEAP16[$10 + 232 >> 1] = $11;
|
|
$11 = 4;
|
|
$15 = $12;
|
|
}
|
|
HEAP32[$10 + 176 >> 2] = $6;
|
|
HEAP32[$10 + 160 >> 2] = $15;
|
|
HEAP32[$10 + 304 >> 2] = $11;
|
|
$12 = 1;
|
|
$11 = HEAP32[$10 + 212 >> 2];
|
|
$13 = HEAP32[$10 + 196 >> 2];
|
|
label$21 : {
|
|
if (($11 | 0) >= ($13 | 0)) {
|
|
$17 = $11;
|
|
$11 = $13;
|
|
break label$21;
|
|
}
|
|
HEAP32[$10 + 212 >> 2] = $13;
|
|
HEAP32[$10 + 196 >> 2] = $11;
|
|
$12 = HEAPU16[$10 + 226 >> 1];
|
|
HEAP16[$10 + 226 >> 1] = HEAPU16[$10 + 234 >> 1];
|
|
HEAP16[$10 + 234 >> 1] = $12;
|
|
$12 = 5;
|
|
$17 = $13;
|
|
}
|
|
HEAP32[$10 + 180 >> 2] = $11;
|
|
HEAP32[$10 + 164 >> 2] = $17;
|
|
HEAP32[$10 + 308 >> 2] = $12;
|
|
$12 = 2;
|
|
$13 = HEAP32[$10 + 216 >> 2];
|
|
$14 = HEAP32[$10 + 200 >> 2];
|
|
label$23 : {
|
|
if (($13 | 0) >= ($14 | 0)) {
|
|
$18 = $13;
|
|
$13 = $14;
|
|
break label$23;
|
|
}
|
|
HEAP32[$10 + 216 >> 2] = $14;
|
|
HEAP32[$10 + 200 >> 2] = $13;
|
|
$12 = HEAPU16[$10 + 228 >> 1];
|
|
HEAP16[$10 + 228 >> 1] = HEAPU16[$10 + 236 >> 1];
|
|
HEAP16[$10 + 236 >> 1] = $12;
|
|
$12 = 6;
|
|
$18 = $14;
|
|
}
|
|
HEAP32[$10 + 184 >> 2] = $13;
|
|
HEAP32[$10 + 168 >> 2] = $18;
|
|
HEAP32[$10 + 312 >> 2] = $12;
|
|
$19 = 3;
|
|
$12 = HEAP32[$10 + 220 >> 2];
|
|
$21 = HEAP32[$10 + 204 >> 2];
|
|
label$25 : {
|
|
if (($12 | 0) >= ($21 | 0)) {
|
|
$14 = $12;
|
|
$12 = $21;
|
|
break label$25;
|
|
}
|
|
HEAP32[$10 + 220 >> 2] = $21;
|
|
HEAP32[$10 + 204 >> 2] = $12;
|
|
$14 = HEAPU16[$10 + 230 >> 1];
|
|
HEAP16[$10 + 230 >> 1] = HEAPU16[$10 + 238 >> 1];
|
|
HEAP16[$10 + 238 >> 1] = $14;
|
|
$19 = 7;
|
|
$14 = $21;
|
|
}
|
|
HEAP32[$10 + 188 >> 2] = $12;
|
|
HEAP32[$10 + 172 >> 2] = $14;
|
|
HEAP32[$10 + 316 >> 2] = $19;
|
|
while (1) {
|
|
$19 = ($15 | 0) > ($17 | 0);
|
|
$15 = $19 ? $17 : $15;
|
|
$17 = ($18 | 0) < ($15 | 0);
|
|
$15 = $17 ? $18 : $15;
|
|
$18 = ($14 | 0) < ($15 | 0);
|
|
$21 = $18 ? $14 : $15;
|
|
$6 = ($6 | 0) > 0 ? $6 : 0;
|
|
$15 = ($11 | 0) > ($6 | 0);
|
|
$6 = $15 ? $11 : $6;
|
|
$11 = ($13 | 0) > ($6 | 0);
|
|
$6 = $11 ? $13 : $6;
|
|
$14 = $6;
|
|
$6 = ($6 | 0) < ($12 | 0);
|
|
if (($21 | 0) < (($6 ? $12 : $14) | 0)) {
|
|
$6 = $6 ? 3 : $11 ? 2 : $15;
|
|
$11 = $6 << 2;
|
|
$12 = $18 ? 3 : $17 ? 2 : $19;
|
|
$13 = $12 << 2;
|
|
HEAP32[($11 | $10 + 304) >> 2] = HEAP32[($13 | $10 + 304) >> 2] ^ 4;
|
|
$15 = $12 | 4;
|
|
HEAP32[($10 + 192 | $11) >> 2] = HEAP32[($10 + 192 | 0) + ($15 << 2) >> 2];
|
|
HEAP32[($10 + 176 | $11) >> 2] = 0;
|
|
HEAP16[($10 + 224 | $6 << 1) >> 1] = HEAPU16[($10 + 224 | $15 << 1) >> 1];
|
|
HEAP32[($10 + 160 | $13) >> 2] = 2147483647;
|
|
$11 = ($10 + 240 | 0) + ($12 << 4) | 0;
|
|
$14 = HEAP32[$11 >> 2];
|
|
$12 = HEAP32[$11 + 4 >> 2];
|
|
$6 = ($10 + 240 | 0) + ($6 << 4) | 0;
|
|
HEAP32[$6 >> 2] = $14;
|
|
HEAP32[$6 + 4 >> 2] = $12;
|
|
$14 = HEAP32[$11 + 12 >> 2];
|
|
$12 = HEAP32[$11 + 8 >> 2];
|
|
HEAP32[$6 + 8 >> 2] = $12;
|
|
HEAP32[$6 + 12 >> 2] = $14;
|
|
$12 = HEAP32[$10 + 188 >> 2];
|
|
$14 = HEAP32[$10 + 172 >> 2];
|
|
$13 = HEAP32[$10 + 184 >> 2];
|
|
$18 = HEAP32[$10 + 168 >> 2];
|
|
$11 = HEAP32[$10 + 180 >> 2];
|
|
$17 = HEAP32[$10 + 164 >> 2];
|
|
$6 = HEAP32[$10 + 176 >> 2];
|
|
$15 = HEAP32[$10 + 160 >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = ($10 + 240 | 0) + $8 | 0;
|
|
HEAP8[$6 | 0] = HEAPU8[$6 | 0] + (HEAP32[$10 + 304 >> 2] >>> 2 | 0);
|
|
$11 = $6 + 16 | 0;
|
|
HEAP8[$11 | 0] = HEAPU8[$6 + 16 | 0] + (HEAP32[$10 + 308 >> 2] >>> 2 | 0);
|
|
$11 = $6 + 48 | 0;
|
|
HEAP8[$11 | 0] = HEAPU8[$6 + 48 | 0] + (HEAP32[$10 + 316 >> 2] >>> 2 | 0);
|
|
$14 = $6;
|
|
$6 = $6 + 32 | 0;
|
|
HEAP8[$6 | 0] = HEAPU8[$14 + 32 | 0] + (HEAP32[$10 + 312 >> 2] >>> 2 | 0);
|
|
}
|
|
if (($24 | 0) > 1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = HEAP32[$10 + 220 >> 2];
|
|
$11 = HEAP32[$10 + 216 >> 2];
|
|
$16 = HEAP32[$10 + 212 >> 2];
|
|
$12 = HEAP32[$10 + 208 >> 2];
|
|
$13 = HEAP32[$10 + 204 >> 2];
|
|
$8 = HEAP32[$10 + 200 >> 2];
|
|
$15 = HEAP32[$10 + 196 >> 2];
|
|
$20 = HEAP32[$10 + 192 >> 2];
|
|
}
|
|
$17 = ($20 | 0) > ($15 | 0);
|
|
$15 = $17 ? $15 : $20;
|
|
$20 = ($15 | 0) > ($8 | 0);
|
|
$8 = $20 ? $8 : $15;
|
|
$15 = ($13 | 0) < ($8 | 0);
|
|
$13 = $15 ? $13 : $8;
|
|
$8 = ($13 | 0) > ($12 | 0);
|
|
$12 = $8 ? $12 : $13;
|
|
$13 = ($16 | 0) < ($12 | 0);
|
|
$16 = $13 ? $16 : $12;
|
|
$12 = ($16 | 0) > ($11 | 0);
|
|
$1 = $12 ? 6 : $13 ? 5 : $8 ? 4 : $15 ? 3 : $20 ? 2 : $17;
|
|
$16 = $12 ? $11 : $16;
|
|
$12 = ($16 | 0) > ($6 | 0);
|
|
$11 = $12 ? 7 : $1;
|
|
if (($9 | 0) > 0) {
|
|
memcpy($0, ($10 + 240 | 0) + (($11 & 3) << 4) | 0, $9);
|
|
}
|
|
HEAP8[$0 | 0] = HEAPU8[$0 | 0] + ($11 >>> 2 | 0);
|
|
__stack_pointer = $10 + 320 | 0;
|
|
return $12 ? $6 : $16;
|
|
}
|
|
function silk_control_encoder($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, wasm2js_i32$0 = 0, wasm2js_i32$1 = 0, wasm2js_i32$2 = 0;
|
|
HEAP32[$0 + 6076 >> 2] = HEAP32[$1 + 48 >> 2];
|
|
HEAP32[$0 + 4676 >> 2] = HEAP32[$1 + 52 >> 2];
|
|
$6 = HEAP32[$1 + 8 >> 2];
|
|
HEAP32[$0 + 4556 >> 2] = $6;
|
|
HEAP32[$0 + 4564 >> 2] = HEAP32[$1 + 12 >> 2];
|
|
HEAP32[$0 + 4568 >> 2] = HEAP32[$1 + 16 >> 2];
|
|
HEAP32[$0 + 4572 >> 2] = HEAP32[$1 + 20 >> 2];
|
|
HEAP32[$0 + 6088 >> 2] = HEAP32[$1 + 40 >> 2];
|
|
HEAP32[$0 + 5752 >> 2] = HEAP32[$1 >> 2];
|
|
$5 = HEAP32[$1 + 4 >> 2];
|
|
HEAP32[$0 + 5760 >> 2] = $3;
|
|
HEAP32[$0 + 4536 >> 2] = $2;
|
|
HEAP32[$0 + 5756 >> 2] = $5;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (!(HEAP32[$0 + 4680 >> 2] | !HEAP32[$0 + 4668 >> 2])) {
|
|
$1 = 0;
|
|
if (HEAP32[$0 + 4560 >> 2] == ($6 | 0)) {
|
|
break label$2;
|
|
}
|
|
$4 = HEAP32[$0 + 4576 >> 2];
|
|
if (($4 | 0) < 1) {
|
|
break label$2;
|
|
}
|
|
return silk_setup_resamplers($0, $4);
|
|
}
|
|
$4 = (wasm2js_i32$0 = $4, wasm2js_i32$1 = silk_control_audio_bandwidth($0, $1), wasm2js_i32$2 = $4, wasm2js_i32$2 ? wasm2js_i32$0 : wasm2js_i32$1);
|
|
$8 = silk_setup_resamplers($0, $4);
|
|
$6 = 0;
|
|
$2 = HEAP32[$1 + 24 >> 2];
|
|
if (($2 | 0) != HEAP32[$0 + 4612 >> 2]) {
|
|
label$5 : {
|
|
label$6 : {
|
|
switch ($2 - 10 | 0) {
|
|
default:
|
|
if (($2 | 0) == 40 | ($2 | 0) == 60) {
|
|
break label$5;
|
|
}
|
|
break;
|
|
case 0:
|
|
case 10:
|
|
break label$5;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
break label$6;
|
|
}
|
|
}
|
|
$6 = -103;
|
|
}
|
|
label$8 : {
|
|
if (($2 | 0) <= 10) {
|
|
HEAP32[$0 + 5744 >> 2] = 1;
|
|
HEAP32[$0 + 4580 >> 2] = ($2 | 0) == 10 ? 2 : 1;
|
|
$3 = $4 << 16 >> 16;
|
|
HEAP32[$0 + 4584 >> 2] = Math_imul($3, $2 << 16 >> 16);
|
|
HEAP32[$0 + 4548 >> 2] = Math_imul($3, 14);
|
|
if (HEAP32[$0 + 4576 >> 2] == 8) {
|
|
HEAP32[$0 + 4688 >> 2] = 2169;
|
|
break label$8;
|
|
}
|
|
HEAP32[$0 + 4688 >> 2] = 2157;
|
|
break label$8;
|
|
}
|
|
HEAP32[$0 + 4580 >> 2] = 4;
|
|
HEAP32[$0 + 5744 >> 2] = ($2 >>> 0) / 20;
|
|
$3 = $4 << 16 >> 16;
|
|
HEAP32[$0 + 4584 >> 2] = Math_imul($3, 20);
|
|
HEAP32[$0 + 4548 >> 2] = Math_imul($3, 24);
|
|
if (HEAP32[$0 + 4576 >> 2] == 8) {
|
|
HEAP32[$0 + 4688 >> 2] = 2146;
|
|
break label$8;
|
|
}
|
|
HEAP32[$0 + 4688 >> 2] = 2112;
|
|
}
|
|
HEAP32[$0 + 4608 >> 2] = 0;
|
|
HEAP32[$0 + 4612 >> 2] = $2;
|
|
}
|
|
label$12 : {
|
|
label$13 : {
|
|
label$14 : {
|
|
label$15 : {
|
|
if (!(!(1 << $4 & 69888) | $4 >>> 0 > 16)) {
|
|
label$17 : {
|
|
label$18 : {
|
|
$2 = HEAP32[$0 + 4580 >> 2];
|
|
switch ($2 - 2 | 0) {
|
|
case 0:
|
|
case 2:
|
|
break label$17;
|
|
default:
|
|
break label$18;
|
|
}
|
|
}
|
|
celt_fatal(6692, 6671, 242);
|
|
abort();
|
|
}
|
|
label$19 : {
|
|
if (HEAP32[$0 + 4576 >> 2] == ($4 | 0)) {
|
|
$5 = HEAP32[$0 + 4584 >> 2];
|
|
$3 = HEAP32[$0 + 4588 >> 2];
|
|
break label$19;
|
|
}
|
|
HEAP32[$0 + 7168 >> 2] = 0;
|
|
HEAP32[$0 + 7172 >> 2] = 0;
|
|
HEAP32[$0 + 5748 >> 2] = 0;
|
|
HEAP32[$0 + 5740 >> 2] = 0;
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
HEAP32[$0 + 20 >> 2] = 0;
|
|
HEAP32[$0 + 4608 >> 2] = 0;
|
|
HEAP32[$0 + 7176 >> 2] = 0;
|
|
memset($0 + 148 | 0, 0, 4384);
|
|
$3 = 10;
|
|
HEAP8[$0 + 7168 | 0] = 10;
|
|
HEAP32[$0 + 4664 >> 2] = 1;
|
|
HEAP32[$0 + 4544 >> 2] = 100;
|
|
HEAP32[$0 + 4576 >> 2] = $4;
|
|
HEAP8[$0 + 4541 | 0] = 0;
|
|
HEAP32[$0 + 4492 >> 2] = 65536;
|
|
HEAP32[$0 + 4476 >> 2] = 100;
|
|
label$21 : {
|
|
if (($4 | 0) == 8) {
|
|
HEAP32[$0 + 4688 >> 2] = ($2 | 0) == 4 ? 2146 : 2169;
|
|
$5 = 3576;
|
|
break label$21;
|
|
}
|
|
HEAP32[$0 + 4688 >> 2] = ($2 | 0) == 4 ? 2112 : 2157;
|
|
$3 = ($4 | 0) == 12;
|
|
$5 = $3 ? 3576 : 5700;
|
|
$3 = $3 ? 10 : 16;
|
|
}
|
|
HEAP32[$0 + 4692 >> 2] = $5;
|
|
HEAP32[$0 + 4640 >> 2] = $3;
|
|
$3 = Math_imul($4, 5);
|
|
HEAP32[$0 + 4588 >> 2] = $3;
|
|
HEAP32[$0 + 4596 >> 2] = $4 << 1;
|
|
HEAP32[$0 + 4592 >> 2] = Math_imul($4, 20);
|
|
HEAP32[$0 + 4552 >> 2] = Math_imul($4, 18);
|
|
$5 = Math_imul(Math_imul($4, 327680) >> 16, $2);
|
|
HEAP32[$0 + 4584 >> 2] = $5;
|
|
HEAP32[$0 + 4548 >> 2] = Math_imul(($2 | 0) == 4 ? 24 : 14, $4);
|
|
if (($4 | 0) == 16) {
|
|
HEAP32[$0 + 4684 >> 2] = 5872;
|
|
$3 = 80;
|
|
break label$19;
|
|
}
|
|
if (($4 | 0) == 12) {
|
|
HEAP32[$0 + 4684 >> 2] = 5866;
|
|
$3 = 60;
|
|
break label$19;
|
|
}
|
|
HEAP32[$0 + 4684 >> 2] = 5857;
|
|
}
|
|
if ((Math_imul($2, $3) | 0) != ($5 | 0)) {
|
|
break label$15;
|
|
}
|
|
$2 = HEAP32[$1 + 36 >> 2];
|
|
if ($2 >>> 0 >= 11) {
|
|
break label$14;
|
|
}
|
|
label$25 : {
|
|
$3 = $0;
|
|
label$26 : {
|
|
if (!$2) {
|
|
HEAP32[$0 + 4652 >> 2] = 52429;
|
|
HEAP32[$0 + 4644 >> 2] = 0;
|
|
HEAP32[$0 + 4648 >> 2] = 6;
|
|
HEAP32[$0 + 4636 >> 2] = 12;
|
|
HEAP32[$0 + 4660 >> 2] = 2;
|
|
HEAP32[$0 + 4628 >> 2] = 1;
|
|
HEAP32[$0 + 4632 >> 2] = 0;
|
|
$5 = Math_imul($4, 3);
|
|
break label$26;
|
|
}
|
|
if (($2 | 0) <= 1) {
|
|
HEAP32[$0 + 4652 >> 2] = 49807;
|
|
HEAP32[$0 + 4644 >> 2] = 1;
|
|
HEAP32[$0 + 4648 >> 2] = 8;
|
|
HEAP32[$0 + 4636 >> 2] = 14;
|
|
HEAP32[$0 + 4660 >> 2] = 3;
|
|
HEAP32[$0 + 4628 >> 2] = 1;
|
|
HEAP32[$0 + 4632 >> 2] = 0;
|
|
break label$13;
|
|
}
|
|
if (($2 | 0) != 2) {
|
|
break label$25;
|
|
}
|
|
HEAP32[$0 + 4652 >> 2] = 52429;
|
|
HEAP32[$0 + 4644 >> 2] = 0;
|
|
HEAP32[$0 + 4648 >> 2] = 6;
|
|
HEAP32[$0 + 4636 >> 2] = 12;
|
|
HEAP32[$0 + 4660 >> 2] = 2;
|
|
HEAP32[$0 + 4628 >> 2] = 2;
|
|
HEAP32[$0 + 4632 >> 2] = 0;
|
|
$5 = Math_imul($4, 3);
|
|
}
|
|
HEAP32[$3 + 4600 >> 2] = $5;
|
|
$3 = 6;
|
|
break label$12;
|
|
}
|
|
if (($2 | 0) <= 3) {
|
|
HEAP32[$0 + 4652 >> 2] = 49807;
|
|
HEAP32[$0 + 4644 >> 2] = 1;
|
|
HEAP32[$0 + 4648 >> 2] = 8;
|
|
HEAP32[$0 + 4636 >> 2] = 14;
|
|
HEAP32[$0 + 4660 >> 2] = 4;
|
|
HEAP32[$0 + 4628 >> 2] = 2;
|
|
HEAP32[$0 + 4632 >> 2] = 0;
|
|
break label$13;
|
|
}
|
|
if (($2 | 0) <= 5) {
|
|
HEAP32[$0 + 4652 >> 2] = 48497;
|
|
HEAP32[$0 + 4644 >> 2] = 1;
|
|
HEAP32[$0 + 4648 >> 2] = 10;
|
|
HEAP32[$0 + 4636 >> 2] = 16;
|
|
HEAP32[$0 + 4660 >> 2] = 6;
|
|
HEAP32[$0 + 4628 >> 2] = 2;
|
|
HEAP32[$0 + 4632 >> 2] = 1;
|
|
$5 = Math_imul($4, 5);
|
|
HEAP32[$0 + 4600 >> 2] = $5;
|
|
$7 = Math_imul($4, 983);
|
|
$3 = 10;
|
|
break label$12;
|
|
}
|
|
if (($2 | 0) <= 7) {
|
|
HEAP32[$0 + 4652 >> 2] = 47186;
|
|
HEAP32[$0 + 4644 >> 2] = 1;
|
|
HEAP32[$0 + 4648 >> 2] = 12;
|
|
HEAP32[$0 + 4636 >> 2] = 20;
|
|
HEAP32[$0 + 4660 >> 2] = 8;
|
|
HEAP32[$0 + 4628 >> 2] = 3;
|
|
HEAP32[$0 + 4632 >> 2] = 1;
|
|
$5 = Math_imul($4, 5);
|
|
HEAP32[$0 + 4600 >> 2] = $5;
|
|
$7 = Math_imul($4, 983);
|
|
$3 = 12;
|
|
break label$12;
|
|
}
|
|
HEAP32[$0 + 4652 >> 2] = 45875;
|
|
HEAP32[$0 + 4644 >> 2] = 2;
|
|
HEAP32[$0 + 4648 >> 2] = 16;
|
|
HEAP32[$0 + 4636 >> 2] = 24;
|
|
HEAP32[$0 + 4660 >> 2] = 16;
|
|
HEAP32[$0 + 4628 >> 2] = 4;
|
|
HEAP32[$0 + 4632 >> 2] = 1;
|
|
$5 = Math_imul($4, 5);
|
|
HEAP32[$0 + 4600 >> 2] = $5;
|
|
$7 = Math_imul($4, 983);
|
|
$3 = 16;
|
|
break label$12;
|
|
}
|
|
celt_fatal(6609, 6671, 241);
|
|
abort();
|
|
}
|
|
celt_fatal(6765, 6671, 302);
|
|
abort();
|
|
}
|
|
celt_fatal(6863, 6671, 315);
|
|
abort();
|
|
}
|
|
$5 = Math_imul($4, 5);
|
|
HEAP32[$0 + 4600 >> 2] = $5;
|
|
$3 = 8;
|
|
}
|
|
HEAP32[$0 + 4672 >> 2] = $7;
|
|
HEAP32[$0 + 4624 >> 2] = $2;
|
|
HEAP32[$0 + 4604 >> 2] = Math_imul($4, 5) + ($5 << 1);
|
|
$4 = HEAP32[$0 + 4640 >> 2];
|
|
$4 = ($3 | 0) < ($4 | 0) ? $3 : $4;
|
|
HEAP32[$0 + 4648 >> 2] = $4;
|
|
if (($4 | 0) >= 17) {
|
|
break label$1;
|
|
}
|
|
$4 = HEAP32[$1 + 32 >> 2];
|
|
HEAP32[$0 + 4616 >> 2] = $4;
|
|
$2 = HEAP32[$0 + 6092 >> 2];
|
|
$1 = HEAP32[$1 + 44 >> 2];
|
|
HEAP32[$0 + 6092 >> 2] = $1;
|
|
if ($1) {
|
|
$3 = $0;
|
|
if ($2) {
|
|
$1 = (Math_imul($4 >> 16, -26214) - (Math_imul($4 & 65535, 26214) >>> 16 | 0) | 0) + 7 | 0;
|
|
$1 = ($1 | 0) > 2 ? $1 : 2;
|
|
} else {
|
|
$1 = 7;
|
|
}
|
|
HEAP32[$3 + 6096 >> 2] = $1;
|
|
}
|
|
$1 = $6 + $8 | 0;
|
|
HEAP32[$0 + 4668 >> 2] = 1;
|
|
}
|
|
return $1;
|
|
}
|
|
celt_fatal(6917, 6671, 393);
|
|
abort();
|
|
}
|
|
function silk_encode_pulses($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0;
|
|
$5 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $5;
|
|
$10 = $5;
|
|
HEAP32[$5 + 24 >> 2] = 0;
|
|
HEAP32[$5 + 28 >> 2] = 0;
|
|
HEAP32[$5 + 16 >> 2] = 0;
|
|
HEAP32[$5 + 20 >> 2] = 0;
|
|
HEAP32[$5 + 8 >> 2] = 0;
|
|
HEAP32[$5 + 12 >> 2] = 0;
|
|
HEAP32[$5 >> 2] = 0;
|
|
HEAP32[$5 + 4 >> 2] = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
$7 = $4 & -16;
|
|
if (($7 | 0) < ($4 | 0)) {
|
|
if (($4 | 0) != 120) {
|
|
break label$3;
|
|
}
|
|
HEAP8[$3 + 120 | 0] = 0;
|
|
HEAP8[$3 + 121 | 0] = 0;
|
|
HEAP8[$3 + 122 | 0] = 0;
|
|
HEAP8[$3 + 123 | 0] = 0;
|
|
HEAP8[$3 + 124 | 0] = 0;
|
|
HEAP8[$3 + 125 | 0] = 0;
|
|
HEAP8[$3 + 126 | 0] = 0;
|
|
HEAP8[$3 + 127 | 0] = 0;
|
|
$7 = 128;
|
|
HEAP8[$3 + 128 | 0] = 0;
|
|
HEAP8[$3 + 129 | 0] = 0;
|
|
HEAP8[$3 + 130 | 0] = 0;
|
|
HEAP8[$3 + 131 | 0] = 0;
|
|
HEAP8[$3 + 132 | 0] = 0;
|
|
HEAP8[$3 + 133 | 0] = 0;
|
|
HEAP8[$3 + 134 | 0] = 0;
|
|
HEAP8[$3 + 135 | 0] = 0;
|
|
$15 = $5 - 512 | 0;
|
|
$8 = $15;
|
|
__stack_pointer = $8;
|
|
$17 = 8;
|
|
break label$2;
|
|
}
|
|
$17 = $4 >> 4;
|
|
$15 = $5 - ($7 << 2) | 0;
|
|
$8 = $15;
|
|
__stack_pointer = $8;
|
|
if (($4 | 0) > 15) {
|
|
break label$2;
|
|
}
|
|
$5 = ($17 << 2) + 15 & -16;
|
|
$16 = $8 - $5 | 0;
|
|
$6 = $16;
|
|
__stack_pointer = $6;
|
|
$19 = $6 - $5 | 0;
|
|
__stack_pointer = $19;
|
|
break label$1;
|
|
}
|
|
celt_fatal(9312, 9354, 89);
|
|
abort();
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
$6 = HEAP8[$3 + $5 | 0];
|
|
$9 = $6;
|
|
$6 = $6 >> 31;
|
|
HEAP32[($5 << 2) + $15 >> 2] = $6 ^ $6 + $9;
|
|
$6 = $5 | 1;
|
|
$11 = ($6 << 2) + $15 | 0;
|
|
$6 = HEAP8[$3 + $6 | 0];
|
|
$9 = $6;
|
|
$6 = $6 >> 31;
|
|
HEAP32[$11 >> 2] = $6 ^ $6 + $9;
|
|
$6 = $5 | 2;
|
|
$11 = ($6 << 2) + $15 | 0;
|
|
$6 = HEAP8[$3 + $6 | 0];
|
|
$9 = $6;
|
|
$6 = $6 >> 31;
|
|
HEAP32[$11 >> 2] = $6 ^ $6 + $9;
|
|
$6 = $5 | 3;
|
|
$11 = ($6 << 2) + $15 | 0;
|
|
$6 = HEAP8[$3 + $6 | 0];
|
|
$9 = $6;
|
|
$6 = $6 >> 31;
|
|
HEAP32[$11 >> 2] = $6 ^ $6 + $9;
|
|
$5 = $5 + 4 | 0;
|
|
if (($7 | 0) > ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = ($17 << 2) + 15 & -16;
|
|
$16 = $8 - $5 | 0;
|
|
$6 = $16;
|
|
__stack_pointer = $6;
|
|
$19 = $6 - $5 | 0;
|
|
__stack_pointer = $19;
|
|
$24 = HEAPU8[8120];
|
|
$23 = HEAPU8[8119];
|
|
$20 = HEAPU8[8118];
|
|
$14 = HEAPU8[8117];
|
|
$6 = 0;
|
|
$5 = $15;
|
|
while (1) {
|
|
$7 = $22 << 2;
|
|
$18 = $19 + $7 | 0;
|
|
HEAP32[$18 >> 2] = 0;
|
|
$25 = $7 + $16 | 0;
|
|
$7 = HEAP32[$5 + 4 >> 2];
|
|
$8 = HEAP32[$5 >> 2];
|
|
while (1) {
|
|
$13 = 1;
|
|
label$8 : {
|
|
label$9 : {
|
|
$7 = $7 + $8 | 0;
|
|
if (($14 | 0) < ($7 | 0)) {
|
|
$9 = $12;
|
|
$7 = $6;
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 >> 2] = $7;
|
|
$9 = HEAP32[$5 + 12 >> 2] + HEAP32[$5 + 8 >> 2] | 0;
|
|
if (($14 | 0) < ($9 | 0)) {
|
|
$9 = $12;
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 4 >> 2] = $9;
|
|
$6 = HEAP32[$5 + 20 >> 2] + HEAP32[$5 + 16 >> 2] | 0;
|
|
if (($14 | 0) < ($6 | 0)) {
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 8 >> 2] = $6;
|
|
$6 = HEAP32[$5 + 28 >> 2] + HEAP32[$5 + 24 >> 2] | 0;
|
|
if (($14 | 0) < ($6 | 0)) {
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 12 >> 2] = $6;
|
|
$6 = HEAP32[$5 + 36 >> 2] + HEAP32[$5 + 32 >> 2] | 0;
|
|
if (($14 | 0) < ($6 | 0)) {
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 16 >> 2] = $6;
|
|
$6 = HEAP32[$5 + 44 >> 2] + HEAP32[$5 + 40 >> 2] | 0;
|
|
if (($14 | 0) < ($6 | 0)) {
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 20 >> 2] = $6;
|
|
$6 = HEAP32[$5 + 52 >> 2] + HEAP32[$5 + 48 >> 2] | 0;
|
|
if (($14 | 0) < ($6 | 0)) {
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 24 >> 2] = $6;
|
|
$6 = HEAP32[$5 + 60 >> 2] + HEAP32[$5 + 56 >> 2] | 0;
|
|
if (($14 | 0) < ($6 | 0)) {
|
|
break label$9;
|
|
}
|
|
HEAP32[$10 + 28 >> 2] = $6;
|
|
$21 = 0;
|
|
break label$8;
|
|
}
|
|
$21 = 1;
|
|
}
|
|
$8 = $7 + $9 | 0;
|
|
label$12 : {
|
|
if (($20 | 0) < ($8 | 0)) {
|
|
$11 = $9;
|
|
$8 = $7;
|
|
break label$12;
|
|
}
|
|
HEAP32[$10 >> 2] = $8;
|
|
$11 = HEAP32[$10 + 12 >> 2] + HEAP32[$10 + 8 >> 2] | 0;
|
|
if (($20 | 0) < ($11 | 0)) {
|
|
$11 = $9;
|
|
break label$12;
|
|
}
|
|
HEAP32[$10 + 4 >> 2] = $11;
|
|
$6 = HEAP32[$10 + 20 >> 2] + HEAP32[$10 + 16 >> 2] | 0;
|
|
if (($20 | 0) < ($6 | 0)) {
|
|
break label$12;
|
|
}
|
|
HEAP32[$10 + 8 >> 2] = $6;
|
|
$6 = HEAP32[$10 + 28 >> 2] + HEAP32[$10 + 24 >> 2] | 0;
|
|
if (($20 | 0) < ($6 | 0)) {
|
|
break label$12;
|
|
}
|
|
HEAP32[$10 + 12 >> 2] = $6;
|
|
$13 = 0;
|
|
}
|
|
$7 = -1;
|
|
$6 = $8 + $11 | 0;
|
|
label$15 : {
|
|
if (($23 | 0) < ($6 | 0)) {
|
|
$12 = $11;
|
|
$6 = $8;
|
|
break label$15;
|
|
}
|
|
HEAP32[$10 >> 2] = $6;
|
|
$12 = HEAP32[$10 + 12 >> 2] + HEAP32[$10 + 8 >> 2] | 0;
|
|
if (($23 | 0) < ($12 | 0)) {
|
|
$12 = $11;
|
|
break label$15;
|
|
}
|
|
HEAP32[$10 + 4 >> 2] = $12;
|
|
$7 = 0;
|
|
}
|
|
$8 = $13 + $21 | 0;
|
|
label$18 : {
|
|
$9 = $6 + $12 | 0;
|
|
if (($24 | 0) >= ($9 | 0)) {
|
|
HEAP32[$25 >> 2] = $9;
|
|
if (($7 | 0) == ($8 | 0)) {
|
|
break label$18;
|
|
}
|
|
}
|
|
HEAP32[$18 >> 2] = HEAP32[$18 >> 2] + 1;
|
|
$8 = HEAP32[$5 >> 2] >> 1;
|
|
HEAP32[$5 >> 2] = $8;
|
|
$7 = HEAP32[$5 + 4 >> 2] >> 1;
|
|
HEAP32[$5 + 4 >> 2] = $7;
|
|
HEAP32[$5 + 8 >> 2] = HEAP32[$5 + 8 >> 2] >> 1;
|
|
HEAP32[$5 + 12 >> 2] = HEAP32[$5 + 12 >> 2] >> 1;
|
|
HEAP32[$5 + 16 >> 2] = HEAP32[$5 + 16 >> 2] >> 1;
|
|
HEAP32[$5 + 20 >> 2] = HEAP32[$5 + 20 >> 2] >> 1;
|
|
HEAP32[$5 + 24 >> 2] = HEAP32[$5 + 24 >> 2] >> 1;
|
|
HEAP32[$5 + 28 >> 2] = HEAP32[$5 + 28 >> 2] >> 1;
|
|
HEAP32[$5 + 32 >> 2] = HEAP32[$5 + 32 >> 2] >> 1;
|
|
HEAP32[$5 + 36 >> 2] = HEAP32[$5 + 36 >> 2] >> 1;
|
|
HEAP32[$5 + 40 >> 2] = HEAP32[$5 + 40 >> 2] >> 1;
|
|
HEAP32[$5 + 44 >> 2] = HEAP32[$5 + 44 >> 2] >> 1;
|
|
HEAP32[$5 + 48 >> 2] = HEAP32[$5 + 48 >> 2] >> 1;
|
|
HEAP32[$5 + 52 >> 2] = HEAP32[$5 + 52 >> 2] >> 1;
|
|
HEAP32[$5 + 56 >> 2] = HEAP32[$5 + 56 >> 2] >> 1;
|
|
HEAP32[$5 + 60 >> 2] = HEAP32[$5 + 60 >> 2] >> 1;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = $5 - -64 | 0;
|
|
$18 = 1;
|
|
$22 = $22 + 1 | 0;
|
|
if (($22 | 0) != ($17 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = 2147483647;
|
|
$20 = $1 >> 1;
|
|
$14 = Math_imul($20, 9);
|
|
$11 = 0;
|
|
$21 = 0;
|
|
while (1) {
|
|
$7 = HEAPU8[($11 + $14 | 0) + 8528 | 0];
|
|
if ($18) {
|
|
$9 = Math_imul($11, 18);
|
|
$12 = $9 + 8337 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$6 = $12;
|
|
$8 = $5 << 2;
|
|
if (HEAP32[$19 + $8 >> 2] <= 0) {
|
|
$6 = (HEAP32[$8 + $16 >> 2] + $9 | 0) + 8320 | 0;
|
|
}
|
|
$7 = HEAPU8[$6 | 0] + $7 | 0;
|
|
$5 = $5 + 1 | 0;
|
|
if (($17 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = ($7 | 0) < ($13 | 0);
|
|
$21 = $5 ? $11 : $21;
|
|
$13 = $5 ? $7 : $13;
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) != 9) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
ec_enc_icdf($0, $21, Math_imul($20, 9) + 8496 | 0, 8);
|
|
label$24 : {
|
|
if (!$18) {
|
|
break label$24;
|
|
}
|
|
$12 = Math_imul($21, 18) + 8128 | 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$8 = $7 << 2;
|
|
$5 = HEAP32[$19 + $8 >> 2];
|
|
label$26 : {
|
|
if (!$5) {
|
|
ec_enc_icdf($0, HEAP32[$8 + $16 >> 2], $12, 8);
|
|
break label$26;
|
|
}
|
|
ec_enc_icdf($0, 17, $12, 8);
|
|
if (($5 | 0) >= 2) {
|
|
$6 = $5 - 1 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
ec_enc_icdf($0, 17, 8290, 8);
|
|
$5 = $5 + 1 | 0;
|
|
if (($6 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ec_enc_icdf($0, HEAP32[$8 + $16 >> 2], 8290, 8);
|
|
}
|
|
$7 = $7 + 1 | 0;
|
|
if (($17 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!$18) {
|
|
break label$24;
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
if (HEAP32[($5 << 2) + $16 >> 2] >= 1) {
|
|
silk_shell_encoder($0, ($5 << 6) + $15 | 0);
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($17 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!$18) {
|
|
break label$24;
|
|
}
|
|
$13 = 0;
|
|
while (1) {
|
|
$9 = HEAP32[($13 << 2) + $19 >> 2];
|
|
if (($9 | 0) >= 1) {
|
|
$11 = ($13 << 4) + $3 | 0;
|
|
$12 = 0;
|
|
while (1) {
|
|
$5 = HEAP8[$12 + $11 | 0];
|
|
$6 = $5;
|
|
$5 = $5 >> 31;
|
|
$8 = ($5 ^ $5 + $6) << 24 >> 24;
|
|
$5 = $9;
|
|
if (($5 | 0) != 1) {
|
|
while (1) {
|
|
$6 = $5 - 1 | 0;
|
|
ec_enc_icdf($0, $8 >>> $6 & 1, 5824, 8);
|
|
$7 = ($5 | 0) > 2;
|
|
$5 = $6;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ec_enc_icdf($0, $8 & 1, 5824, 8);
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != 16) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = $13 + 1 | 0;
|
|
if (($17 | 0) != ($13 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_encode_signs($0, $3, $4, $1, $2, $16);
|
|
__stack_pointer = $10 + 32 | 0;
|
|
}
|
|
function compute_gru($0, $1, $2) {
|
|
var $3 = Math_fround(0), $4 = 0, $5 = 0, $6 = Math_fround(0), $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = Math_fround(0);
|
|
$9 = __stack_pointer - 512 | 0;
|
|
__stack_pointer = $9;
|
|
$7 = HEAP32[$0 + 16 >> 2];
|
|
label$1 : {
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$10 = Math_imul($7, 3);
|
|
$13 = HEAP32[$0 + 12 >> 2];
|
|
$5 = HEAP32[$0 >> 2];
|
|
while (1) {
|
|
HEAPF32[($9 + 256 | 0) + ($4 << 2) >> 2] = HEAP8[$4 + $5 | 0];
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$14 = HEAP32[$0 + 4 >> 2];
|
|
$5 = 0;
|
|
$8 = ($13 | 0) < 1;
|
|
while (1) {
|
|
if (!$8) {
|
|
$12 = ($9 + 256 | 0) + ($5 << 2) | 0;
|
|
$3 = HEAPF32[$12 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($4 << 2) + $2 >> 2] * Math_fround(HEAP8[(Math_imul($4, $10) + $5 | 0) + $14 | 0])));
|
|
$4 = $4 + 1 | 0;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$12 >> 2] = $3;
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = HEAP32[$0 + 8 >> 2];
|
|
$5 = 0;
|
|
while (1) {
|
|
$8 = ($9 + 256 | 0) + ($5 << 2) | 0;
|
|
$3 = HEAPF32[$8 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($4 << 2) + $1 >> 2] * Math_fround(HEAP8[(Math_imul($4, $10) + $5 | 0) + $12 | 0])));
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$8 >> 2] = $3;
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
if (($7 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$3 = Math_fround(1);
|
|
$5 = ($9 + 256 | 0) + ($4 << 2) | 0;
|
|
$6 = Math_fround(Math_fround(HEAPF32[$5 >> 2] * Math_fround(.0078125)) * Math_fround(.5));
|
|
label$9 : {
|
|
if ($6 < Math_fround(8) ^ 1) {
|
|
break label$9;
|
|
}
|
|
$3 = Math_fround(0);
|
|
if ($6 > Math_fround(-8) ^ 1) {
|
|
break label$9;
|
|
}
|
|
$3 = Math_fround(.5);
|
|
if ($6 != $6) {
|
|
break label$9;
|
|
}
|
|
$11 = $6 < Math_fround(0);
|
|
$6 = $11 ? Math_fround(-$6) : $6;
|
|
$3 = Math_fround(Math_floor(Math_fround(Math_fround($6 * Math_fround(25)) + Math_fround(.5))));
|
|
label$10 : {
|
|
if (Math_fround(Math_abs($3)) < Math_fround(2147483648)) {
|
|
$8 = ~~$3;
|
|
break label$10;
|
|
}
|
|
$8 = -2147483648;
|
|
}
|
|
$3 = HEAPF32[($8 << 2) + 48128 >> 2];
|
|
$6 = Math_fround($6 + Math_fround(Math_fround($8 | 0) * Math_fround(-.03999999910593033)));
|
|
$3 = Math_fround($3 + Math_fround(Math_fround(Math_fround(1) - Math_fround($3 * $6)) * Math_fround($6 * Math_fround(Math_fround(1) - Math_fround($3 * $3)))));
|
|
$3 = Math_fround(Math_fround(($11 ? Math_fround(-$3) : $3) * Math_fround(.5)) + Math_fround(.5));
|
|
}
|
|
HEAPF32[$5 >> 2] = $3;
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = HEAP32[$0 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
HEAPF32[($9 + 128 | 0) + ($4 << 2) >> 2] = HEAP8[($4 + $7 | 0) + $5 | 0];
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$8 = $7 + $14 | 0;
|
|
$5 = 0;
|
|
$15 = ($13 | 0) < 1;
|
|
while (1) {
|
|
if (!$15) {
|
|
$11 = ($9 + 128 | 0) + ($5 << 2) | 0;
|
|
$3 = HEAPF32[$11 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($4 << 2) + $2 >> 2] * Math_fround(HEAP8[(Math_imul($4, $10) + $5 | 0) + $8 | 0])));
|
|
$4 = $4 + 1 | 0;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$11 >> 2] = $3;
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = $7 + $12 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$11 = ($9 + 128 | 0) + ($5 << 2) | 0;
|
|
$3 = HEAPF32[$11 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($4 << 2) + $1 >> 2] * Math_fround(HEAP8[(Math_imul($4, $10) + $5 | 0) + $8 | 0])));
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$11 >> 2] = $3;
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
if (($7 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$3 = Math_fround(1);
|
|
$5 = ($9 + 128 | 0) + ($4 << 2) | 0;
|
|
$6 = Math_fround(Math_fround(HEAPF32[$5 >> 2] * Math_fround(.0078125)) * Math_fround(.5));
|
|
label$19 : {
|
|
if ($6 < Math_fround(8) ^ 1) {
|
|
break label$19;
|
|
}
|
|
$3 = Math_fround(0);
|
|
if ($6 > Math_fround(-8) ^ 1) {
|
|
break label$19;
|
|
}
|
|
$3 = Math_fround(.5);
|
|
if ($6 != $6) {
|
|
break label$19;
|
|
}
|
|
$11 = $6 < Math_fround(0);
|
|
$6 = $11 ? Math_fround(-$6) : $6;
|
|
$3 = Math_fround(Math_floor(Math_fround(Math_fround($6 * Math_fround(25)) + Math_fround(.5))));
|
|
label$20 : {
|
|
if (Math_fround(Math_abs($3)) < Math_fround(2147483648)) {
|
|
$8 = ~~$3;
|
|
break label$20;
|
|
}
|
|
$8 = -2147483648;
|
|
}
|
|
$3 = HEAPF32[($8 << 2) + 48128 >> 2];
|
|
$6 = Math_fround($6 + Math_fround(Math_fround($8 | 0) * Math_fround(-.03999999910593033)));
|
|
$3 = Math_fround($3 + Math_fround(Math_fround(Math_fround(1) - Math_fround($3 * $6)) * Math_fround($6 * Math_fround(Math_fround(1) - Math_fround($3 * $3)))));
|
|
$3 = Math_fround(Math_fround(($11 ? Math_fround(-$3) : $3) * Math_fround(.5)) + Math_fround(.5));
|
|
}
|
|
HEAPF32[$5 >> 2] = $3;
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = $7 << 1;
|
|
$8 = HEAP32[$0 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
HEAPF32[($4 << 2) + $9 >> 2] = HEAP8[($4 + $5 | 0) + $8 | 0];
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
if (($7 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$5 = $4 << 2;
|
|
HEAPF32[$5 + ($9 + 384 | 0) >> 2] = HEAPF32[$1 + $5 >> 2] * HEAPF32[($9 + 128 | 0) + $5 >> 2];
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$0 = $7 << 1;
|
|
$14 = $14 + $0 | 0;
|
|
$5 = 0;
|
|
$11 = ($13 | 0) < 1;
|
|
while (1) {
|
|
if (!$11) {
|
|
$8 = ($5 << 2) + $9 | 0;
|
|
$3 = HEAPF32[$8 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($4 << 2) + $2 >> 2] * Math_fround(HEAP8[(Math_imul($4, $10) + $5 | 0) + $14 | 0])));
|
|
$4 = $4 + 1 | 0;
|
|
if (($13 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$8 >> 2] = $3;
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = $0 + $12 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$13 = ($5 << 2) + $9 | 0;
|
|
$3 = HEAPF32[$13 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($9 + 384 | 0) + ($4 << 2) >> 2] * Math_fround(HEAP8[(Math_imul($4, $10) + $5 | 0) + $12 | 0])));
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$13 >> 2] = $3;
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
if (($7 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$10 = $4 << 2;
|
|
$3 = HEAPF32[$10 + ($9 + 256 | 0) >> 2];
|
|
$16 = Math_fround($3 * HEAPF32[$1 + $10 >> 2]);
|
|
$17 = Math_fround(Math_fround(1) - $3);
|
|
$3 = Math_fround(1);
|
|
$10 = $9 + $10 | 0;
|
|
$6 = Math_fround(HEAPF32[$10 >> 2] * Math_fround(.0078125));
|
|
label$30 : {
|
|
if ($6 < Math_fround(8) ^ 1) {
|
|
break label$30;
|
|
}
|
|
$3 = Math_fround(-1);
|
|
if ($6 > Math_fround(-8) ^ 1) {
|
|
break label$30;
|
|
}
|
|
$3 = Math_fround(0);
|
|
if ($6 != $6) {
|
|
break label$30;
|
|
}
|
|
$12 = $6 < Math_fround(0);
|
|
$6 = $12 ? Math_fround(-$6) : $6;
|
|
$3 = Math_fround(Math_floor(Math_fround(Math_fround($6 * Math_fround(25)) + Math_fround(.5))));
|
|
label$31 : {
|
|
if (Math_fround(Math_abs($3)) < Math_fround(2147483648)) {
|
|
$5 = ~~$3;
|
|
break label$31;
|
|
}
|
|
$5 = -2147483648;
|
|
}
|
|
$3 = HEAPF32[($5 << 2) + 48128 >> 2];
|
|
$6 = Math_fround($6 + Math_fround(Math_fround($5 | 0) * Math_fround(-.03999999910593033)));
|
|
$3 = Math_fround($3 + Math_fround(Math_fround(Math_fround(1) - Math_fround($3 * $6)) * Math_fround($6 * Math_fround(Math_fround(1) - Math_fround($3 * $3)))));
|
|
$3 = $12 ? Math_fround(-$3) : $3;
|
|
}
|
|
HEAPF32[$10 >> 2] = $16 + Math_fround($17 * $3);
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
memcpy($1, $9, $7 << 2);
|
|
}
|
|
__stack_pointer = $9 + 512 | 0;
|
|
}
|
|
function quant_band($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = Math_fround(0), $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0;
|
|
$22 = ($2 >>> 0) / ($4 >>> 0) | 0;
|
|
$24 = HEAP32[$0 >> 2];
|
|
label$1 : {
|
|
if (($2 | 0) == 1) {
|
|
$5 = 0;
|
|
if (HEAP32[$0 + 32 >> 2] >= 8) {
|
|
$9 = HEAP32[$0 + 28 >> 2];
|
|
label$4 : {
|
|
if ($24) {
|
|
$5 = HEAPF32[$1 >> 2] < Math_fround(0);
|
|
ec_enc_bits($9, $5, 1);
|
|
break label$4;
|
|
}
|
|
$5 = ec_dec_bits($9, 1);
|
|
}
|
|
HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] - 8;
|
|
}
|
|
if (HEAP32[$0 + 4 >> 2]) {
|
|
HEAPF32[$1 >> 2] = $5 ? Math_fround(-1) : Math_fround(1);
|
|
}
|
|
$10 = 1;
|
|
if (!$7) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$7 >> 2] = HEAP32[$1 >> 2];
|
|
return 1;
|
|
}
|
|
$21 = HEAP32[$0 + 24 >> 2];
|
|
$11 = ($21 | 0) > 0;
|
|
label$7 : {
|
|
if (!$5) {
|
|
$9 = $5;
|
|
break label$7;
|
|
}
|
|
if (!$9) {
|
|
$9 = $5;
|
|
break label$7;
|
|
}
|
|
if (!(!($22 & 1) & ($21 | 0) != 0 | (($21 | 0) > 0 | ($4 | 0) > 1))) {
|
|
$9 = $5;
|
|
break label$7;
|
|
}
|
|
memcpy($9, $5, $2 << 2);
|
|
}
|
|
$19 = $11 ? $21 : 0;
|
|
if (($21 | 0) >= 1) {
|
|
while (1) {
|
|
label$13 : {
|
|
if ($24) {
|
|
if (($12 | 0) == 31) {
|
|
break label$13;
|
|
}
|
|
$15 = $2 >> $12;
|
|
$5 = $15 >> 1;
|
|
$20 = ($5 | 0) > 1 ? $5 : 1;
|
|
$14 = 1 << $12;
|
|
$18 = $14 << 1;
|
|
$11 = 0;
|
|
while (1) {
|
|
$5 = 0;
|
|
if (($15 | 0) >= 2) {
|
|
while (1) {
|
|
$13 = (Math_imul($5, $18) + $11 << 2) + $1 | 0;
|
|
$23 = $13;
|
|
$16 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
$13 = ((($5 << 1 | 1) << $12) + $11 << 2) + $1 | 0;
|
|
$17 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$23 >> 2] = $16 + $17;
|
|
HEAPF32[$13 >> 2] = $16 - $17;
|
|
$5 = $5 + 1 | 0;
|
|
if (($20 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$11 = $11 + 1 | 0;
|
|
if (($14 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$9 | ($12 | 0) == 31) {
|
|
break label$13;
|
|
}
|
|
$15 = $2 >> $12;
|
|
$5 = $15 >> 1;
|
|
$20 = ($5 | 0) > 1 ? $5 : 1;
|
|
$14 = 1 << $12;
|
|
$18 = $14 << 1;
|
|
$11 = 0;
|
|
while (1) {
|
|
$5 = 0;
|
|
if (($15 | 0) >= 2) {
|
|
while (1) {
|
|
$13 = (Math_imul($5, $18) + $11 << 2) + $9 | 0;
|
|
$23 = $13;
|
|
$16 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
$13 = ((($5 << 1 | 1) << $12) + $11 << 2) + $9 | 0;
|
|
$17 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$23 >> 2] = $16 + $17;
|
|
HEAPF32[$13 >> 2] = $16 - $17;
|
|
$5 = $5 + 1 | 0;
|
|
if (($20 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$11 = $11 + 1 | 0;
|
|
if (($14 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$10 = HEAPU8[($10 & 15) + 41920 | 0] | HEAPU8[($10 >> 4) + 41920 | 0] << 2;
|
|
$12 = $12 + 1 | 0;
|
|
if (($19 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = $4 >> $19;
|
|
$15 = $22 << $19;
|
|
label$21 : {
|
|
if (!($15 & 1 | ($21 | 0) > -1)) {
|
|
$22 = $21;
|
|
while (1) {
|
|
if (!(!$24 | ($12 | 0) < 1)) {
|
|
$5 = $15 >> 1;
|
|
$20 = ($5 | 0) > 1 ? $5 : 1;
|
|
$18 = $12 << 1;
|
|
$11 = 0;
|
|
while (1) {
|
|
$5 = 0;
|
|
if (($15 | 0) >= 2) {
|
|
while (1) {
|
|
$13 = (Math_imul($5, $18) + $11 << 2) + $1 | 0;
|
|
$14 = $13;
|
|
$16 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
$13 = (Math_imul($5 << 1 | 1, $12) + $11 << 2) + $1 | 0;
|
|
$17 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$14 >> 2] = $16 + $17;
|
|
HEAPF32[$13 >> 2] = $16 - $17;
|
|
$5 = $5 + 1 | 0;
|
|
if (($20 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$11 = $11 + 1 | 0;
|
|
if (($12 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$14 = $15 >> 1;
|
|
if (!(!$9 | ($12 | 0) < 1)) {
|
|
$20 = ($14 | 0) > 1 ? $14 : 1;
|
|
$18 = $12 << 1;
|
|
$11 = 0;
|
|
while (1) {
|
|
$5 = 0;
|
|
if (($15 | 0) >= 2) {
|
|
while (1) {
|
|
$13 = (Math_imul($5, $18) + $11 << 2) + $9 | 0;
|
|
$23 = $13;
|
|
$16 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
$13 = (Math_imul($5 << 1 | 1, $12) + $11 << 2) + $9 | 0;
|
|
$17 = Math_fround(HEAPF32[$13 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$23 >> 2] = $16 + $17;
|
|
HEAPF32[$13 >> 2] = $16 - $17;
|
|
$5 = $5 + 1 | 0;
|
|
if (($20 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$11 = $11 + 1 | 0;
|
|
if (($12 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$25 = $25 + 1 | 0;
|
|
$5 = $12 << 1;
|
|
$10 = $10 << $12 | $10;
|
|
if ($15 & 2) {
|
|
break label$21;
|
|
}
|
|
$11 = ($22 | 0) < -1;
|
|
$22 = $22 + 1 | 0;
|
|
$12 = $5;
|
|
$15 = $14;
|
|
if ($11) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$21;
|
|
}
|
|
$14 = $15;
|
|
$5 = $12;
|
|
}
|
|
$11 = ($4 | 0) == 1;
|
|
label$32 : {
|
|
if (($5 | 0) < 2) {
|
|
break label$32;
|
|
}
|
|
if ($24) {
|
|
deinterleave_hadamard($1, $14 >> $19, $5 << $19, $11);
|
|
}
|
|
if (!$9) {
|
|
break label$32;
|
|
}
|
|
deinterleave_hadamard($9, $14 >> $19, $5 << $19, $11);
|
|
}
|
|
$10 = quant_partition($0, $1, $2, $3, $5, $9, $6, $8, $10);
|
|
if (!HEAP32[$0 + 4 >> 2]) {
|
|
break label$1;
|
|
}
|
|
if (($5 | 0) >= 2) {
|
|
interleave_hadamard($1, $14 >> $19, $5 << $19, $11);
|
|
}
|
|
label$35 : {
|
|
if (!$25) {
|
|
$13 = $5;
|
|
break label$35;
|
|
}
|
|
$18 = 0;
|
|
while (1) {
|
|
$14 = $14 << 1;
|
|
$13 = $5 >> 1;
|
|
$15 = $10 >>> $13 | 0;
|
|
if (($5 | 0) >= 2) {
|
|
$9 = $14 >> 1;
|
|
$12 = ($9 | 0) > 1 ? $9 : 1;
|
|
$20 = $5 & -2;
|
|
$9 = 0;
|
|
while (1) {
|
|
$5 = 0;
|
|
if (($14 | 0) >= 2) {
|
|
while (1) {
|
|
$11 = (Math_imul($5, $20) + $9 << 2) + $1 | 0;
|
|
$0 = $11;
|
|
$16 = Math_fround(HEAPF32[$11 >> 2] * Math_fround(.7071067690849304));
|
|
$11 = (Math_imul($5 << 1 | 1, $13) + $9 << 2) + $1 | 0;
|
|
$17 = Math_fround(HEAPF32[$11 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$0 >> 2] = $16 + $17;
|
|
HEAPF32[$11 >> 2] = $16 - $17;
|
|
$5 = $5 + 1 | 0;
|
|
if (($12 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($13 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$10 = $10 | $15;
|
|
$5 = $13;
|
|
$18 = $18 + 1 | 0;
|
|
if (($25 | 0) != ($18 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = 0;
|
|
if (($21 | 0) > 0) {
|
|
while (1) {
|
|
$10 = HEAPU8[$10 + 41936 | 0];
|
|
if (($12 | 0) != 31) {
|
|
$15 = $2 >> $12;
|
|
$5 = $15 >> 1;
|
|
$20 = ($5 | 0) > 1 ? $5 : 1;
|
|
$14 = 1 << $12;
|
|
$18 = $14 << 1;
|
|
$9 = 0;
|
|
while (1) {
|
|
$5 = 0;
|
|
if (($15 | 0) >= 2) {
|
|
while (1) {
|
|
$11 = (Math_imul($5, $18) + $9 << 2) + $1 | 0;
|
|
$0 = $11;
|
|
$16 = Math_fround(HEAPF32[$11 >> 2] * Math_fround(.7071067690849304));
|
|
$11 = ((($5 << 1 | 1) << $12) + $9 << 2) + $1 | 0;
|
|
$17 = Math_fround(HEAPF32[$11 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$0 >> 2] = $16 + $17;
|
|
HEAPF32[$11 >> 2] = $16 - $17;
|
|
$5 = $5 + 1 | 0;
|
|
if (($20 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($14 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if (($19 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$11 = $13 << $19;
|
|
if (!(!$7 | ($2 | 0) < 1)) {
|
|
$16 = Math_fround(Math_sqrt(+($2 | 0)));
|
|
$5 = 0;
|
|
while (1) {
|
|
$9 = $5 << 2;
|
|
HEAPF32[$9 + $7 >> 2] = HEAPF32[$1 + $9 >> 2] * $16;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$10 = (-1 << $11 ^ -1) & $10;
|
|
}
|
|
return $10;
|
|
}
|
|
function update_filter($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = Math_fround(0), $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0;
|
|
$2 = HEAP32[$0 + 8 >> 2];
|
|
$1 = HEAP32[$0 + 12 >> 2];
|
|
$5 = ($2 >>> 0) / ($1 >>> 0) | 0;
|
|
HEAP32[$0 + 36 >> 2] = $5;
|
|
$3 = Math_imul(HEAP32[$0 + 16 >> 2], 20);
|
|
$6 = HEAP32[$3 + 50884 >> 2];
|
|
HEAP32[$0 + 48 >> 2] = $6;
|
|
$11 = HEAP32[$0 + 24 >> 2];
|
|
$4 = HEAP32[$3 + 50880 >> 2];
|
|
HEAP32[$0 + 24 >> 2] = $4;
|
|
HEAP32[$0 + 40 >> 2] = $2 - Math_imul($1, $5);
|
|
$17 = HEAP32[$0 + 28 >> 2];
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
if ($1 >>> 0 < $2 >>> 0) {
|
|
HEAPF32[$0 + 44 >> 2] = Math_fround(HEAPF32[$3 + 50888 >> 2] * Math_fround($1 >>> 0)) / Math_fround($2 >>> 0);
|
|
$3 = ($4 >>> 0) / ($1 >>> 0) | 0;
|
|
$5 = $4 - Math_imul($3, $1) | 0;
|
|
$4 = 4294967295 / ($2 >>> 0) | 0;
|
|
if ($5 >>> 0 > $4 >>> 0 | $3 >>> 0 > $4 >>> 0) {
|
|
break label$2;
|
|
}
|
|
$4 = Math_imul($2, $3);
|
|
$3 = (Math_imul($2, $5) >>> 0) / ($1 >>> 0) | 0;
|
|
if ($4 >>> 0 > ($3 ^ -1) >>> 0) {
|
|
break label$2;
|
|
}
|
|
$4 = ($3 + $4 | 0) + 7 & -8;
|
|
HEAP32[$0 + 24 >> 2] = $4;
|
|
$3 = $1 << 1 >>> 0 < $2 >>> 0;
|
|
$5 = $1 << 2 >>> 0 < $2 >>> 0;
|
|
$7 = $1 << 3;
|
|
$6 = $6 >>> $3 >>> $5 >>> ($7 >>> 0 < $2 >>> 0) | 0;
|
|
if (!($2 >>> 0 <= $7 >>> 0 ? !($3 | $5) : 0)) {
|
|
HEAP32[$0 + 48 >> 2] = $6;
|
|
}
|
|
$3 = $1 << 4 >>> 0 < $2 >>> 0;
|
|
$2 = $6 >>> $3 | 0;
|
|
if ($2 ? !$3 : 0) {
|
|
break label$3;
|
|
}
|
|
$6 = $2 ? $2 : 1;
|
|
HEAP32[$0 + 48 >> 2] = $6;
|
|
break label$3;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$3 + 50892 >> 2];
|
|
}
|
|
$2 = Math_imul($1, $4);
|
|
$5 = Math_imul($4, $6) + 8 | 0;
|
|
label$7 : {
|
|
if ($2 >>> 0 <= $5 >>> 0) {
|
|
$3 = 1;
|
|
if (536870911 / ($1 >>> 0) >>> 0 >= $4 >>> 0) {
|
|
break label$7;
|
|
}
|
|
}
|
|
$3 = 0;
|
|
$2 = $5;
|
|
if (536870903 / ($6 >>> 0) >>> 0 < $4 >>> 0) {
|
|
break label$2;
|
|
}
|
|
}
|
|
if (HEAPU32[$0 + 80 >> 2] < $2 >>> 0) {
|
|
$1 = dlrealloc(HEAP32[$0 + 76 >> 2], $2 << 2);
|
|
if (!$1) {
|
|
break label$2;
|
|
}
|
|
HEAP32[$0 + 80 >> 2] = $2;
|
|
HEAP32[$0 + 76 >> 2] = $1;
|
|
}
|
|
$9 = $0;
|
|
label$10 : {
|
|
label$11 : {
|
|
label$12 : {
|
|
if (!$3) {
|
|
$1 = -4;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
$6 = HEAP32[$0 + 48 >> 2];
|
|
$4 = Math_imul($2, $6) + 4 | 0;
|
|
if (($4 | 0) > -4) {
|
|
break label$12;
|
|
}
|
|
$5 = HEAP32[$0 + 16 >> 2];
|
|
break label$11;
|
|
}
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
$8 = HEAP32[$0 + 12 >> 2];
|
|
if ($8) {
|
|
$5 = ($2 | 0) / -2 | 0;
|
|
$13 = Math_fround($8 >>> 0);
|
|
$7 = 0;
|
|
while (1) {
|
|
if ($2) {
|
|
$4 = Math_imul($2, $7);
|
|
$14 = Math_fround(Math_fround($7 >>> 0) / $13);
|
|
$3 = HEAP32[Math_imul(HEAP32[$0 + 16 >> 2], 20) + 50896 >> 2];
|
|
$6 = HEAP32[$0 + 76 >> 2];
|
|
$1 = 0;
|
|
while (1) {
|
|
$10 = ($1 + $4 << 2) + $6 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
HEAPF32[$10 >> 2] = sinc(HEAPF32[$0 + 44 >> 2], Math_fround(Math_fround($5 + $1 | 0) - $14), $2, $3);
|
|
if (($1 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = $7 + 1 | 0;
|
|
if (($8 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = HEAP32[$0 + 16 >> 2] > 8 ? 5 : 6;
|
|
break label$10;
|
|
}
|
|
$14 = Math_fround($2 >>> 1 >>> 0);
|
|
$5 = HEAP32[$0 + 16 >> 2];
|
|
$3 = HEAP32[Math_imul($5, 20) + 50896 >> 2];
|
|
$13 = Math_fround($6 >>> 0);
|
|
$6 = HEAP32[$0 + 76 >> 2];
|
|
while (1) {
|
|
HEAPF32[(($1 << 2) + $6 | 0) + 16 >> 2] = sinc(HEAPF32[$0 + 44 >> 2], Math_fround(Math_fround(Math_fround($1 | 0) / $13) - $14), $2, $3);
|
|
$1 = $1 + 1 | 0;
|
|
if (($4 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = ($5 | 0) > 8 ? 7 : 8;
|
|
}
|
|
HEAP32[$9 + 84 >> 2] = $1;
|
|
$1 = (HEAP32[$0 + 32 >> 2] + $2 | 0) - 1 | 0;
|
|
$2 = HEAP32[$0 + 28 >> 2];
|
|
if ($1 >>> 0 > $2 >>> 0) {
|
|
$2 = HEAP32[$0 + 20 >> 2];
|
|
if (536870911 / ($2 >>> 0) >>> 0 < $1 >>> 0) {
|
|
break label$2;
|
|
}
|
|
$2 = dlrealloc(HEAP32[$0 + 72 >> 2], Math_imul($1, $2) << 2);
|
|
if (!$2) {
|
|
break label$2;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = $1;
|
|
HEAP32[$0 + 72 >> 2] = $2;
|
|
$2 = $1;
|
|
}
|
|
if (!HEAP32[$0 + 56 >> 2]) {
|
|
$1 = Math_imul(HEAP32[$0 + 20 >> 2], $2);
|
|
if (!$1) {
|
|
return 0;
|
|
}
|
|
memset(HEAP32[$0 + 72 >> 2], 0, $1 << 2);
|
|
return 0;
|
|
}
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if ($11 >>> 0 < $2 >>> 0) {
|
|
$8 = HEAP32[$0 + 20 >> 2];
|
|
if (!$8) {
|
|
return 0;
|
|
}
|
|
$18 = $11 - 1 | 0;
|
|
$19 = ($8 << 2) - 4 | 0;
|
|
$20 = HEAP32[$0 + 68 >> 2];
|
|
while (1) {
|
|
$7 = $12 << 2;
|
|
$8 = $8 - 1 | 0;
|
|
$15 = $8 << 2;
|
|
$5 = $15 + $20 | 0;
|
|
$4 = HEAP32[$5 >> 2];
|
|
$9 = $4 << 1;
|
|
$1 = $4 + $18 | 0;
|
|
if ($1) {
|
|
$3 = Math_imul($8, $17);
|
|
$6 = Math_imul(HEAP32[$0 + 28 >> 2], $8);
|
|
$2 = HEAP32[$0 + 72 >> 2];
|
|
while (1) {
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[(($4 + $1 | 0) + $6 << 2) + $2 >> 2] = HEAP32[($1 + $3 << 2) + $2 >> 2];
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$16 = $19 - $7 | 0;
|
|
$9 = $9 + $11 | 0;
|
|
if ($4) {
|
|
memset(HEAP32[$0 + 72 >> 2] + Math_imul(HEAP32[$0 + 28 >> 2], $16) | 0, 0, $4 << 2);
|
|
}
|
|
HEAP32[$5 >> 2] = 0;
|
|
$10 = HEAP32[$0 + 24 >> 2];
|
|
label$28 : {
|
|
if ($10 >>> 0 > $9 >>> 0) {
|
|
$6 = $9 - 1 | 0;
|
|
if ($6) {
|
|
$5 = $10 - 2 | 0;
|
|
$7 = $9 - 2 | 0;
|
|
$4 = Math_imul(HEAP32[$0 + 28 >> 2], $8);
|
|
$3 = HEAP32[$0 + 72 >> 2];
|
|
$1 = 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
HEAP32[(($1 + $5 | 0) + $4 << 2) + $3 >> 2] = HEAP32[(($1 + $7 | 0) + $4 << 2) + $3 >> 2];
|
|
$1 = $2 ^ -1;
|
|
$2 = $2 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = $10 - 1 | 0;
|
|
if ($6 >>> 0 < $1 >>> 0) {
|
|
memset(HEAP32[$0 + 72 >> 2] + Math_imul(HEAP32[$0 + 28 >> 2], $16) | 0, 0, $1 - $6 << 2);
|
|
}
|
|
$1 = HEAP32[$0 + 60 >> 2] + $15 | 0;
|
|
HEAP32[$1 >> 2] = HEAP32[$1 >> 2] + ($10 - $9 >>> 1 | 0);
|
|
break label$28;
|
|
}
|
|
$3 = $9 - $10 >>> 1 | 0;
|
|
HEAP32[$5 >> 2] = $3;
|
|
$1 = $3 - 1 | 0;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (($1 | 0) == (0 - $2 | 0)) {
|
|
break label$28;
|
|
}
|
|
$1 = $1 + $2 | 0;
|
|
$6 = $1 >>> 0 > 1 ? $1 : 1;
|
|
$5 = Math_imul(HEAP32[$0 + 28 >> 2], $8);
|
|
$2 = HEAP32[$0 + 72 >> 2];
|
|
$1 = 0;
|
|
while (1) {
|
|
$4 = $1 + $5 | 0;
|
|
HEAP32[($4 << 2) + $2 >> 2] = HEAP32[($3 + $4 << 2) + $2 >> 2];
|
|
$1 = $1 + 1 | 0;
|
|
if (($6 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if ($8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
$1 = 0;
|
|
if (!HEAP32[$0 + 20 >> 2] | $2 >>> 0 >= $11 >>> 0) {
|
|
break label$1;
|
|
}
|
|
$12 = HEAP32[$0 + 68 >> 2];
|
|
$7 = 0;
|
|
while (1) {
|
|
$8 = ($7 << 2) + $12 | 0;
|
|
$1 = HEAP32[$8 >> 2];
|
|
$3 = $11 - $2 >>> 1 | 0;
|
|
HEAP32[$8 >> 2] = $3;
|
|
$9 = $1 + $3 | 0;
|
|
$1 = $9 - 1 | 0;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (($1 | 0) != (0 - $2 | 0)) {
|
|
$1 = $1 + $2 | 0;
|
|
$6 = $1 >>> 0 > 1 ? $1 : 1;
|
|
$5 = Math_imul(HEAP32[$0 + 28 >> 2], $7);
|
|
$2 = HEAP32[$0 + 72 >> 2];
|
|
$1 = 0;
|
|
while (1) {
|
|
$4 = $1 + $5 | 0;
|
|
HEAP32[($4 << 2) + $2 >> 2] = HEAP32[($3 + $4 << 2) + $2 >> 2];
|
|
$1 = $1 + 1 | 0;
|
|
if (($6 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$8 >> 2] = $9;
|
|
$7 = $7 + 1 | 0;
|
|
if ($7 >>> 0 >= HEAPU32[$0 + 20 >> 2]) {
|
|
return 0;
|
|
} else {
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
HEAP32[$0 + 24 >> 2] = $11;
|
|
HEAP32[$0 + 84 >> 2] = 9;
|
|
$1 = 1;
|
|
}
|
|
return $1;
|
|
}
|
|
function dlfree($0) {
|
|
$0 = $0 | 0;
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (!$0) {
|
|
break label$2;
|
|
}
|
|
$3 = $0 - 8 | 0;
|
|
$1 = HEAP32[$0 - 4 >> 2];
|
|
$0 = $1 & -8;
|
|
$5 = $3 + $0 | 0;
|
|
label$3 : {
|
|
if ($1 & 1) {
|
|
break label$3;
|
|
}
|
|
if (!($1 & 3)) {
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$3 >> 2];
|
|
$3 = $3 - $1 | 0;
|
|
$4 = HEAP32[13236];
|
|
if ($3 >>> 0 < $4 >>> 0) {
|
|
break label$2;
|
|
}
|
|
$0 = $0 + $1 | 0;
|
|
if (HEAP32[13237] != ($3 | 0)) {
|
|
if ($1 >>> 0 <= 255) {
|
|
$7 = $1 >>> 3 | 0;
|
|
$1 = ($7 << 3) + 52968 | 0;
|
|
$6 = HEAP32[$3 + 8 >> 2];
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
if (($6 | 0) == ($2 | 0)) {
|
|
HEAP32[13232] = HEAP32[13232] & __wasm_rotl_i32(-2, $7);
|
|
break label$3;
|
|
}
|
|
HEAP32[$6 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 8 >> 2] = $6;
|
|
break label$3;
|
|
}
|
|
$7 = HEAP32[$3 + 24 >> 2];
|
|
$2 = HEAP32[$3 + 12 >> 2];
|
|
label$7 : {
|
|
if (($2 | 0) != ($3 | 0)) {
|
|
$1 = HEAP32[$3 + 8 >> 2];
|
|
HEAP32[$1 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 8 >> 2] = $1;
|
|
break label$7;
|
|
}
|
|
label$10 : {
|
|
$1 = $3 + 20 | 0;
|
|
$4 = HEAP32[$1 >> 2];
|
|
if ($4) {
|
|
break label$10;
|
|
}
|
|
$1 = $3 + 16 | 0;
|
|
$4 = HEAP32[$1 >> 2];
|
|
if ($4) {
|
|
break label$10;
|
|
}
|
|
$2 = 0;
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$6 = $1;
|
|
$2 = $4;
|
|
$1 = $2 + 20 | 0;
|
|
$4 = HEAP32[$1 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
$1 = $2 + 16 | 0;
|
|
$4 = HEAP32[$2 + 16 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$6 >> 2] = 0;
|
|
}
|
|
if (!$7) {
|
|
break label$3;
|
|
}
|
|
$4 = HEAP32[$3 + 28 >> 2];
|
|
$1 = ($4 << 2) + 53232 | 0;
|
|
label$12 : {
|
|
if (HEAP32[$1 >> 2] == ($3 | 0)) {
|
|
HEAP32[$1 >> 2] = $2;
|
|
if ($2) {
|
|
break label$12;
|
|
}
|
|
HEAP32[13233] = HEAP32[13233] & __wasm_rotl_i32(-2, $4);
|
|
break label$3;
|
|
}
|
|
HEAP32[(HEAP32[$7 + 16 >> 2] == ($3 | 0) ? 16 : 20) + $7 >> 2] = $2;
|
|
if (!$2) {
|
|
break label$3;
|
|
}
|
|
}
|
|
HEAP32[$2 + 24 >> 2] = $7;
|
|
$1 = HEAP32[$3 + 16 >> 2];
|
|
if ($1) {
|
|
HEAP32[$2 + 16 >> 2] = $1;
|
|
HEAP32[$1 + 24 >> 2] = $2;
|
|
}
|
|
$1 = HEAP32[$3 + 20 >> 2];
|
|
if (!$1) {
|
|
break label$3;
|
|
}
|
|
HEAP32[$2 + 20 >> 2] = $1;
|
|
HEAP32[$1 + 24 >> 2] = $2;
|
|
break label$3;
|
|
}
|
|
$1 = HEAP32[$5 + 4 >> 2];
|
|
if (($1 & 3) != 3) {
|
|
break label$3;
|
|
}
|
|
HEAP32[13234] = $0;
|
|
HEAP32[$5 + 4 >> 2] = $1 & -2;
|
|
break label$1;
|
|
}
|
|
if ($3 >>> 0 >= $5 >>> 0) {
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$5 + 4 >> 2];
|
|
if (!($1 & 1)) {
|
|
break label$2;
|
|
}
|
|
label$15 : {
|
|
if (!($1 & 2)) {
|
|
if (HEAP32[13238] == ($5 | 0)) {
|
|
HEAP32[13238] = $3;
|
|
$0 = HEAP32[13235] + $0 | 0;
|
|
HEAP32[13235] = $0;
|
|
HEAP32[$3 + 4 >> 2] = $0 | 1;
|
|
if (HEAP32[13237] != ($3 | 0)) {
|
|
break label$2;
|
|
}
|
|
HEAP32[13234] = 0;
|
|
HEAP32[13237] = 0;
|
|
return;
|
|
}
|
|
if (HEAP32[13237] == ($5 | 0)) {
|
|
HEAP32[13237] = $3;
|
|
$0 = HEAP32[13234] + $0 | 0;
|
|
HEAP32[13234] = $0;
|
|
break label$1;
|
|
}
|
|
$0 = ($1 & -8) + $0 | 0;
|
|
label$19 : {
|
|
if ($1 >>> 0 <= 255) {
|
|
$4 = HEAP32[$5 + 12 >> 2];
|
|
$2 = HEAP32[$5 + 8 >> 2];
|
|
$5 = $1 >>> 3 | 0;
|
|
if (($2 | 0) == ($4 | 0)) {
|
|
HEAP32[13232] = HEAP32[13232] & __wasm_rotl_i32(-2, $5);
|
|
break label$19;
|
|
}
|
|
HEAP32[$2 + 12 >> 2] = $4;
|
|
HEAP32[$4 + 8 >> 2] = $2;
|
|
break label$19;
|
|
}
|
|
$7 = HEAP32[$5 + 24 >> 2];
|
|
$2 = HEAP32[$5 + 12 >> 2];
|
|
label$24 : {
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
$1 = HEAP32[$5 + 8 >> 2];
|
|
HEAP32[$1 + 12 >> 2] = $2;
|
|
HEAP32[$2 + 8 >> 2] = $1;
|
|
break label$24;
|
|
}
|
|
label$27 : {
|
|
$1 = $5 + 20 | 0;
|
|
$4 = HEAP32[$1 >> 2];
|
|
if ($4) {
|
|
break label$27;
|
|
}
|
|
$1 = $5 + 16 | 0;
|
|
$4 = HEAP32[$1 >> 2];
|
|
if ($4) {
|
|
break label$27;
|
|
}
|
|
$2 = 0;
|
|
break label$24;
|
|
}
|
|
while (1) {
|
|
$6 = $1;
|
|
$2 = $4;
|
|
$1 = $2 + 20 | 0;
|
|
$4 = HEAP32[$1 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
$1 = $2 + 16 | 0;
|
|
$4 = HEAP32[$2 + 16 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$6 >> 2] = 0;
|
|
}
|
|
if (!$7) {
|
|
break label$19;
|
|
}
|
|
$4 = HEAP32[$5 + 28 >> 2];
|
|
$1 = ($4 << 2) + 53232 | 0;
|
|
label$29 : {
|
|
if (HEAP32[$1 >> 2] == ($5 | 0)) {
|
|
HEAP32[$1 >> 2] = $2;
|
|
if ($2) {
|
|
break label$29;
|
|
}
|
|
HEAP32[13233] = HEAP32[13233] & __wasm_rotl_i32(-2, $4);
|
|
break label$19;
|
|
}
|
|
HEAP32[(HEAP32[$7 + 16 >> 2] == ($5 | 0) ? 16 : 20) + $7 >> 2] = $2;
|
|
if (!$2) {
|
|
break label$19;
|
|
}
|
|
}
|
|
HEAP32[$2 + 24 >> 2] = $7;
|
|
$1 = HEAP32[$5 + 16 >> 2];
|
|
if ($1) {
|
|
HEAP32[$2 + 16 >> 2] = $1;
|
|
HEAP32[$1 + 24 >> 2] = $2;
|
|
}
|
|
$1 = HEAP32[$5 + 20 >> 2];
|
|
if (!$1) {
|
|
break label$19;
|
|
}
|
|
HEAP32[$2 + 20 >> 2] = $1;
|
|
HEAP32[$1 + 24 >> 2] = $2;
|
|
}
|
|
HEAP32[$3 + 4 >> 2] = $0 | 1;
|
|
HEAP32[$0 + $3 >> 2] = $0;
|
|
if (HEAP32[13237] != ($3 | 0)) {
|
|
break label$15;
|
|
}
|
|
HEAP32[13234] = $0;
|
|
return;
|
|
}
|
|
HEAP32[$5 + 4 >> 2] = $1 & -2;
|
|
HEAP32[$3 + 4 >> 2] = $0 | 1;
|
|
HEAP32[$0 + $3 >> 2] = $0;
|
|
}
|
|
if ($0 >>> 0 <= 255) {
|
|
$1 = $0 >>> 3 | 0;
|
|
$0 = ($1 << 3) + 52968 | 0;
|
|
$1 = 1 << $1;
|
|
$4 = HEAP32[13232];
|
|
label$33 : {
|
|
if (!($1 & $4)) {
|
|
HEAP32[13232] = $1 | $4;
|
|
$1 = $0;
|
|
break label$33;
|
|
}
|
|
$1 = HEAP32[$0 + 8 >> 2];
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $3;
|
|
HEAP32[$1 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 12 >> 2] = $0;
|
|
HEAP32[$3 + 8 >> 2] = $1;
|
|
return;
|
|
}
|
|
$1 = 31;
|
|
HEAP32[$3 + 16 >> 2] = 0;
|
|
HEAP32[$3 + 20 >> 2] = 0;
|
|
if ($0 >>> 0 <= 16777215) {
|
|
$1 = $0 >>> 8 | 0;
|
|
$2 = $1;
|
|
$1 = $1 + 1048320 >>> 16 & 8;
|
|
$4 = $2 << $1;
|
|
$2 = $4;
|
|
$4 = $4 + 520192 >>> 16 & 4;
|
|
$2 = $2 << $4;
|
|
$6 = $2;
|
|
$2 = $2 + 245760 >>> 16 & 2;
|
|
$1 = ($6 << $2 >>> 15 | 0) - ($1 | $4 | $2) | 0;
|
|
$1 = ($1 << 1 | $0 >>> $1 + 21 & 1) + 28 | 0;
|
|
}
|
|
HEAP32[$3 + 28 >> 2] = $1;
|
|
$4 = ($1 << 2) + 53232 | 0;
|
|
label$36 : {
|
|
label$37 : {
|
|
$2 = HEAP32[13233];
|
|
$5 = 1 << $1;
|
|
label$38 : {
|
|
if (!($2 & $5)) {
|
|
HEAP32[13233] = $2 | $5;
|
|
HEAP32[$4 >> 2] = $3;
|
|
break label$38;
|
|
}
|
|
$1 = $0 << (($1 | 0) == 31 ? 0 : 25 - ($1 >>> 1 | 0) | 0);
|
|
$2 = HEAP32[$4 >> 2];
|
|
while (1) {
|
|
$4 = $2;
|
|
if ((HEAP32[$2 + 4 >> 2] & -8) == ($0 | 0)) {
|
|
break label$37;
|
|
}
|
|
$2 = $1 >>> 29 | 0;
|
|
$1 = $1 << 1;
|
|
$6 = ($2 & 4) + $4 | 0;
|
|
$5 = $6 + 16 | 0;
|
|
$2 = HEAP32[$5 >> 2];
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$6 + 16 >> 2] = $3;
|
|
}
|
|
HEAP32[$3 + 24 >> 2] = $4;
|
|
HEAP32[$3 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $3;
|
|
break label$36;
|
|
}
|
|
$0 = HEAP32[$4 + 8 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $3;
|
|
HEAP32[$4 + 8 >> 2] = $3;
|
|
HEAP32[$3 + 24 >> 2] = 0;
|
|
HEAP32[$3 + 12 >> 2] = $4;
|
|
HEAP32[$3 + 8 >> 2] = $0;
|
|
}
|
|
$3 = HEAP32[13240] - 1 | 0;
|
|
HEAP32[13240] = $3 ? $3 : -1;
|
|
}
|
|
return;
|
|
}
|
|
HEAP32[$3 + 4 >> 2] = $0 | 1;
|
|
HEAP32[$0 + $3 >> 2] = $0;
|
|
}
|
|
function dispose_chunk($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
$5 = $0 + $1 | 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
$2 = HEAP32[$0 + 4 >> 2];
|
|
if ($2 & 1) {
|
|
break label$2;
|
|
}
|
|
if (!($2 & 3)) {
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$0 >> 2];
|
|
$1 = $2 + $1 | 0;
|
|
$0 = $0 - $2 | 0;
|
|
if (($0 | 0) != HEAP32[13237]) {
|
|
if ($2 >>> 0 <= 255) {
|
|
$6 = $2 >>> 3 | 0;
|
|
$2 = ($6 << 3) + 52968 | 0;
|
|
$3 = HEAP32[$0 + 8 >> 2];
|
|
$4 = HEAP32[$0 + 12 >> 2];
|
|
if (($4 | 0) == ($3 | 0)) {
|
|
HEAP32[13232] = HEAP32[13232] & __wasm_rotl_i32(-2, $6);
|
|
break label$2;
|
|
}
|
|
HEAP32[$3 + 12 >> 2] = $4;
|
|
HEAP32[$4 + 8 >> 2] = $3;
|
|
break label$2;
|
|
}
|
|
$6 = HEAP32[$0 + 24 >> 2];
|
|
$3 = HEAP32[$0 + 12 >> 2];
|
|
label$6 : {
|
|
if (($3 | 0) != ($0 | 0)) {
|
|
$2 = HEAP32[$0 + 8 >> 2];
|
|
HEAP32[$2 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $2;
|
|
break label$6;
|
|
}
|
|
label$9 : {
|
|
$2 = $0 + 20 | 0;
|
|
$4 = HEAP32[$2 >> 2];
|
|
if ($4) {
|
|
break label$9;
|
|
}
|
|
$2 = $0 + 16 | 0;
|
|
$4 = HEAP32[$2 >> 2];
|
|
if ($4) {
|
|
break label$9;
|
|
}
|
|
$3 = 0;
|
|
break label$6;
|
|
}
|
|
while (1) {
|
|
$7 = $2;
|
|
$3 = $4;
|
|
$2 = $3 + 20 | 0;
|
|
$4 = HEAP32[$2 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
$2 = $3 + 16 | 0;
|
|
$4 = HEAP32[$3 + 16 >> 2];
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$7 >> 2] = 0;
|
|
}
|
|
if (!$6) {
|
|
break label$2;
|
|
}
|
|
$4 = HEAP32[$0 + 28 >> 2];
|
|
$2 = ($4 << 2) + 53232 | 0;
|
|
label$11 : {
|
|
if (HEAP32[$2 >> 2] == ($0 | 0)) {
|
|
HEAP32[$2 >> 2] = $3;
|
|
if ($3) {
|
|
break label$11;
|
|
}
|
|
HEAP32[13233] = HEAP32[13233] & __wasm_rotl_i32(-2, $4);
|
|
break label$2;
|
|
}
|
|
HEAP32[(HEAP32[$6 + 16 >> 2] == ($0 | 0) ? 16 : 20) + $6 >> 2] = $3;
|
|
if (!$3) {
|
|
break label$2;
|
|
}
|
|
}
|
|
HEAP32[$3 + 24 >> 2] = $6;
|
|
$2 = HEAP32[$0 + 16 >> 2];
|
|
if ($2) {
|
|
HEAP32[$3 + 16 >> 2] = $2;
|
|
HEAP32[$2 + 24 >> 2] = $3;
|
|
}
|
|
$2 = HEAP32[$0 + 20 >> 2];
|
|
if (!$2) {
|
|
break label$2;
|
|
}
|
|
HEAP32[$3 + 20 >> 2] = $2;
|
|
HEAP32[$2 + 24 >> 2] = $3;
|
|
break label$2;
|
|
}
|
|
$2 = HEAP32[$5 + 4 >> 2];
|
|
if (($2 & 3) != 3) {
|
|
break label$2;
|
|
}
|
|
HEAP32[13234] = $1;
|
|
HEAP32[$5 + 4 >> 2] = $2 & -2;
|
|
HEAP32[$0 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$5 >> 2] = $1;
|
|
return;
|
|
}
|
|
$2 = HEAP32[$5 + 4 >> 2];
|
|
label$14 : {
|
|
if (!($2 & 2)) {
|
|
if (HEAP32[13238] == ($5 | 0)) {
|
|
HEAP32[13238] = $0;
|
|
$1 = HEAP32[13235] + $1 | 0;
|
|
HEAP32[13235] = $1;
|
|
HEAP32[$0 + 4 >> 2] = $1 | 1;
|
|
if (HEAP32[13237] != ($0 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[13234] = 0;
|
|
HEAP32[13237] = 0;
|
|
return;
|
|
}
|
|
if (HEAP32[13237] == ($5 | 0)) {
|
|
HEAP32[13237] = $0;
|
|
$1 = HEAP32[13234] + $1 | 0;
|
|
HEAP32[13234] = $1;
|
|
HEAP32[$0 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$0 + $1 >> 2] = $1;
|
|
return;
|
|
}
|
|
$1 = ($2 & -8) + $1 | 0;
|
|
label$18 : {
|
|
if ($2 >>> 0 <= 255) {
|
|
$4 = HEAP32[$5 + 12 >> 2];
|
|
$3 = HEAP32[$5 + 8 >> 2];
|
|
$5 = $2 >>> 3 | 0;
|
|
if (($3 | 0) == ($4 | 0)) {
|
|
HEAP32[13232] = HEAP32[13232] & __wasm_rotl_i32(-2, $5);
|
|
break label$18;
|
|
}
|
|
HEAP32[$3 + 12 >> 2] = $4;
|
|
HEAP32[$4 + 8 >> 2] = $3;
|
|
break label$18;
|
|
}
|
|
$6 = HEAP32[$5 + 24 >> 2];
|
|
$3 = HEAP32[$5 + 12 >> 2];
|
|
label$21 : {
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
$2 = HEAP32[$5 + 8 >> 2];
|
|
HEAP32[$2 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $2;
|
|
break label$21;
|
|
}
|
|
label$24 : {
|
|
$4 = $5 + 20 | 0;
|
|
$2 = HEAP32[$4 >> 2];
|
|
if ($2) {
|
|
break label$24;
|
|
}
|
|
$4 = $5 + 16 | 0;
|
|
$2 = HEAP32[$4 >> 2];
|
|
if ($2) {
|
|
break label$24;
|
|
}
|
|
$3 = 0;
|
|
break label$21;
|
|
}
|
|
while (1) {
|
|
$7 = $4;
|
|
$3 = $2;
|
|
$4 = $2 + 20 | 0;
|
|
$2 = HEAP32[$4 >> 2];
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
$4 = $3 + 16 | 0;
|
|
$2 = HEAP32[$3 + 16 >> 2];
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$7 >> 2] = 0;
|
|
}
|
|
if (!$6) {
|
|
break label$18;
|
|
}
|
|
$4 = HEAP32[$5 + 28 >> 2];
|
|
$2 = ($4 << 2) + 53232 | 0;
|
|
label$26 : {
|
|
if (HEAP32[$2 >> 2] == ($5 | 0)) {
|
|
HEAP32[$2 >> 2] = $3;
|
|
if ($3) {
|
|
break label$26;
|
|
}
|
|
HEAP32[13233] = HEAP32[13233] & __wasm_rotl_i32(-2, $4);
|
|
break label$18;
|
|
}
|
|
HEAP32[(HEAP32[$6 + 16 >> 2] == ($5 | 0) ? 16 : 20) + $6 >> 2] = $3;
|
|
if (!$3) {
|
|
break label$18;
|
|
}
|
|
}
|
|
HEAP32[$3 + 24 >> 2] = $6;
|
|
$2 = HEAP32[$5 + 16 >> 2];
|
|
if ($2) {
|
|
HEAP32[$3 + 16 >> 2] = $2;
|
|
HEAP32[$2 + 24 >> 2] = $3;
|
|
}
|
|
$2 = HEAP32[$5 + 20 >> 2];
|
|
if (!$2) {
|
|
break label$18;
|
|
}
|
|
HEAP32[$3 + 20 >> 2] = $2;
|
|
HEAP32[$2 + 24 >> 2] = $3;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$0 + $1 >> 2] = $1;
|
|
if (HEAP32[13237] != ($0 | 0)) {
|
|
break label$14;
|
|
}
|
|
HEAP32[13234] = $1;
|
|
return;
|
|
}
|
|
HEAP32[$5 + 4 >> 2] = $2 & -2;
|
|
HEAP32[$0 + 4 >> 2] = $1 | 1;
|
|
HEAP32[$0 + $1 >> 2] = $1;
|
|
}
|
|
if ($1 >>> 0 <= 255) {
|
|
$2 = $1 >>> 3 | 0;
|
|
$1 = ($2 << 3) + 52968 | 0;
|
|
$2 = 1 << $2;
|
|
$4 = HEAP32[13232];
|
|
label$30 : {
|
|
if (!($2 & $4)) {
|
|
HEAP32[13232] = $2 | $4;
|
|
$2 = $1;
|
|
break label$30;
|
|
}
|
|
$2 = HEAP32[$1 + 8 >> 2];
|
|
}
|
|
HEAP32[$1 + 8 >> 2] = $0;
|
|
HEAP32[$2 + 12 >> 2] = $0;
|
|
HEAP32[$0 + 12 >> 2] = $1;
|
|
HEAP32[$0 + 8 >> 2] = $2;
|
|
return;
|
|
}
|
|
$2 = 31;
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
HEAP32[$0 + 20 >> 2] = 0;
|
|
if ($1 >>> 0 <= 16777215) {
|
|
$2 = $1 >>> 8 | 0;
|
|
$3 = $2;
|
|
$2 = $2 + 1048320 >>> 16 & 8;
|
|
$4 = $3 << $2;
|
|
$3 = $4;
|
|
$4 = $4 + 520192 >>> 16 & 4;
|
|
$3 = $3 << $4;
|
|
$7 = $3;
|
|
$3 = $3 + 245760 >>> 16 & 2;
|
|
$2 = ($7 << $3 >>> 15 | 0) - ($2 | $4 | $3) | 0;
|
|
$2 = ($2 << 1 | $1 >>> $2 + 21 & 1) + 28 | 0;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
$4 = ($2 << 2) + 53232 | 0;
|
|
label$33 : {
|
|
$3 = HEAP32[13233];
|
|
$5 = 1 << $2;
|
|
label$34 : {
|
|
if (!($3 & $5)) {
|
|
HEAP32[13233] = $3 | $5;
|
|
HEAP32[$4 >> 2] = $0;
|
|
break label$34;
|
|
}
|
|
$2 = $1 << (($2 | 0) == 31 ? 0 : 25 - ($2 >>> 1 | 0) | 0);
|
|
$3 = HEAP32[$4 >> 2];
|
|
while (1) {
|
|
$4 = $3;
|
|
if ((HEAP32[$3 + 4 >> 2] & -8) == ($1 | 0)) {
|
|
break label$33;
|
|
}
|
|
$3 = $2 >>> 29 | 0;
|
|
$2 = $2 << 1;
|
|
$7 = ($3 & 4) + $4 | 0;
|
|
$5 = $7 + 16 | 0;
|
|
$3 = HEAP32[$5 >> 2];
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$7 + 16 >> 2] = $0;
|
|
}
|
|
HEAP32[$0 + 24 >> 2] = $4;
|
|
HEAP32[$0 + 12 >> 2] = $0;
|
|
HEAP32[$0 + 8 >> 2] = $0;
|
|
return;
|
|
}
|
|
$1 = HEAP32[$4 + 8 >> 2];
|
|
HEAP32[$1 + 12 >> 2] = $0;
|
|
HEAP32[$4 + 8 >> 2] = $0;
|
|
HEAP32[$0 + 24 >> 2] = 0;
|
|
HEAP32[$0 + 12 >> 2] = $4;
|
|
HEAP32[$0 + 8 >> 2] = $1;
|
|
}
|
|
}
|
|
function tf_analysis($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = Math_fround(0), $24 = 0, $25 = 0, $26 = 0, $27 = Math_fround(0), $28 = 0, $29 = 0, $30 = Math_fround(0), $31 = 0, $32 = 0, $33 = 0, $34 = Math_fround(0);
|
|
$11 = __stack_pointer;
|
|
$28 = $11;
|
|
$20 = 1;
|
|
$12 = ($1 << 2) + 15 & -16;
|
|
$21 = $11 - $12 | 0;
|
|
$13 = $21;
|
|
__stack_pointer = $13;
|
|
$11 = HEAP32[$0 + 32 >> 2];
|
|
$24 = $1 - 1 | 0;
|
|
$14 = (HEAP16[$11 + ($1 << 1) >> 1] - HEAP16[($24 << 1) + $11 >> 1] << $7 << 2) + 15 & -16;
|
|
$22 = $13 - $14 | 0;
|
|
$13 = $22;
|
|
__stack_pointer = $13;
|
|
$29 = $13 - $14 | 0;
|
|
$13 = $29;
|
|
__stack_pointer = $13;
|
|
$25 = $13 - $12 | 0;
|
|
$13 = $25;
|
|
__stack_pointer = $13;
|
|
$26 = $13 - $12 | 0;
|
|
__stack_pointer = $26;
|
|
if (($1 | 0) >= 1) {
|
|
$27 = Math_fround(Math_fround(Math_max(Math_fround(Math_fround(.5) - $8), Math_fround(-.25))) * Math_fround(.03999999910593033));
|
|
$30 = Math_fround($27 * Math_fround(($2 ? $7 : 0) | 0));
|
|
$31 = 1 << $7;
|
|
$32 = Math_imul($6, $9);
|
|
$33 = 0 - ($7 << 1) | 0;
|
|
$34 = Math_fround($27 * Math_fround($7 + 1 | 0));
|
|
while (1) {
|
|
$12 = HEAP16[($16 << 1) + $11 >> 1];
|
|
$6 = (($12 << $7) + $32 << 2) + $5 | 0;
|
|
$18 = $16 + 1 | 0;
|
|
$9 = HEAP16[($18 << 1) + $11 >> 1] - $12 | 0;
|
|
$12 = $9 << $7;
|
|
$14 = $12 << 2;
|
|
$13 = memcpy($22, $6, $14);
|
|
$8 = Math_fround(0);
|
|
$11 = 0;
|
|
$15 = ($12 | 0) < 1;
|
|
if (!$15) {
|
|
while (1) {
|
|
$8 = Math_fround($8 + Math_fround(Math_abs(HEAPF32[($11 << 2) + $13 >> 2])));
|
|
$11 = $11 + 1 | 0;
|
|
if (($12 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$23 = Math_fround($8 + Math_fround($30 * $8));
|
|
$11 = 0;
|
|
$6 = 0;
|
|
label$5 : {
|
|
if (!$2) {
|
|
break label$5;
|
|
}
|
|
$6 = 0;
|
|
if (($9 | 0) == 1) {
|
|
break label$5;
|
|
}
|
|
$6 = memcpy($29, $13, $14);
|
|
haar1($6, $12 >> $7, $31);
|
|
$14 = 0;
|
|
$8 = Math_fround(0);
|
|
if (!$15) {
|
|
while (1) {
|
|
$8 = Math_fround($8 + Math_fround(Math_abs(HEAPF32[($14 << 2) + $6 >> 2])));
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = Math_fround($8 + Math_fround($34 * $8));
|
|
$6 = 0;
|
|
if ($23 > $8 ^ 1) {
|
|
break label$5;
|
|
}
|
|
$23 = $8;
|
|
$6 = -1;
|
|
}
|
|
$19 = ($9 | 0) != 1;
|
|
$17 = ($19 & !$2) + $7 | 0;
|
|
if (($17 | 0) >= 1) {
|
|
while (1) {
|
|
haar1($13, $12 >> $11, 1 << $11);
|
|
$14 = $11 + 1 | 0;
|
|
$9 = $2 ? ($11 ^ -1) + $7 | 0 : $14;
|
|
$11 = 0;
|
|
$8 = Math_fround(0);
|
|
if (!$15) {
|
|
while (1) {
|
|
$8 = Math_fround($8 + Math_fround(Math_abs(HEAPF32[($11 << 2) + $13 >> 2])));
|
|
$11 = $11 + 1 | 0;
|
|
if (($12 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = Math_fround($8 + Math_fround(Math_fround($27 * Math_fround($9 | 0)) * $8));
|
|
$11 = $23 > $8;
|
|
$23 = $11 ? $8 : $23;
|
|
$6 = $11 ? $14 : $6;
|
|
$11 = $14;
|
|
if (($17 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = ($16 << 2) + $21 | 0;
|
|
$11 = $6 << 1;
|
|
$11 = $2 ? $11 : 0 - $11 | 0;
|
|
HEAP32[$12 >> 2] = $11;
|
|
if (!((($11 | 0) != ($33 | 0) ? $11 : 0) | $19)) {
|
|
HEAP32[$12 >> 2] = $11 - 1;
|
|
}
|
|
if (($1 | 0) != ($18 | 0)) {
|
|
$11 = HEAP32[$0 + 32 >> 2];
|
|
$16 = $18;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$18 = HEAP32[$21 >> 2];
|
|
}
|
|
$0 = $2 << 2;
|
|
$16 = ($7 << 3) + 1744 | 0;
|
|
$15 = HEAP8[$0 + $16 | 0] << 1;
|
|
$11 = $18 - $15 | 0;
|
|
$5 = $11;
|
|
$19 = HEAP32[$10 >> 2];
|
|
$11 = $11 >> 31;
|
|
$11 = Math_imul($19, $11 ^ $11 + $5);
|
|
$17 = HEAP8[($0 | 1) + $16 | 0] << 1;
|
|
$12 = $18 - $17 | 0;
|
|
$6 = $12;
|
|
$5 = $2 ? 0 : $4;
|
|
$12 = $12 >> 31;
|
|
$12 = $5 + Math_imul($12 ^ $12 + $6, $19) | 0;
|
|
label$14 : {
|
|
if (($1 | 0) <= 1) {
|
|
$6 = $12;
|
|
break label$14;
|
|
}
|
|
while (1) {
|
|
$13 = $4 + $11 | 0;
|
|
$14 = $20 << 2;
|
|
$6 = HEAP32[$21 + $14 >> 2];
|
|
$9 = $6 - $15 | 0;
|
|
$22 = $9;
|
|
$14 = HEAP32[$10 + $14 >> 2];
|
|
$9 = $9 >> 31;
|
|
$22 = Math_imul($14, $9 ^ $9 + $22);
|
|
$9 = $4 + $12 | 0;
|
|
$11 = $22 + (($9 | 0) > ($11 | 0) ? $11 : $9) | 0;
|
|
$6 = $6 - $17 | 0;
|
|
$9 = $6;
|
|
$6 = $6 >> 31;
|
|
$6 = Math_imul($6 ^ $6 + $9, $14) + (($12 | 0) > ($13 | 0) ? $13 : $12) | 0;
|
|
$12 = $6;
|
|
$20 = $20 + 1 | 0;
|
|
if (($20 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$14 = 1;
|
|
$17 = HEAP8[($0 | 2) + $16 | 0] << 1;
|
|
$12 = $18 - $17 | 0;
|
|
$9 = $12;
|
|
$12 = $12 >> 31;
|
|
$12 = Math_imul($12 ^ $12 + $9, $19);
|
|
$16 = HEAP8[($0 | 3) + $16 | 0] << 1;
|
|
$13 = $18 - $16 | 0;
|
|
$9 = $13;
|
|
$13 = $13 >> 31;
|
|
$13 = Math_imul($13 ^ $13 + $9, $19) + $5 | 0;
|
|
$20 = ($6 | 0) > ($11 | 0) ? $11 : $6;
|
|
label$17 : {
|
|
if (($1 | 0) <= 1) {
|
|
$11 = $13;
|
|
break label$17;
|
|
}
|
|
while (1) {
|
|
$11 = $4 + $12 | 0;
|
|
$6 = $14 << 2;
|
|
$9 = HEAP32[$21 + $6 >> 2];
|
|
$15 = $9 - $17 | 0;
|
|
$5 = $15;
|
|
$6 = HEAP32[$6 + $10 >> 2];
|
|
$15 = $15 >> 31;
|
|
$5 = Math_imul($6, $15 ^ $15 + $5);
|
|
$15 = $4 + $13 | 0;
|
|
$12 = $5 + (($12 | 0) < ($15 | 0) ? $12 : $15) | 0;
|
|
$9 = $9 - $16 | 0;
|
|
$5 = $9;
|
|
$9 = $9 >> 31;
|
|
$11 = Math_imul($9 ^ $9 + $5, $6) + (($11 | 0) < ($13 | 0) ? $11 : $13) | 0;
|
|
$13 = $11;
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$14 = 1;
|
|
$16 = ($2 | 0) != 0 & ((($11 | 0) > ($12 | 0) ? $12 : $11) | 0) < ($20 | 0);
|
|
$12 = ($16 ? 2 : 0) | $0;
|
|
$13 = ($7 << 3) + 1744 | 0;
|
|
$15 = HEAP8[$12 + $13 | 0] << 1;
|
|
$11 = $18 - $15 | 0;
|
|
$0 = $11;
|
|
$11 = $11 >> 31;
|
|
$11 = Math_imul($11 ^ $11 + $0, $19);
|
|
$17 = HEAP8[($12 | 1) + $13 | 0] << 1;
|
|
$12 = $18 - $17 | 0;
|
|
$0 = $12;
|
|
$12 = $12 >> 31;
|
|
$12 = Math_imul($12 ^ $12 + $0, $19) + ($2 ? 0 : $4) | 0;
|
|
if (($1 | 0) <= 1) {
|
|
HEAP32[($24 << 2) + $3 >> 2] = ($11 | 0) >= ($12 | 0);
|
|
__stack_pointer = $28;
|
|
return $16;
|
|
}
|
|
while (1) {
|
|
$13 = $14 << 2;
|
|
$6 = $4 + $12 | 0;
|
|
HEAP32[$25 + $13 >> 2] = ($11 | 0) >= ($6 | 0);
|
|
$9 = $4 + $11 | 0;
|
|
HEAP32[$13 + $26 >> 2] = ($12 | 0) <= ($9 | 0);
|
|
$7 = HEAP32[$13 + $21 >> 2];
|
|
$2 = $7 - $17 | 0;
|
|
$0 = $2;
|
|
$13 = HEAP32[$10 + $13 >> 2];
|
|
$2 = $2 >> 31;
|
|
$12 = Math_imul($13, $2 ^ $2 + $0) + (($9 | 0) < ($12 | 0) ? $9 : $12) | 0;
|
|
$9 = $7 - $15 | 0;
|
|
$0 = $9;
|
|
$9 = $9 >> 31;
|
|
$11 = Math_imul($9 ^ $9 + $0, $13) + (($6 | 0) > ($11 | 0) ? $11 : $6) | 0;
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = ($11 | 0) >= ($12 | 0);
|
|
HEAP32[($24 << 2) + $3 >> 2] = $12;
|
|
if (($1 | 0) >= 2) {
|
|
$11 = $1 - 2 | 0;
|
|
while (1) {
|
|
$13 = $11 << 2;
|
|
$12 = HEAP32[($13 + (($12 | 0) == 1 ? $26 : $25) | 0) + 4 >> 2];
|
|
HEAP32[$3 + $13 >> 2] = $12;
|
|
$13 = ($11 | 0) > 0;
|
|
$11 = $11 - 1 | 0;
|
|
if ($13) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $28;
|
|
return $16;
|
|
}
|
|
function silk_burg_modified_FLP($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = Math_fround(0), $27 = Math_fround(0), $28 = Math_fround(0), $29 = 0;
|
|
$7 = __stack_pointer - 992 | 0;
|
|
__stack_pointer = $7;
|
|
$6 = Math_imul($3, $4);
|
|
if (($6 | 0) < 385) {
|
|
$19 = silk_energy_FLP($1, $6);
|
|
memset($7 + 800 | 0, 0, 192);
|
|
if (($4 | 0) >= 1) {
|
|
while (1) {
|
|
$6 = 1;
|
|
if (($5 | 0) >= 1) {
|
|
$9 = (Math_imul($3, $14) << 2) + $1 | 0;
|
|
while (1) {
|
|
$13 = ($6 << 3) + $7 | 0;
|
|
$11 = $13 + 792 | 0;
|
|
HEAPF64[$11 >> 3] = silk_inner_product_FLP($9, ($6 << 2) + $9 | 0, $3 - $6 | 0) + HEAPF64[$13 + 792 >> 3];
|
|
$11 = ($5 | 0) != ($6 | 0);
|
|
$6 = $6 + 1 | 0;
|
|
if ($11) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memcpy($7 + 608 | 0, $7 + 800 | 0, 192);
|
|
$24 = $19 * 9999999747378752e-21;
|
|
$10 = $19 + $24 + 9.999999717180685e-10;
|
|
HEAPF64[$7 + 192 >> 3] = $10;
|
|
HEAPF64[$7 + 400 >> 3] = $10;
|
|
label$6 : {
|
|
label$7 : {
|
|
if (($5 | 0) < 1) {
|
|
$12 = 1;
|
|
break label$7;
|
|
}
|
|
$25 = +$2;
|
|
$11 = 0;
|
|
$21 = 2;
|
|
$20 = 1;
|
|
$22 = 1;
|
|
while (1) {
|
|
if (($4 | 0) >= 1) {
|
|
$17 = $3 - $11 | 0;
|
|
$18 = $17 - 1 | 0;
|
|
$16 = 0;
|
|
while (1) {
|
|
$9 = (Math_imul($3, $16) << 2) + $1 | 0;
|
|
$26 = HEAPF32[$9 + ($18 << 2) >> 2];
|
|
$8 = +$26;
|
|
$27 = HEAPF32[($11 << 2) + $9 >> 2];
|
|
$10 = +$27;
|
|
$6 = 0;
|
|
if ($11) {
|
|
while (1) {
|
|
$14 = $6 << 3;
|
|
$13 = $14 + ($7 + 800 | 0) | 0;
|
|
$2 = HEAPF32[(($6 ^ -1) + $11 << 2) + $9 >> 2];
|
|
HEAPF64[$13 >> 3] = HEAPF64[$13 >> 3] - +Math_fround($27 * $2);
|
|
$13 = ($7 + 608 | 0) + $14 | 0;
|
|
$28 = HEAPF32[($6 + $17 << 2) + $9 >> 2];
|
|
HEAPF64[$13 >> 3] = HEAPF64[$13 >> 3] - +Math_fround($26 * $28);
|
|
$12 = HEAPF64[$7 + $14 >> 3];
|
|
$10 = $10 + $12 * +$2;
|
|
$8 = $8 + $12 * +$28;
|
|
$6 = $6 + 1 | 0;
|
|
if (($11 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = 0;
|
|
while (1) {
|
|
$14 = $6 << 3;
|
|
$13 = $14 + ($7 + 400 | 0) | 0;
|
|
HEAPF64[$13 >> 3] = HEAPF64[$13 >> 3] - $10 * +HEAPF32[($11 - $6 << 2) + $9 >> 2];
|
|
$14 = ($7 + 192 | 0) + $14 | 0;
|
|
HEAPF64[$14 >> 3] = HEAPF64[$14 >> 3] - $8 * +HEAPF32[($6 + $18 << 2) + $9 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($20 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$16 = $16 + 1 | 0;
|
|
if (($16 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$18 = $11 << 3;
|
|
$10 = HEAPF64[$18 + ($7 + 608 | 0) >> 3];
|
|
$8 = HEAPF64[($7 + 800 | 0) + $18 >> 3];
|
|
$6 = 0;
|
|
if ($11) {
|
|
while (1) {
|
|
$12 = HEAPF64[($6 << 3) + $7 >> 3];
|
|
$9 = ($6 ^ -1) + $11 << 3;
|
|
$10 = $10 + $12 * HEAPF64[$9 + ($7 + 800 | 0) >> 3];
|
|
$8 = $8 + $12 * HEAPF64[($7 + 608 | 0) + $9 >> 3];
|
|
$6 = $6 + 1 | 0;
|
|
if (($11 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = $11 + 1 | 0;
|
|
$6 = $13 << 3;
|
|
HEAPF64[$6 + ($7 + 400 | 0) >> 3] = $8;
|
|
$17 = ($7 + 192 | 0) + $6 | 0;
|
|
HEAPF64[$17 >> 3] = $10;
|
|
$6 = 0;
|
|
$12 = HEAPF64[$7 + 192 >> 3];
|
|
$23 = HEAPF64[$7 + 400 >> 3];
|
|
$15 = $23;
|
|
if ($11) {
|
|
while (1) {
|
|
$8 = HEAPF64[($6 << 3) + $7 >> 3];
|
|
$9 = $6 + 1 | 0;
|
|
$14 = $9 << 3;
|
|
$15 = $15 + $8 * HEAPF64[$14 + ($7 + 400 | 0) >> 3];
|
|
$12 = $12 + $8 * HEAPF64[($7 + 192 | 0) + $14 >> 3];
|
|
$10 = $10 + $8 * HEAPF64[($7 + 192 | 0) + ($11 - $6 << 3) >> 3];
|
|
$6 = $9;
|
|
if (($11 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$16 = 1;
|
|
$8 = $10 * -2 / ($15 + $12);
|
|
$15 = $22 * (1 - $8 * $8);
|
|
if (!($25 >= $15 ^ 1)) {
|
|
$16 = 0;
|
|
$15 = $25;
|
|
$8 = Math_sqrt(1 - $15 / $22);
|
|
$8 = $10 > 0 ? -$8 : $8;
|
|
}
|
|
if ($13 & 2147483646) {
|
|
$14 = $20 >>> 1 | 0;
|
|
$6 = 0;
|
|
while (1) {
|
|
$9 = ($6 << 3) + $7 | 0;
|
|
$29 = $9;
|
|
$10 = HEAPF64[$9 >> 3];
|
|
$9 = (($6 ^ -1) + $11 << 3) + $7 | 0;
|
|
$12 = HEAPF64[$9 >> 3];
|
|
HEAPF64[$29 >> 3] = $10 + $8 * $12;
|
|
HEAPF64[$9 >> 3] = $12 + $8 * $10;
|
|
$6 = $6 + 1 | 0;
|
|
if (($14 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[$7 + $18 >> 3] = $8;
|
|
label$22 : {
|
|
if ($16) {
|
|
$10 = HEAPF64[$17 >> 3];
|
|
HEAPF64[$17 >> 3] = $10 + $8 * $23;
|
|
HEAPF64[$7 + 400 >> 3] = $23 + $8 * $10;
|
|
$6 = 1;
|
|
while (1) {
|
|
$9 = ($7 + 192 | 0) + ($13 - $6 << 3) | 0;
|
|
$11 = $9;
|
|
$10 = HEAPF64[$9 >> 3];
|
|
$9 = ($7 + 400 | 0) + ($6 << 3) | 0;
|
|
$12 = HEAPF64[$9 >> 3];
|
|
HEAPF64[$11 >> 3] = $10 + $8 * $12;
|
|
HEAPF64[$9 >> 3] = $12 + $8 * $10;
|
|
$6 = $6 + 1 | 0;
|
|
if (($21 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$22;
|
|
}
|
|
if (($5 | 0) > ($13 | 0)) {
|
|
memset(($13 << 3) + $7 | 0, 0, $5 - $13 << 3);
|
|
}
|
|
$6 = 0;
|
|
while (1) {
|
|
HEAPF32[($6 << 2) + $0 >> 2] = -Math_fround(HEAPF64[($6 << 3) + $7 >> 3]);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = 0;
|
|
if (($4 | 0) > 0) {
|
|
while (1) {
|
|
$19 = $19 - silk_energy_FLP((Math_imul($3, $6) << 2) + $1 | 0, $5);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $15 * $19;
|
|
break label$6;
|
|
}
|
|
$21 = $21 + 1 | 0;
|
|
$20 = $20 + 1 | 0;
|
|
$22 = $15;
|
|
$11 = $13;
|
|
if (($11 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$12 = 1;
|
|
$10 = HEAPF64[$7 + 400 >> 3];
|
|
if (($5 | 0) < 1) {
|
|
break label$7;
|
|
}
|
|
$6 = 0;
|
|
while (1) {
|
|
$9 = $6 + 1 | 0;
|
|
$15 = HEAPF64[($7 + 400 | 0) + ($9 << 3) >> 3];
|
|
$8 = HEAPF64[($6 << 3) + $7 >> 3];
|
|
HEAPF32[($6 << 2) + $0 >> 2] = -Math_fround($8);
|
|
$10 = $10 + $8 * $15;
|
|
$12 = $12 + $8 * $8;
|
|
$6 = $9;
|
|
if (($6 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $10 - $24 * $12;
|
|
}
|
|
__stack_pointer = $7 + 992 | 0;
|
|
return Math_fround($8);
|
|
}
|
|
celt_fatal(16463, 16523, 55);
|
|
abort();
|
|
}
|
|
function quant_coarse_energy($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) {
|
|
var $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = Math_fround(0), $24 = 0, $25 = 0, $26 = 0, $27 = Math_fround(0), $28 = 0, $29 = 0, $30 = Math_fround(0), $31 = 0, $32 = 0, $33 = 0;
|
|
$25 = __stack_pointer - 96 | 0;
|
|
$21 = $25;
|
|
__stack_pointer = $21;
|
|
$26 = 1;
|
|
label$1 : {
|
|
if ($12) {
|
|
break label$1;
|
|
}
|
|
$26 = 0;
|
|
if ($14) {
|
|
break label$1;
|
|
}
|
|
$12 = Math_imul($2 - $1 | 0, $9);
|
|
if (HEAPF32[$13 >> 2] > Math_fround($12 << 1) ^ 1) {
|
|
break label$1;
|
|
}
|
|
$26 = ($11 | 0) > ($12 | 0);
|
|
}
|
|
$30 = Math_fround(Math_fround(Math_fround(HEAPF32[$13 >> 2] * Math_fround($6 >>> 0)) * Math_fround($15 | 0)) / Math_fround($9 << 9));
|
|
$18 = ($9 | 0) > 1 ? $9 : 1;
|
|
$22 = HEAP32[$0 + 8 >> 2];
|
|
while (1) {
|
|
if (($1 | 0) < ($3 | 0)) {
|
|
$24 = Math_imul($20, $22);
|
|
$12 = $1;
|
|
while (1) {
|
|
$15 = $12 + $24 << 2;
|
|
$23 = Math_fround(HEAPF32[$15 + $4 >> 2] - HEAPF32[$5 + $15 >> 2]);
|
|
$27 = Math_fround($27 + Math_fround($23 * $23));
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$20 = $20 + 1 | 0;
|
|
if (($18 | 0) != ($20 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$24 = HEAP32[$8 + 20 >> 2];
|
|
$20 = HEAP32[$8 + 28 >> 2];
|
|
$19 = $8;
|
|
$18 = HEAP32[$19 + 16 >> 2];
|
|
$17 = HEAP32[$19 + 20 >> 2];
|
|
$3 = $18;
|
|
$18 = $21;
|
|
HEAP32[$18 + 88 >> 2] = $3;
|
|
HEAP32[$18 + 92 >> 2] = $17;
|
|
$18 = HEAP32[$19 + 12 >> 2];
|
|
$17 = HEAP32[$19 + 8 >> 2];
|
|
$3 = $17;
|
|
$17 = $21;
|
|
HEAP32[$17 + 80 >> 2] = $3;
|
|
HEAP32[$17 + 84 >> 2] = $18;
|
|
$17 = HEAP32[$19 + 4 >> 2];
|
|
$18 = HEAP32[$19 >> 2];
|
|
$3 = $18;
|
|
$18 = $21;
|
|
HEAP32[$18 + 72 >> 2] = $3;
|
|
HEAP32[$18 + 76 >> 2] = $17;
|
|
$3 = HEAP32[$19 + 24 >> 2];
|
|
$18 = HEAP32[$19 + 40 >> 2];
|
|
$17 = HEAP32[$19 + 36 >> 2];
|
|
$12 = $17;
|
|
$17 = $21;
|
|
HEAP32[$17 + 56 >> 2] = $12;
|
|
HEAP32[$17 + 60 >> 2] = $18;
|
|
HEAP32[$17 - -64 >> 2] = HEAP32[$19 + 44 >> 2];
|
|
$17 = HEAP32[$19 + 32 >> 2];
|
|
$18 = HEAP32[$19 + 28 >> 2];
|
|
$12 = $18;
|
|
$18 = $21;
|
|
HEAP32[$18 + 48 >> 2] = $12;
|
|
HEAP32[$18 + 52 >> 2] = $17;
|
|
$15 = $25 - ((Math_imul($9, $22) << 2) + 15 & -16) | 0;
|
|
$12 = $15;
|
|
__stack_pointer = $12;
|
|
$22 = Math_imul(HEAP32[$0 + 8 >> 2], $9) << 2;
|
|
$12 = $12 - ($22 + 15 & -16) | 0;
|
|
$28 = $12;
|
|
__stack_pointer = $12;
|
|
$15 = memcpy($15, $5, $22);
|
|
$23 = ($2 - $1 | 0) > 10 ? Math_fround(Math_min(Math_fround(Math_fround($11 | 0) * Math_fround(.125)), Math_fround(16))) : Math_fround(16);
|
|
$25 = 0;
|
|
$24 = Math_clz32($20) + $24 | 0;
|
|
$20 = $24 - 29 >>> 0 > $6 >>> 0;
|
|
$14 = $20 ? 0 : $14;
|
|
$20 = $20 ? 0 : $26;
|
|
$22 = $14 | $20;
|
|
if (Math_fround(Math_abs($30)) < Math_fround(2147483648)) {
|
|
$26 = ~~$30;
|
|
} else {
|
|
$26 = -2147483648;
|
|
}
|
|
$23 = $16 ? Math_fround(3) : $23;
|
|
$24 = $24 - 32 | 0;
|
|
if ($22) {
|
|
$25 = quant_coarse_energy_impl($0, $1, $2, $4, $15, $6, $24, Math_imul($10, 84) + 33082 | 0, $12, $8, $9, $10, 1, $23, $16);
|
|
}
|
|
$27 = Math_fround(Math_min($27, Math_fround(200)));
|
|
label$8 : {
|
|
label$9 : {
|
|
if (!$20) {
|
|
$33 = ec_tell_frac($8);
|
|
$11 = HEAP32[$8 >> 2];
|
|
HEAP32[$21 + 40 >> 2] = HEAP32[$8 + 20 >> 2];
|
|
$17 = HEAP32[$8 + 12 >> 2];
|
|
$18 = HEAP32[$19 + 16 >> 2];
|
|
$20 = $17;
|
|
$17 = $21;
|
|
HEAP32[$17 + 32 >> 2] = $20;
|
|
HEAP32[$17 + 36 >> 2] = $18;
|
|
$17 = HEAP32[$19 + 8 >> 2];
|
|
$18 = HEAP32[$19 + 4 >> 2];
|
|
$20 = $18;
|
|
$18 = $21;
|
|
HEAP32[$18 + 24 >> 2] = $20;
|
|
HEAP32[$18 + 28 >> 2] = $17;
|
|
$31 = HEAP32[$19 + 24 >> 2];
|
|
$20 = $19 + 28 | 0;
|
|
$19 = $20 + 8 | 0;
|
|
$17 = HEAP32[$19 >> 2];
|
|
$18 = HEAP32[$19 + 4 >> 2];
|
|
$19 = $17;
|
|
$17 = $21;
|
|
HEAP32[$17 + 8 >> 2] = $19;
|
|
HEAP32[$17 + 12 >> 2] = $18;
|
|
HEAP32[$17 + 16 >> 2] = HEAP32[$20 + 16 >> 2];
|
|
$19 = $20;
|
|
$18 = HEAP32[$19 >> 2];
|
|
$17 = HEAP32[$19 + 4 >> 2];
|
|
$19 = $18;
|
|
$18 = $21;
|
|
HEAP32[$18 >> 2] = $19;
|
|
HEAP32[$18 + 4 >> 2] = $17;
|
|
$22 = $31 - $3 | 0;
|
|
$28 = $28 - (($22 ? $22 : 1) + 15 & -16) | 0;
|
|
__stack_pointer = $28;
|
|
$32 = $3 + $11 | 0;
|
|
$28 = memcpy($28, $32, $22);
|
|
$19 = $18;
|
|
$17 = HEAP32[$19 + 88 >> 2];
|
|
$18 = HEAP32[$19 + 92 >> 2];
|
|
$29 = $17;
|
|
$17 = $8;
|
|
HEAP32[$17 + 16 >> 2] = $29;
|
|
HEAP32[$17 + 20 >> 2] = $18;
|
|
$17 = HEAP32[$19 + 84 >> 2];
|
|
$18 = HEAP32[$19 + 80 >> 2];
|
|
$29 = $18;
|
|
$18 = $8;
|
|
HEAP32[$18 + 8 >> 2] = $29;
|
|
HEAP32[$18 + 12 >> 2] = $17;
|
|
$18 = HEAP32[$19 + 76 >> 2];
|
|
$17 = HEAP32[$19 + 72 >> 2];
|
|
$29 = $17;
|
|
$17 = $8;
|
|
HEAP32[$17 >> 2] = $29;
|
|
HEAP32[$17 + 4 >> 2] = $18;
|
|
HEAP32[$17 + 24 >> 2] = $3;
|
|
HEAP32[$20 + 16 >> 2] = HEAP32[$19 - -64 >> 2];
|
|
$17 = HEAP32[$19 + 60 >> 2];
|
|
$18 = HEAP32[$19 + 56 >> 2];
|
|
$3 = $18;
|
|
$18 = $20;
|
|
HEAP32[$18 + 8 >> 2] = $3;
|
|
HEAP32[$18 + 12 >> 2] = $17;
|
|
$18 = HEAP32[$19 + 52 >> 2];
|
|
$17 = HEAP32[$19 + 48 >> 2];
|
|
$3 = $17;
|
|
$17 = $20;
|
|
HEAP32[$17 >> 2] = $3;
|
|
HEAP32[$17 + 4 >> 2] = $18;
|
|
$3 = quant_coarse_energy_impl($0, $1, $2, $4, $5, $6, $24, Math_imul($10, 84) + 33040 | 0, $7, $8, $9, $10, 0, $23, $16);
|
|
if (!$14) {
|
|
break label$9;
|
|
}
|
|
if (($3 | 0) <= ($25 | 0)) {
|
|
if (($3 | 0) != ($25 | 0)) {
|
|
break label$9;
|
|
}
|
|
if ((ec_tell_frac($8) + $26 | 0) <= ($33 | 0)) {
|
|
break label$9;
|
|
}
|
|
}
|
|
HEAP32[$8 >> 2] = $11;
|
|
$3 = $8 + 4 | 0;
|
|
HEAP32[$3 + 16 >> 2] = HEAP32[$21 + 40 >> 2];
|
|
$18 = HEAP32[$21 + 32 >> 2];
|
|
$17 = HEAP32[$19 + 36 >> 2];
|
|
$1 = $18;
|
|
$18 = $8;
|
|
HEAP32[$18 + 12 >> 2] = $1;
|
|
HEAP32[$18 + 16 >> 2] = $17;
|
|
$18 = HEAP32[$19 + 28 >> 2];
|
|
$17 = HEAP32[$19 + 24 >> 2];
|
|
$1 = $17;
|
|
$17 = $8;
|
|
HEAP32[$17 + 4 >> 2] = $1;
|
|
HEAP32[$17 + 8 >> 2] = $18;
|
|
HEAP32[$17 + 24 >> 2] = $31;
|
|
HEAP32[$20 + 16 >> 2] = HEAP32[$19 + 16 >> 2];
|
|
$17 = HEAP32[$19 + 12 >> 2];
|
|
$18 = HEAP32[$19 + 8 >> 2];
|
|
$1 = $18;
|
|
$18 = $20;
|
|
HEAP32[$18 + 8 >> 2] = $1;
|
|
HEAP32[$18 + 12 >> 2] = $17;
|
|
$18 = HEAP32[$19 + 4 >> 2];
|
|
$17 = HEAP32[$19 >> 2];
|
|
$1 = $17;
|
|
$17 = $20;
|
|
HEAP32[$17 >> 2] = $1;
|
|
HEAP32[$17 + 4 >> 2] = $18;
|
|
memcpy($32, $28, $22);
|
|
$3 = $9 << 2;
|
|
memcpy($5, $15, Math_imul($3, HEAP32[$0 + 8 >> 2]));
|
|
memcpy($7, $12, Math_imul(HEAP32[$0 + 8 >> 2], $3));
|
|
break label$8;
|
|
}
|
|
$3 = $9 << 2;
|
|
memcpy($5, $15, Math_imul($3, HEAP32[$0 + 8 >> 2]));
|
|
memcpy($7, $12, Math_imul(HEAP32[$0 + 8 >> 2], $3));
|
|
break label$8;
|
|
}
|
|
$23 = HEAPF32[($10 << 2) + 33376 >> 2];
|
|
$27 = Math_fround($27 + Math_fround(Math_fround($23 * $23) * HEAPF32[$13 >> 2]));
|
|
}
|
|
HEAPF32[$13 >> 2] = $27;
|
|
__stack_pointer = $21 + 96 | 0;
|
|
}
|
|
function tonality_get_info($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = Math_fround(0), $9 = Math_fround(0), $10 = 0, $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = Math_fround(0), $15 = Math_fround(0), $16 = 0, $17 = Math_fround(0), $18 = Math_fround(0);
|
|
$4 = HEAP32[$0 + 8 >> 2];
|
|
$3 = HEAP32[$0 + 7452 >> 2] + (($2 | 0) / (($4 | 0) / 400 | 0) | 0) | 0;
|
|
HEAP32[$0 + 7452 >> 2] = $3;
|
|
$10 = HEAP32[$0 + 7444 >> 2];
|
|
$12 = HEAP32[$0 + 7448 >> 2];
|
|
$7 = $12;
|
|
if (($3 | 0) >= 8) {
|
|
$11 = ($3 - (($3 | 0) < 15 ? $3 : 15) | 0) + 7 | 0;
|
|
$7 = (($11 >>> 3 | 0) + $12 | 0) + 1 | 0;
|
|
HEAP32[$0 + 7448 >> 2] = $7;
|
|
HEAP32[$0 + 7452 >> 2] = ($3 - ($11 & -8) | 0) - 8;
|
|
}
|
|
if (($7 | 0) >= 100) {
|
|
HEAP32[$0 + 7448 >> 2] = $7 - 100;
|
|
}
|
|
$11 = 6;
|
|
$3 = $12 + 1 | 0;
|
|
$3 = ($10 | 0) == ($12 | 0) ? $12 : (($4 | 0) / 50 | 0) >= ($2 | 0) ? $12 : ($3 | 0) == 100 ? 0 : $3;
|
|
$3 = $3 - (($3 | 0) == ($10 | 0)) | 0;
|
|
$2 = ($3 | 0) < 0 ? 99 : $3;
|
|
$3 = ($2 << 6) + $0 | 0;
|
|
$6 = $3 + 7660 | 0;
|
|
$7 = HEAP32[$6 >> 2];
|
|
$4 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 56 >> 2] = $7;
|
|
HEAP32[$1 + 60 >> 2] = $4;
|
|
$6 = $3 + 7652 | 0;
|
|
$4 = HEAP32[$6 >> 2];
|
|
$7 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 48 >> 2] = $4;
|
|
HEAP32[$1 + 52 >> 2] = $7;
|
|
$6 = $3 + 7644 | 0;
|
|
$7 = HEAP32[$6 >> 2];
|
|
$4 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 40 >> 2] = $7;
|
|
HEAP32[$1 + 44 >> 2] = $4;
|
|
$6 = $3 + 7636 | 0;
|
|
$4 = HEAP32[$6 >> 2];
|
|
$7 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 32 >> 2] = $4;
|
|
HEAP32[$1 + 36 >> 2] = $7;
|
|
$6 = $3 + 7628 | 0;
|
|
$7 = HEAP32[$6 >> 2];
|
|
$4 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 24 >> 2] = $7;
|
|
HEAP32[$1 + 28 >> 2] = $4;
|
|
$6 = $3 + 7620 | 0;
|
|
$4 = HEAP32[$6 >> 2];
|
|
$7 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 16 >> 2] = $4;
|
|
HEAP32[$1 + 20 >> 2] = $7;
|
|
$6 = $3 + 7612 | 0;
|
|
$7 = HEAP32[$6 >> 2];
|
|
$4 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 + 8 >> 2] = $7;
|
|
HEAP32[$1 + 12 >> 2] = $4;
|
|
$6 = $3 + 7604 | 0;
|
|
$4 = HEAP32[$6 >> 2];
|
|
$7 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$1 >> 2] = $4;
|
|
HEAP32[$1 + 4 >> 2] = $7;
|
|
if ($4) {
|
|
$3 = $10 - $12 | 0;
|
|
$10 = ($3 | 0) < 0;
|
|
$7 = $3 + 100 | 0;
|
|
$5 = HEAPF32[$1 + 4 >> 2];
|
|
$8 = Math_fround(1);
|
|
$16 = $2 + 1 | 0;
|
|
$4 = ($16 | 0) == 100 ? 0 : $16;
|
|
$12 = HEAP32[$0 + 7444 >> 2];
|
|
label$4 : {
|
|
if (($4 | 0) == ($12 | 0)) {
|
|
$9 = $5;
|
|
break label$4;
|
|
}
|
|
$11 = ($4 << 6) + $0 | 0;
|
|
$8 = HEAPF32[$11 + 7608 >> 2];
|
|
$6 = HEAP32[$1 + 32 >> 2];
|
|
$11 = HEAP32[$11 + 7636 >> 2];
|
|
$11 = ($11 | 0) < ($6 | 0) ? $6 : $11;
|
|
HEAP32[$1 + 32 >> 2] = $11;
|
|
$9 = $5 > $8 ? $5 : $8;
|
|
$5 = Math_fround($5 + $8);
|
|
$4 = $4 + 1 | 0;
|
|
$4 = ($4 | 0) == 100 ? 0 : $4;
|
|
if (($12 | 0) == ($4 | 0)) {
|
|
$11 = 5;
|
|
$8 = Math_fround(2);
|
|
break label$4;
|
|
}
|
|
$6 = ($4 << 6) + $0 | 0;
|
|
$8 = HEAPF32[$6 + 7608 >> 2];
|
|
$6 = HEAP32[$6 + 7636 >> 2];
|
|
$11 = ($11 | 0) > ($6 | 0) ? $11 : $6;
|
|
HEAP32[$1 + 32 >> 2] = $11;
|
|
$9 = $8 < $9 ? $9 : $8;
|
|
$5 = Math_fround($5 + $8);
|
|
$4 = $4 + 1 | 0;
|
|
$4 = ($4 | 0) == 100 ? 0 : $4;
|
|
if (($12 | 0) == ($4 | 0)) {
|
|
$11 = 4;
|
|
$8 = Math_fround(3);
|
|
break label$4;
|
|
}
|
|
$4 = ($4 << 6) + $0 | 0;
|
|
$8 = HEAPF32[$4 + 7608 >> 2];
|
|
$4 = HEAP32[$4 + 7636 >> 2];
|
|
HEAP32[$1 + 32 >> 2] = ($4 | 0) < ($11 | 0) ? $11 : $4;
|
|
$9 = $8 < $9 ? $9 : $8;
|
|
$5 = Math_fround($5 + $8);
|
|
$11 = 3;
|
|
$8 = Math_fround(4);
|
|
}
|
|
$6 = $10 ? $7 : $3;
|
|
$10 = 0;
|
|
$3 = $2;
|
|
while (1) {
|
|
$3 = ($3 | 0) < 1 ? 99 : $3 - 1 | 0;
|
|
if (($12 | 0) != ($3 | 0)) {
|
|
$7 = HEAP32[$1 + 32 >> 2];
|
|
$4 = HEAP32[(($3 << 6) + $0 | 0) + 7636 >> 2];
|
|
HEAP32[$1 + 32 >> 2] = ($4 | 0) < ($7 | 0) ? $7 : $4;
|
|
$10 = $10 + 1 | 0;
|
|
if (($11 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
$5 = Math_fround($5 / $8);
|
|
$9 = Math_fround($9 + Math_fround(-.20000000298023224));
|
|
HEAPF32[$1 + 4 >> 2] = $5 > $9 ? $5 : $9;
|
|
$10 = $2;
|
|
$3 = $10;
|
|
if (($6 | 0) >= 16) {
|
|
$10 = (($2 | 0) > 94 ? -95 : 5) + $2 | 0;
|
|
$16 = $10 + 1 | 0;
|
|
$3 = (($2 | 0) > 98 ? -99 : 1) + $2 | 0;
|
|
}
|
|
$7 = $0 + 7604 | 0;
|
|
$17 = HEAPF32[($7 + ($3 << 6) | 0) + 36 >> 2];
|
|
$5 = Math_fround(Math_max($17, Math_fround(.10000000149011612)));
|
|
$9 = Math_fround(HEAPF32[(($10 << 6) + $7 | 0) + 20 >> 2] * $5);
|
|
$10 = ($16 | 0) == 100 ? 0 : $16;
|
|
label$11 : {
|
|
if (($12 | 0) == ($10 | 0)) {
|
|
$8 = Math_fround(1);
|
|
break label$11;
|
|
}
|
|
$8 = Math_fround(1);
|
|
while (1) {
|
|
$3 = $3 + 1 | 0;
|
|
$3 = ($3 | 0) == 100 ? 0 : $3;
|
|
if (($12 | 0) == ($3 | 0)) {
|
|
break label$11;
|
|
}
|
|
$13 = HEAPF32[(($3 << 6) + $7 | 0) + 36 >> 2];
|
|
$15 = Math_fround(Math_fround($17 - $13) * Math_fround(10));
|
|
$18 = Math_fround(Math_fround($9 + $15) / $5);
|
|
$14 = $14 < $18 ? $18 : $14;
|
|
$15 = Math_fround(Math_fround($9 - $15) / $5);
|
|
$8 = $8 > $15 ? $15 : $8;
|
|
$13 = Math_fround(Math_max($13, Math_fround(.10000000149011612)));
|
|
$9 = Math_fround($9 + Math_fround(HEAPF32[(($10 << 6) + $7 | 0) + 20 >> 2] * $13));
|
|
$5 = Math_fround($5 + $13);
|
|
$10 = $10 + 1 | 0;
|
|
$10 = ($10 | 0) == 100 ? 0 : $10;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = Math_fround($9 / $5);
|
|
HEAPF32[$1 + 20 >> 2] = $5;
|
|
$9 = $5 > $14 ? $5 : $14;
|
|
$14 = $9 < Math_fround(1) ? $9 : Math_fround(1);
|
|
$5 = $5 < $8 ? $5 : $8;
|
|
$13 = $5 > Math_fround(0) ? $5 : Math_fround(0);
|
|
if (($6 | 0) <= 9) {
|
|
$9 = $13;
|
|
$8 = $14;
|
|
$3 = HEAP32[$0 + 7436 >> 2];
|
|
if (($3 | 0) >= 2) {
|
|
$3 = ($3 | 0) > 15 ? 15 : $3 - 1 | 0;
|
|
$12 = ($3 | 0) > 1 ? $3 : 1;
|
|
$3 = 0;
|
|
while (1) {
|
|
$2 = ($2 | 0) < 1 ? 99 : $2 - 1 | 0;
|
|
$5 = HEAPF32[(($2 << 6) + $0 | 0) + 7624 >> 2];
|
|
$8 = $5 < $8 ? $8 : $5;
|
|
$9 = $5 > $9 ? $9 : $5;
|
|
$3 = $3 + 1 | 0;
|
|
if (($12 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = Math_fround(Math_fround(1) - Math_fround(Math_fround($6 | 0) * Math_fround(.10000000149011612)));
|
|
$15 = Math_fround($17 * Math_fround(.10000000149011612));
|
|
$14 = Math_fround($14 + Math_fround($5 * Math_fround(Math_fround(Math_min(Math_fround($15 + $8), Math_fround(1))) - $14)));
|
|
$13 = Math_fround($13 + Math_fround($5 * Math_fround(Math_fround(Math_max(Math_fround($9 - $15), Math_fround(0))) - $13)));
|
|
}
|
|
HEAPF32[$1 + 28 >> 2] = $14;
|
|
HEAPF32[$1 + 24 >> 2] = $13;
|
|
}
|
|
}
|
|
function silk_NLSF2A($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0;
|
|
$6 = __stack_pointer - 320 | 0;
|
|
__stack_pointer = $6;
|
|
label$1 : {
|
|
switch ($2 - 10 | 0) {
|
|
default:
|
|
celt_fatal(15418, 15451, 89);
|
|
abort();
|
|
case 0:
|
|
case 6:
|
|
break label$1;
|
|
}
|
|
}
|
|
$12 = ($2 | 0) == 16 ? 15392 : 15408;
|
|
while (1) {
|
|
$8 = HEAP16[($5 << 1) + $1 >> 1];
|
|
$7 = $8 >> 8 << 1;
|
|
$3 = HEAP16[$7 + 15122 >> 1];
|
|
$7 = HEAP16[$7 + 15120 >> 1];
|
|
HEAP32[($6 + 224 | 0) + (HEAPU8[$5 + $12 | 0] << 2) >> 2] = (Math_imul($3 - $7 | 0, $8 & 255) + ($7 << 8) >> 3) + 1 >> 1;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = 65536;
|
|
HEAP32[$6 + 160 >> 2] = 65536;
|
|
$1 = 0 - HEAP32[$6 + 224 >> 2] | 0;
|
|
HEAP32[$6 + 164 >> 2] = $1;
|
|
$5 = 1;
|
|
$19 = $2 >> 1;
|
|
label$4 : {
|
|
$20 = ($2 | 0) < 4;
|
|
if ($20) {
|
|
break label$4;
|
|
}
|
|
while (1) {
|
|
$17 = HEAP32[($6 + 224 | 0) + ($5 << 3) >> 2];
|
|
$3 = $17;
|
|
$4 = $3 >> 31;
|
|
$14 = $3;
|
|
$15 = $4;
|
|
$3 = $1;
|
|
$4 = $3 >> 31;
|
|
$3 = $4;
|
|
$13 = $5 + 1 | 0;
|
|
$18 = ($6 + 160 | 0) + ($13 << 2) | 0;
|
|
$4 = $15;
|
|
$3 = __wasm_i64_mul($14, $4, $1, $3);
|
|
$9 = $3;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $4 >>> 15 | 0;
|
|
$4 = ($4 & 32767) << 17 | $9 >>> 15;
|
|
$10 = $4 + 1 | 0;
|
|
$11 = $10 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $10;
|
|
HEAP32[$18 >> 2] = ($7 << 1) - (($11 & 1) << 31 | $3 >>> 1);
|
|
$8 = $5 << 2;
|
|
$16 = $8 + ($6 + 160 | 0) | 0;
|
|
label$6 : {
|
|
if ($5 >>> 0 < 2) {
|
|
break label$6;
|
|
}
|
|
$8 = HEAP32[($6 + $8 | 0) + 152 >> 2];
|
|
$1 = $8 + $1 | 0;
|
|
$3 = $7;
|
|
$4 = $3 >> 31;
|
|
$3 = $15;
|
|
$3 = __wasm_i64_mul($7, $4, $14, $3);
|
|
$11 = $3;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $4 >>> 15 | 0;
|
|
$4 = ($4 & 32767) << 17 | $11 >>> 15;
|
|
$9 = $4 + 1 | 0;
|
|
$10 = $9 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $9;
|
|
HEAP32[$16 >> 2] = $1 - (($10 & 1) << 31 | $3 >>> 1);
|
|
if (($5 | 0) == 2) {
|
|
break label$6;
|
|
}
|
|
while (1) {
|
|
$7 = $5 - 1 | 0;
|
|
$1 = ($6 + 160 | 0) + ($7 << 2) | 0;
|
|
$12 = HEAP32[(($5 << 2) + $6 | 0) + 148 >> 2];
|
|
$21 = $12 + HEAP32[$1 >> 2] | 0;
|
|
$3 = $8;
|
|
$4 = $3 >> 31;
|
|
$3 = $15;
|
|
$3 = __wasm_i64_mul($8, $4, $14, $3);
|
|
$10 = $3;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $4 >>> 15 | 0;
|
|
$4 = ($4 & 32767) << 17 | $10 >>> 15;
|
|
$11 = $4 + 1 | 0;
|
|
$9 = $11 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $11;
|
|
HEAP32[$1 >> 2] = $21 - (($9 & 1) << 31 | $3 >>> 1);
|
|
$1 = ($5 | 0) > 3;
|
|
$5 = $7;
|
|
$8 = $12;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$6 + 164 >> 2] = HEAP32[$6 + 164 >> 2] - $17;
|
|
if (($13 | 0) == ($19 | 0)) {
|
|
break label$4;
|
|
}
|
|
$1 = HEAP32[$18 >> 2];
|
|
$7 = HEAP32[$16 >> 2];
|
|
$5 = $13;
|
|
continue;
|
|
}
|
|
}
|
|
$7 = 65536;
|
|
HEAP32[$6 + 96 >> 2] = 65536;
|
|
$1 = 0 - HEAP32[$6 + 228 >> 2] | 0;
|
|
HEAP32[$6 + 100 >> 2] = $1;
|
|
label$8 : {
|
|
if ($20) {
|
|
break label$8;
|
|
}
|
|
$20 = $6 + 224 | 4;
|
|
$5 = 1;
|
|
while (1) {
|
|
$17 = HEAP32[($5 << 3) + $20 >> 2];
|
|
$3 = $17;
|
|
$4 = $3 >> 31;
|
|
$14 = $3;
|
|
$15 = $4;
|
|
$3 = $1;
|
|
$4 = $3 >> 31;
|
|
$3 = $4;
|
|
$13 = $5 + 1 | 0;
|
|
$18 = ($6 + 96 | 0) + ($13 << 2) | 0;
|
|
$4 = $15;
|
|
$3 = __wasm_i64_mul($14, $4, $1, $3);
|
|
$9 = $3;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $4 >>> 15 | 0;
|
|
$4 = ($4 & 32767) << 17 | $9 >>> 15;
|
|
$10 = $4 + 1 | 0;
|
|
$11 = $10 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $10;
|
|
HEAP32[$18 >> 2] = ($7 << 1) - (($11 & 1) << 31 | $3 >>> 1);
|
|
$8 = $5 << 2;
|
|
$16 = $8 + ($6 + 96 | 0) | 0;
|
|
label$10 : {
|
|
if ($5 >>> 0 < 2) {
|
|
break label$10;
|
|
}
|
|
$8 = HEAP32[($6 + $8 | 0) + 88 >> 2];
|
|
$1 = $8 + $1 | 0;
|
|
$3 = $7;
|
|
$4 = $3 >> 31;
|
|
$3 = $15;
|
|
$3 = __wasm_i64_mul($7, $4, $14, $3);
|
|
$11 = $3;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $4 >>> 15 | 0;
|
|
$4 = ($4 & 32767) << 17 | $11 >>> 15;
|
|
$9 = $4 + 1 | 0;
|
|
$10 = $9 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $9;
|
|
HEAP32[$16 >> 2] = $1 - (($10 & 1) << 31 | $3 >>> 1);
|
|
if (($5 | 0) == 2) {
|
|
break label$10;
|
|
}
|
|
while (1) {
|
|
$7 = $5 - 1 | 0;
|
|
$1 = ($6 + 96 | 0) + ($7 << 2) | 0;
|
|
$12 = HEAP32[(($5 << 2) + $6 | 0) + 84 >> 2];
|
|
$21 = $12 + HEAP32[$1 >> 2] | 0;
|
|
$3 = $8;
|
|
$4 = $3 >> 31;
|
|
$3 = $15;
|
|
$3 = __wasm_i64_mul($8, $4, $14, $3);
|
|
$10 = $3;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $4 >>> 15 | 0;
|
|
$4 = ($4 & 32767) << 17 | $10 >>> 15;
|
|
$11 = $4 + 1 | 0;
|
|
$9 = $11 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $11;
|
|
HEAP32[$1 >> 2] = $21 - (($9 & 1) << 31 | $3 >>> 1);
|
|
$1 = ($5 | 0) > 3;
|
|
$5 = $7;
|
|
$8 = $12;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$6 + 100 >> 2] = HEAP32[$6 + 100 >> 2] - $17;
|
|
if (($13 | 0) == ($19 | 0)) {
|
|
break label$8;
|
|
}
|
|
$1 = HEAP32[$18 >> 2];
|
|
$7 = HEAP32[$16 >> 2];
|
|
$5 = $13;
|
|
continue;
|
|
}
|
|
}
|
|
if (($2 | 0) >= 2) {
|
|
$16 = ($19 | 0) > 1 ? $19 : 1;
|
|
$7 = HEAP32[$6 + 96 >> 2];
|
|
$1 = HEAP32[$6 + 160 >> 2];
|
|
$5 = 0;
|
|
while (1) {
|
|
$8 = $5 + 1 | 0;
|
|
$12 = $8 << 2;
|
|
$13 = HEAP32[$12 + ($6 + 96 | 0) >> 2];
|
|
$7 = $13 - $7 | 0;
|
|
$12 = HEAP32[($6 + 160 | 0) + $12 >> 2];
|
|
$1 = $12 + $1 | 0;
|
|
HEAP32[($5 << 2) + $6 >> 2] = 0 - ($7 + $1 | 0);
|
|
HEAP32[(($5 ^ -1) + $2 << 2) + $6 >> 2] = $7 - $1;
|
|
$7 = $13;
|
|
$1 = $12;
|
|
$5 = $8;
|
|
if (($16 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_LPC_fit($0, $6, 12, 17, $2);
|
|
label$14 : {
|
|
if (silk_LPC_inverse_pred_gain_c($0, $2)) {
|
|
break label$14;
|
|
}
|
|
$8 = 0;
|
|
while (1) {
|
|
silk_bwexpander_32($6, $2, (-2 << $8) + 65536 | 0);
|
|
$5 = 0;
|
|
while (1) {
|
|
HEAP16[($5 << 1) + $0 >> 1] = (HEAP32[($5 << 2) + $6 >> 2] >>> 4 | 0) + 1 >>> 1;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = silk_LPC_inverse_pred_gain_c($0, $2);
|
|
if ($8 >>> 0 > 14) {
|
|
break label$14;
|
|
}
|
|
$8 = $8 + 1 | 0;
|
|
if (!$5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $6 + 320 | 0;
|
|
}
|
|
function celt_pitch_xcorr_c($0, $1, $2, $3, $4, $5) {
|
|
var $6 = Math_fround(0), $7 = 0, $8 = Math_fround(0), $9 = 0, $10 = 0, $11 = 0, $12 = Math_fround(0), $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = 0, $18 = Math_fround(0), $19 = 0, $20 = Math_fround(0), $21 = Math_fround(0), $22 = Math_fround(0), $23 = Math_fround(0), $24 = Math_fround(0), $25 = Math_fround(0), $26 = Math_fround(0), $27 = Math_fround(0), $28 = Math_fround(0), $29 = 0, $30 = 0, $31 = Math_fround(0), $32 = 0, $33 = 0, $34 = 0;
|
|
if (($4 | 0) >= 1) {
|
|
label$2 : {
|
|
if (($4 | 0) < 4) {
|
|
break label$2;
|
|
}
|
|
if (($3 | 0) >= 3) {
|
|
$32 = $4 - 3 | 0;
|
|
$19 = $3 - 3 | 0;
|
|
$33 = ($3 | 0) == 3;
|
|
$29 = $3 & -4;
|
|
$30 = $29 | 1;
|
|
$34 = ($30 + 1 | 0) >= ($3 | 0);
|
|
while (1) {
|
|
$17 = $11 << 2;
|
|
$5 = $17 + $1 | 0;
|
|
$7 = $5 + 12 | 0;
|
|
$8 = HEAPF32[$5 + 8 >> 2];
|
|
$18 = HEAPF32[$5 + 4 >> 2];
|
|
$16 = HEAPF32[$5 >> 2];
|
|
$12 = Math_fround(0);
|
|
$25 = Math_fround(0);
|
|
$26 = Math_fround(0);
|
|
$27 = Math_fround(0);
|
|
$5 = $0;
|
|
$10 = 0;
|
|
$9 = 0;
|
|
$13 = 0;
|
|
$14 = 0;
|
|
$15 = 0;
|
|
if (!$33) {
|
|
while (1) {
|
|
$20 = HEAPF32[$5 >> 2];
|
|
$6 = HEAPF32[$7 >> 2];
|
|
$21 = HEAPF32[$5 + 4 >> 2];
|
|
$22 = HEAPF32[$7 + 4 >> 2];
|
|
$23 = HEAPF32[$5 + 8 >> 2];
|
|
$28 = HEAPF32[$7 + 8 >> 2];
|
|
$24 = HEAPF32[$5 + 12 >> 2];
|
|
$31 = HEAPF32[$7 + 12 >> 2];
|
|
$12 = Math_fround(Math_fround(Math_fround(Math_fround($12 + Math_fround($20 * $6)) + Math_fround($21 * $22)) + Math_fround($23 * $28)) + Math_fround($24 * $31));
|
|
$25 = Math_fround(Math_fround(Math_fround(Math_fround($25 + Math_fround($8 * $20)) + Math_fround($6 * $21)) + Math_fround($22 * $23)) + Math_fround($28 * $24));
|
|
$26 = Math_fround(Math_fround(Math_fround(Math_fround($26 + Math_fround($18 * $20)) + Math_fround($8 * $21)) + Math_fround($6 * $23)) + Math_fround($22 * $24));
|
|
$27 = Math_fround(Math_fround(Math_fround(Math_fround($27 + Math_fround($16 * $20)) + Math_fround($18 * $21)) + Math_fround($8 * $23)) + Math_fround($6 * $24));
|
|
$7 = $7 + 16 | 0;
|
|
$5 = $5 + 16 | 0;
|
|
$16 = $22;
|
|
$8 = $31;
|
|
$18 = $28;
|
|
$10 = $10 + 4 | 0;
|
|
if (($19 | 0) > ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$13 = (wasm2js_scratch_store_f32($26), wasm2js_scratch_load_i32(2));
|
|
$14 = (wasm2js_scratch_store_f32($25), wasm2js_scratch_load_i32(2));
|
|
$15 = (wasm2js_scratch_store_f32($12), wasm2js_scratch_load_i32(2));
|
|
$12 = $6;
|
|
$9 = (wasm2js_scratch_store_f32($27), wasm2js_scratch_load_i32(2));
|
|
}
|
|
label$7 : {
|
|
if (($3 | 0) <= ($29 | 0)) {
|
|
break label$7;
|
|
}
|
|
$6 = HEAPF32[$5 >> 2];
|
|
$12 = HEAPF32[$7 >> 2];
|
|
$15 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($6 * $12) + (wasm2js_scratch_store_i32(2, $15), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$14 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($8 * $6) + (wasm2js_scratch_store_i32(2, $14), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$13 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($18 * $6) + (wasm2js_scratch_store_i32(2, $13), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$9 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($16 * $6) + (wasm2js_scratch_store_i32(2, $9), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$7 = $7 + 4 | 0;
|
|
$5 = $5 + 4 | 0;
|
|
}
|
|
$10 = $7;
|
|
label$9 : {
|
|
if (($3 | 0) <= ($30 | 0)) {
|
|
$7 = $10;
|
|
break label$9;
|
|
}
|
|
$6 = HEAPF32[$5 >> 2];
|
|
$16 = HEAPF32[$10 >> 2];
|
|
$15 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($6 * $16) + (wasm2js_scratch_store_i32(2, $15), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$14 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($12 * $6) + (wasm2js_scratch_store_i32(2, $14), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$13 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($8 * $6) + (wasm2js_scratch_store_i32(2, $13), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$9 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($18 * $6) + (wasm2js_scratch_store_i32(2, $9), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$5 = $5 + 4 | 0;
|
|
$7 = $10 + 4 | 0;
|
|
}
|
|
if (!$34) {
|
|
$6 = HEAPF32[$5 >> 2];
|
|
$15 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($6 * HEAPF32[$7 >> 2]) + (wasm2js_scratch_store_i32(2, $15), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$14 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($16 * $6) + (wasm2js_scratch_store_i32(2, $14), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$13 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($12 * $6) + (wasm2js_scratch_store_i32(2, $13), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
$9 = (wasm2js_scratch_store_f32(Math_fround(Math_fround($8 * $6) + (wasm2js_scratch_store_i32(2, $9), wasm2js_scratch_load_f32()))), wasm2js_scratch_load_i32(2));
|
|
}
|
|
HEAP32[$2 + $17 >> 2] = $9;
|
|
HEAP32[($17 | 4) + $2 >> 2] = $13;
|
|
HEAP32[($17 | 8) + $2 >> 2] = $14;
|
|
HEAP32[($17 | 12) + $2 >> 2] = $15;
|
|
$11 = $11 + 4 | 0;
|
|
if (($32 | 0) > ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$2;
|
|
}
|
|
celt_fatal(9872, 9897, 69);
|
|
abort();
|
|
}
|
|
if (($4 | 0) > ($11 | 0)) {
|
|
$9 = ($3 | 0) < 1;
|
|
while (1) {
|
|
$19 = $11 << 2;
|
|
$8 = Math_fround(0);
|
|
if (!$9) {
|
|
$10 = $1 + $19 | 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$5 = $7 << 2;
|
|
$8 = Math_fround($8 + Math_fround(HEAPF32[$5 + $0 >> 2] * HEAPF32[$5 + $10 >> 2]));
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$2 + $19 >> 2] = $8;
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(9738, 9768, 251);
|
|
abort();
|
|
}
|
|
function quant_band_stereo($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
var $11 = Math_fround(0), $12 = 0, $13 = 0, $14 = 0, $15 = Math_fround(0), $16 = 0, $17 = 0, $18 = Math_fround(0), $19 = Math_fround(0), $20 = 0, $21 = 0, $22 = 0, $23 = Math_fround(0);
|
|
$12 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $12;
|
|
HEAP32[$12 + 24 >> 2] = $10;
|
|
HEAP32[$12 + 28 >> 2] = $4;
|
|
$4 = HEAP32[$0 + 28 >> 2];
|
|
$16 = HEAP32[$0 >> 2];
|
|
label$1 : {
|
|
if (($3 | 0) == 1) {
|
|
$3 = 0;
|
|
$10 = HEAP32[$0 + 32 >> 2];
|
|
if (($10 | 0) >= 8) {
|
|
label$4 : {
|
|
if ($16) {
|
|
$3 = HEAPF32[$1 >> 2] < Math_fround(0);
|
|
ec_enc_bits($4, $3, 1);
|
|
break label$4;
|
|
}
|
|
$3 = ec_dec_bits($4, 1);
|
|
}
|
|
$10 = HEAP32[$0 + 32 >> 2] - 8 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $10;
|
|
}
|
|
if (HEAP32[$0 + 4 >> 2]) {
|
|
HEAPF32[$1 >> 2] = $3 ? Math_fround(-1) : Math_fround(1);
|
|
}
|
|
if ($2) {
|
|
$3 = $2 ? 2 : 1;
|
|
$7 = $3 >>> 0 > 1 ? $3 : 1;
|
|
$5 = 1;
|
|
while (1) {
|
|
$3 = 0;
|
|
if (($10 | 0) >= 8) {
|
|
label$10 : {
|
|
if ($16) {
|
|
$3 = HEAPF32[$2 >> 2] < Math_fround(0);
|
|
ec_enc_bits($4, $3, 1);
|
|
break label$10;
|
|
}
|
|
$3 = ec_dec_bits($4, 1);
|
|
}
|
|
$10 = HEAP32[$0 + 32 >> 2] - 8 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $10;
|
|
}
|
|
if (HEAP32[$0 + 4 >> 2]) {
|
|
HEAPF32[$2 >> 2] = $3 ? Math_fround(-1) : Math_fround(1);
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = 1;
|
|
if (!$8) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$8 >> 2] = HEAP32[$1 >> 2];
|
|
break label$1;
|
|
}
|
|
compute_theta($0, $12, $1, $2, $3, $12 + 28 | 0, $5, $5, $7, 1, $12 + 24 | 0);
|
|
$11 = Math_fround(Math_fround(HEAP32[$12 + 8 >> 2]) * Math_fround(30517578125e-15));
|
|
$19 = Math_fround(Math_fround(HEAP32[$12 + 4 >> 2]) * Math_fround(30517578125e-15));
|
|
$14 = HEAP32[$12 + 28 >> 2];
|
|
$17 = HEAP32[$12 + 20 >> 2];
|
|
$13 = HEAP32[$12 + 16 >> 2];
|
|
$22 = HEAP32[$12 >> 2];
|
|
label$13 : {
|
|
if (($3 | 0) == 2) {
|
|
$21 = $13 & -16385;
|
|
$20 = (($21 | 0) != 0) << 3;
|
|
HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] - ($20 + $17 | 0);
|
|
$13 = ($13 | 0) > 8192;
|
|
$17 = $13 ? $1 : $2;
|
|
$13 = $13 ? $2 : $1;
|
|
$20 = $14 - $20 | 0;
|
|
$14 = 0;
|
|
label$15 : {
|
|
if (!$21) {
|
|
break label$15;
|
|
}
|
|
if ($16) {
|
|
$14 = Math_fround(Math_fround(HEAPF32[$13 >> 2] * HEAPF32[$17 + 4 >> 2]) - Math_fround(HEAPF32[$13 + 4 >> 2] * HEAPF32[$17 >> 2])) < Math_fround(0);
|
|
ec_enc_bits($4, $14, 1);
|
|
break label$15;
|
|
}
|
|
$14 = ec_dec_bits($4, 1);
|
|
}
|
|
$7 = quant_band($0, $13, 2, $20, $5, $6, $7, $8, Math_fround(1), $9, $10);
|
|
$5 = 1 - ($14 << 1) | 0;
|
|
HEAPF32[$17 >> 2] = HEAPF32[$13 + 4 >> 2] * Math_fround(0 - $5 | 0);
|
|
HEAPF32[$17 + 4 >> 2] = HEAPF32[$13 >> 2] * Math_fround($5 | 0);
|
|
if (!HEAP32[$0 + 4 >> 2]) {
|
|
break label$13;
|
|
}
|
|
HEAPF32[$1 >> 2] = $19 * HEAPF32[$1 >> 2];
|
|
HEAPF32[$1 + 4 >> 2] = $19 * HEAPF32[$1 + 4 >> 2];
|
|
$15 = Math_fround($11 * HEAPF32[$2 >> 2]);
|
|
HEAPF32[$2 >> 2] = $15;
|
|
HEAPF32[$2 + 4 >> 2] = $11 * HEAPF32[$2 + 4 >> 2];
|
|
$11 = HEAPF32[$1 >> 2];
|
|
HEAPF32[$1 >> 2] = $11 - $15;
|
|
HEAPF32[$2 >> 2] = $11 + HEAPF32[$2 >> 2];
|
|
$11 = HEAPF32[$1 + 4 >> 2];
|
|
HEAPF32[$1 + 4 >> 2] = $11 - HEAPF32[$2 + 4 >> 2];
|
|
HEAPF32[$2 + 4 >> 2] = $11 + HEAPF32[$2 + 4 >> 2];
|
|
break label$13;
|
|
}
|
|
$10 = HEAP32[$12 + 12 >> 2];
|
|
$17 = HEAP32[$0 + 32 >> 2] - $17 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $17;
|
|
$4 = HEAP32[$12 + 24 >> 2];
|
|
$10 = ($14 - $10 | 0) / 2 | 0;
|
|
$10 = ($10 | 0) > ($14 | 0) ? $14 : $10;
|
|
$10 = ($10 | 0) > 0 ? $10 : 0;
|
|
$16 = $14 - $10 | 0;
|
|
if (($10 | 0) >= ($16 | 0)) {
|
|
$6 = quant_band($0, $1, $3, $10, $5, $6, $7, $8, Math_fround(1), $9, $4);
|
|
$10 = (HEAP32[$0 + 32 >> 2] - $17 | 0) + $10 | 0;
|
|
$7 = $6 | quant_band($0, $2, $3, ($13 ? ($10 | 0) > 24 ? $10 - 24 | 0 : 0 : 0) + $16 | 0, $5, 0, $7, 0, $11, 0, $4 >> $5);
|
|
break label$13;
|
|
}
|
|
$14 = quant_band($0, $2, $3, $16, $5, 0, $7, 0, $11, 0, $4 >> $5);
|
|
$16 = (HEAP32[$0 + 32 >> 2] - $17 | 0) + $16 | 0;
|
|
$7 = $14 | quant_band($0, $1, $3, (($13 | 0) != 16384 ? ($16 | 0) > 24 ? $16 - 24 | 0 : 0 : 0) + $10 | 0, $5, $6, $7, $8, Math_fround(1), $9, $4);
|
|
}
|
|
if (!HEAP32[$0 + 4 >> 2]) {
|
|
break label$1;
|
|
}
|
|
label$18 : {
|
|
if (($3 | 0) == 2) {
|
|
break label$18;
|
|
}
|
|
$15 = Math_fround(0);
|
|
if (($3 | 0) >= 1) {
|
|
$0 = 0;
|
|
while (1) {
|
|
$5 = $0 << 2;
|
|
$11 = HEAPF32[$5 + $2 >> 2];
|
|
$18 = Math_fround($18 + Math_fround($11 * HEAPF32[$1 + $5 >> 2]));
|
|
$15 = Math_fround($15 + Math_fround($11 * $11));
|
|
$0 = $0 + 1 | 0;
|
|
if (($3 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$22 : {
|
|
$15 = Math_fround(Math_fround($19 * $19) + $15);
|
|
$11 = Math_fround($19 * $18);
|
|
$11 = Math_fround($11 + $11);
|
|
$18 = Math_fround($15 + $11);
|
|
if (!($18 < Math_fround(.0006000000284984708))) {
|
|
$11 = Math_fround($15 - $11);
|
|
if ($11 < Math_fround(.0006000000284984708) ^ 1) {
|
|
break label$22;
|
|
}
|
|
}
|
|
memcpy($2, $1, $3 << 2);
|
|
break label$18;
|
|
}
|
|
if (($3 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$18 = Math_fround(Math_fround(1) / Math_fround(Math_sqrt($18)));
|
|
$23 = Math_fround(Math_fround(1) / Math_fround(Math_sqrt($11)));
|
|
$0 = 0;
|
|
while (1) {
|
|
$5 = $0 << 2;
|
|
$10 = $5 + $1 | 0;
|
|
$11 = Math_fround($19 * HEAPF32[$10 >> 2]);
|
|
$5 = $2 + $5 | 0;
|
|
$15 = HEAPF32[$5 >> 2];
|
|
HEAPF32[$10 >> 2] = $23 * Math_fround($11 - $15);
|
|
HEAPF32[$5 >> 2] = $18 * Math_fround($11 + $15);
|
|
$0 = $0 + 1 | 0;
|
|
if (($3 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$22 | ($3 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$0 = 0;
|
|
while (1) {
|
|
$5 = ($0 << 2) + $2 | 0;
|
|
HEAPF32[$5 >> 2] = -HEAPF32[$5 >> 2];
|
|
$0 = $0 + 1 | 0;
|
|
if (($3 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $12 + 32 | 0;
|
|
return $7;
|
|
}
|
|
function silk_LPC_inverse_pred_gain_c($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0;
|
|
$13 = __stack_pointer - 96 | 0;
|
|
label$1 : {
|
|
if (($1 | 0) >= 1) {
|
|
while (1) {
|
|
$8 = HEAP16[($6 << 1) + $0 >> 1];
|
|
HEAP32[($6 << 2) + $13 >> 2] = $8 << 12;
|
|
$10 = $8 + $10 | 0;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($10 | 0) > 4095) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$10 = $1 - 1 | 0;
|
|
$8 = HEAP32[($10 << 2) + $13 >> 2];
|
|
$6 = $8 + 16773022 >>> 0 > 33546044;
|
|
$9 = 1073741824;
|
|
if (($1 | 0) >= 2) {
|
|
while (1) {
|
|
if ($6 & 1) {
|
|
return 0;
|
|
}
|
|
$7 = 0 - ($8 << 7) | 0;
|
|
$3 = $7 >> 31;
|
|
$12 = $7;
|
|
$17 = $3;
|
|
$7 = __wasm_i64_mul($12, $3, $12, $3);
|
|
$3 = i64toi32_i32$HIGH_BITS;
|
|
$6 = 1073741824 - $3 | 0;
|
|
$2 = $6;
|
|
$7 = $2 >> 31;
|
|
$2 = $7;
|
|
$7 = $11;
|
|
$2 = __wasm_i64_mul($9, $7, $6, $2);
|
|
$3 = $2;
|
|
$7 = i64toi32_i32$HIGH_BITS;
|
|
$18 = (($7 & 1073741823) << 2 | $3 >>> 30) & -4;
|
|
if (($18 | 0) < 107374) {
|
|
break label$1;
|
|
}
|
|
$15 = $10;
|
|
$10 = 0;
|
|
$8 = $6 >> 31;
|
|
$16 = Math_clz32($8 ^ $6 + $8);
|
|
$8 = $6 << $16 - 1;
|
|
$0 = $8 >> 16;
|
|
$6 = 536870911 / ($0 | 0) | 0;
|
|
$3 = ($6 >> 15) + 1 >> 1;
|
|
$14 = $6 << 16;
|
|
$6 = $14 >> 16;
|
|
$8 = 0 - ((Math_imul($6, $8 & 65535) >> 16) + Math_imul($0, $6) << 3) | 0;
|
|
$3 = ((Math_imul($8, $3) + $14 | 0) + Math_imul($8 >> 16, $6) | 0) + (Math_imul($8 & 65528, $6) >> 16) | 0;
|
|
$2 = $3 >> 31;
|
|
$19 = $3;
|
|
$20 = $2;
|
|
$6 = $1 >>> 1 | 0;
|
|
$23 = $6 >>> 0 > 1 ? $6 : 1;
|
|
$21 = 31 - $16 | 0;
|
|
while (1) {
|
|
$14 = ($10 << 2) + $13 | 0;
|
|
$6 = HEAP32[$14 >> 2];
|
|
$22 = (($10 ^ -1) + $15 << 2) + $13 | 0;
|
|
$8 = HEAP32[$22 >> 2];
|
|
$3 = $8;
|
|
$2 = $3 >> 31;
|
|
$3 = $17;
|
|
$3 = __wasm_i64_mul($8, $2, $12, $3);
|
|
$7 = $3;
|
|
$2 = i64toi32_i32$HIGH_BITS;
|
|
$3 = $2 >>> 30 | 0;
|
|
$2 = ($2 & 1073741823) << 2 | $7 >>> 30;
|
|
$4 = $2 + 1 | 0;
|
|
$1 = $4 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $4;
|
|
$1 = ($1 & 1) << 31 | $3 >>> 1;
|
|
$0 = $6 - $1 | 0;
|
|
$3 = $0;
|
|
$0 = ($0 | 0) > -1;
|
|
$3 = ((($0 ? $1 : $6) ^ -2147483648) & ($0 ? $6 : $1)) > -1 ? $3 : $0 ? -2147483648 : 2147483647;
|
|
$2 = $3 >> 31;
|
|
$0 = $3;
|
|
$3 = $20;
|
|
$3 = __wasm_i64_mul($0, $2, $19, $3);
|
|
$9 = $3;
|
|
$2 = i64toi32_i32$HIGH_BITS;
|
|
$11 = $2;
|
|
$1 = $3;
|
|
$7 = $3 & 1;
|
|
$3 = 0;
|
|
$4 = $3;
|
|
$3 = $2;
|
|
$2 = $1;
|
|
$5 = ($3 & 1) << 31 | $2 >>> 1;
|
|
$0 = ($16 | 0) != 31;
|
|
$1 = $3 >> 1;
|
|
$2 = $1;
|
|
$1 = $4;
|
|
$4 = $2 + $1 | 0;
|
|
$3 = $7;
|
|
$7 = $3 + $5 | 0;
|
|
$4 = $7 >>> 0 < $5 >>> 0 ? $4 + 1 | 0 : $4;
|
|
$1 = $7;
|
|
label$8 : {
|
|
if (!$0) {
|
|
break label$8;
|
|
}
|
|
$4 = $11;
|
|
$1 = $9;
|
|
$5 = $21;
|
|
$2 = $5 & 31;
|
|
if (($5 & 63) >>> 0 >= 32) {
|
|
$3 = $4 >> 31;
|
|
$4 = $4 >> $2;
|
|
} else {
|
|
$3 = $4 >> $2;
|
|
$4 = ((1 << $2) - 1 & $4) << 32 - $2 | $1 >>> $2;
|
|
}
|
|
$2 = $4 + 1 | 0;
|
|
$7 = $2 >>> 0 < 1 ? $3 + 1 | 0 : $3;
|
|
$3 = $2;
|
|
$1 = ($7 & 1) << 31 | $3 >>> 1;
|
|
$4 = $7 >> 1;
|
|
}
|
|
$2 = $4;
|
|
$9 = $1;
|
|
$7 = $9;
|
|
$1 = $7 - -2147483648 | 0;
|
|
$2 = $1 >>> 0 < 2147483648 ? $2 + 1 | 0 : $2;
|
|
if ($2) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$14 >> 2] = $9;
|
|
$2 = $6;
|
|
$4 = $2 >> 31;
|
|
$2 = $17;
|
|
$2 = __wasm_i64_mul($6, $4, $12, $2);
|
|
$5 = $2;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$2 = $4 >>> 30 | 0;
|
|
$4 = ($4 & 1073741823) << 2 | $5 >>> 30;
|
|
$3 = $4 + 1 | 0;
|
|
$1 = $3 >>> 0 < 1 ? $2 + 1 | 0 : $2;
|
|
$2 = $3;
|
|
$6 = ($1 & 1) << 31 | $2 >>> 1;
|
|
$1 = $8 - $6 | 0;
|
|
$3 = $1;
|
|
$1 = ($1 | 0) > -1;
|
|
$2 = ((($1 ? $6 : $8) ^ -2147483648) & ($1 ? $8 : $6)) > -1 ? $3 : $1 ? -2147483648 : 2147483647;
|
|
$4 = $2 >> 31;
|
|
$1 = $2;
|
|
$2 = $20;
|
|
$2 = __wasm_i64_mul($1, $4, $19, $2);
|
|
$9 = $2;
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$11 = $4;
|
|
if ($0) {
|
|
$4 = $11;
|
|
$1 = $9;
|
|
$7 = $21;
|
|
$5 = $7 & 31;
|
|
if (($7 & 63) >>> 0 >= 32) {
|
|
$2 = $4 >> 31;
|
|
$4 = $4 >> $5;
|
|
} else {
|
|
$2 = $4 >> $5;
|
|
$4 = ((1 << $5) - 1 & $4) << 32 - $5 | $1 >>> $5;
|
|
}
|
|
$5 = $4 + 1 | 0;
|
|
$3 = $5 >>> 0 < 1 ? $2 + 1 | 0 : $2;
|
|
$2 = $5;
|
|
$9 = ($3 & 1) << 31 | $2 >>> 1;
|
|
$4 = $3 >> 1;
|
|
$5 = $4;
|
|
} else {
|
|
$3 = $9;
|
|
$1 = $3 & 1;
|
|
$2 = 0;
|
|
$0 = $2;
|
|
$4 = $11;
|
|
$2 = $4;
|
|
$7 = ($2 & 1) << 31 | $3 >>> 1;
|
|
$3 = $2 >> 1;
|
|
$4 = $3;
|
|
$3 = $0;
|
|
$5 = $3 + $4 | 0;
|
|
$2 = $1;
|
|
$1 = $7 + $2 | 0;
|
|
$9 = $1;
|
|
$5 = $1 >>> 0 < $7 >>> 0 ? $5 + 1 | 0 : $5;
|
|
}
|
|
$11 = $5;
|
|
$3 = $9;
|
|
$4 = $3 - -2147483648 | 0;
|
|
$1 = $4 >>> 0 < 2147483648 ? $5 + 1 | 0 : $5;
|
|
$3 = 0;
|
|
if ($1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$22 >> 2] = $9;
|
|
$10 = $10 + 1 | 0;
|
|
if (($23 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$10 = $15 - 1 | 0;
|
|
$8 = HEAP32[($10 << 2) + $13 >> 2];
|
|
$6 = $8 + 16773022 >>> 0 > 33546044;
|
|
$1 = $18;
|
|
$5 = $1 >> 31;
|
|
$9 = $1;
|
|
$11 = $5;
|
|
$1 = $15;
|
|
if (($1 | 0) > 1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($6) {
|
|
break label$1;
|
|
}
|
|
$1 = 0 - (HEAP32[$13 >> 2] << 7) | 0;
|
|
$5 = $1 >> 31;
|
|
$12 = $1;
|
|
$1 = __wasm_i64_mul($12, $5, $12, $5);
|
|
$2 = 0 - 0 | 0;
|
|
$5 = i64toi32_i32$HIGH_BITS;
|
|
$1 = $5 & 2147483647;
|
|
$4 = $1 + (($3 | 0) != 0) | 0;
|
|
$4 = 1073741824 - $4 | 0;
|
|
$5 = $4 >> 31;
|
|
$1 = $11;
|
|
$1 = __wasm_i64_mul($4, $5, $9, $1);
|
|
$4 = $1;
|
|
$5 = i64toi32_i32$HIGH_BITS;
|
|
$6 = (($5 & 1073741823) << 2 | $4 >>> 30) & -4;
|
|
$24 = ($6 | 0) < 107374 ? 0 : $6;
|
|
}
|
|
return $24;
|
|
}
|
|
function opus_packet_parse_impl($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0;
|
|
$15 = -1;
|
|
label$1 : {
|
|
if (!$5 | ($1 | 0) < 0) {
|
|
break label$1;
|
|
}
|
|
$15 = -4;
|
|
if (!$1) {
|
|
break label$1;
|
|
}
|
|
$16 = HEAPU8[$0 | 0];
|
|
label$2 : {
|
|
if ($16 & 128) {
|
|
$11 = (48e3 << ($16 >>> 3 & 3) >>> 0) / 400 | 0;
|
|
break label$2;
|
|
}
|
|
$11 = $16 & 8 ? 960 : 480;
|
|
if (($16 & 96) == 96) {
|
|
break label$2;
|
|
}
|
|
$9 = $16 >>> 3 & 3;
|
|
$11 = 2880;
|
|
if (($9 | 0) == 3) {
|
|
break label$2;
|
|
}
|
|
$11 = (48e3 << $9 >>> 0) / 100 | 0;
|
|
}
|
|
$10 = 1;
|
|
$9 = $0 + 1 | 0;
|
|
$8 = $1 - 1 | 0;
|
|
$12 = $8;
|
|
$13 = $16 & 3;
|
|
$17 = $13;
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
switch ($13 | 0) {
|
|
case 1:
|
|
if ($2) {
|
|
$10 = 2;
|
|
$13 = 1;
|
|
$17 = 0;
|
|
$12 = $8;
|
|
break label$6;
|
|
}
|
|
if ($8 & 1) {
|
|
break label$1;
|
|
}
|
|
$12 = $8 >>> 1 | 0;
|
|
HEAP16[$5 >> 1] = $12;
|
|
$10 = 2;
|
|
$17 = 0;
|
|
break label$5;
|
|
case 2:
|
|
if (($1 | 0) <= 1) {
|
|
HEAP16[$5 >> 1] = 65535;
|
|
return -4;
|
|
}
|
|
$13 = HEAPU8[$9 | 0];
|
|
if ($13 >>> 0 >= 252) {
|
|
$10 = 2;
|
|
if (($1 | 0) <= 2) {
|
|
HEAP16[$5 >> 1] = 65535;
|
|
return -4;
|
|
}
|
|
$13 = (HEAPU8[$0 + 2 | 0] << 2) + $13 | 0;
|
|
}
|
|
HEAP16[$5 >> 1] = $13;
|
|
$8 = $8 - $10 | 0;
|
|
if (($13 | 0) > ($8 | 0)) {
|
|
break label$1;
|
|
}
|
|
$12 = $8 - $13 | 0;
|
|
$9 = $9 + $10 | 0;
|
|
$13 = 0;
|
|
$10 = 2;
|
|
$17 = 0;
|
|
break label$7;
|
|
case 0:
|
|
break label$7;
|
|
default:
|
|
break label$8;
|
|
}
|
|
}
|
|
if (($1 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
$14 = HEAPU8[$0 + 1 | 0];
|
|
$10 = $14 & 63;
|
|
if (!$10 | Math_imul($10, $11) >>> 0 > 5760) {
|
|
break label$1;
|
|
}
|
|
$13 = $0 + 2 | 0;
|
|
$1 = $1 - 2 | 0;
|
|
$17 = 0;
|
|
label$15 : {
|
|
if (!($14 & 64)) {
|
|
$9 = $13;
|
|
break label$15;
|
|
}
|
|
while (1) {
|
|
if (($1 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$9 = HEAPU8[$13 | 0];
|
|
$12 = ($9 | 0) == 255;
|
|
$9 = ($12 ? -2 : $9) & 255;
|
|
$17 = $17 + $9 | 0;
|
|
$1 = ($9 ^ -1) + $1 | 0;
|
|
$9 = $13 + 1 | 0;
|
|
$13 = $9;
|
|
if ($12) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($1 | 0) < 0) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$13 = $14 >>> 7 ^ 1;
|
|
if ($14 & 128) {
|
|
if ($10 >>> 0 < 2) {
|
|
$8 = $1;
|
|
$12 = $1;
|
|
break label$7;
|
|
}
|
|
$19 = $10 - 1 | 0;
|
|
$14 = 0;
|
|
$12 = $1;
|
|
$8 = $1;
|
|
while (1) {
|
|
$18 = ($14 << 1) + $5 | 0;
|
|
if (($8 | 0) <= 0) {
|
|
HEAP16[$18 >> 1] = 65535;
|
|
return -4;
|
|
}
|
|
$11 = 1;
|
|
$1 = HEAPU8[$9 | 0];
|
|
if ($1 >>> 0 >= 252) {
|
|
if (($8 | 0) <= 1) {
|
|
HEAP16[$18 >> 1] = 65535;
|
|
return -4;
|
|
}
|
|
$11 = 2;
|
|
$1 = (HEAPU8[$9 + 1 | 0] << 2) + $1 | 0;
|
|
}
|
|
HEAP16[$18 >> 1] = $1;
|
|
$8 = $8 - $11 | 0;
|
|
if (($8 | 0) < ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
$9 = $9 + $11 | 0;
|
|
$12 = ($12 - $11 | 0) - $1 | 0;
|
|
$14 = $14 + 1 | 0;
|
|
if (($19 | 0) != ($14 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($12 | 0) >= 0) {
|
|
break label$7;
|
|
}
|
|
break label$1;
|
|
}
|
|
if ($2) {
|
|
$12 = $8;
|
|
$8 = $1;
|
|
break label$6;
|
|
}
|
|
$12 = ($1 | 0) / ($10 | 0) | 0;
|
|
if ((Math_imul($12, $10) | 0) != ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
if ($10 >>> 0 < 2) {
|
|
break label$5;
|
|
}
|
|
$11 = $10 - 1 | 0;
|
|
$8 = 0;
|
|
while (1) {
|
|
HEAP16[($8 << 1) + $5 >> 1] = $12;
|
|
$8 = $8 + 1 | 0;
|
|
if (($11 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$8 = $1;
|
|
}
|
|
if (!$2) {
|
|
break label$5;
|
|
}
|
|
}
|
|
$11 = (($10 << 1) + $5 | 0) - 2 | 0;
|
|
$1 = 65535;
|
|
$2 = -1;
|
|
label$26 : {
|
|
if (($8 | 0) < 1) {
|
|
break label$26;
|
|
}
|
|
$14 = HEAPU8[$9 | 0];
|
|
if ($14 >>> 0 < 252) {
|
|
$1 = $14;
|
|
$2 = 1;
|
|
break label$26;
|
|
}
|
|
$2 = -1;
|
|
if (($8 | 0) < 2) {
|
|
break label$26;
|
|
}
|
|
$1 = (HEAPU8[$9 + 1 | 0] << 2) + $14 | 0;
|
|
$2 = 2;
|
|
}
|
|
HEAP16[$11 >> 1] = $1;
|
|
$11 = $1 << 16 >> 16;
|
|
if (($11 | 0) < 0) {
|
|
break label$1;
|
|
}
|
|
$8 = $8 - $2 | 0;
|
|
if (($11 | 0) > ($8 | 0)) {
|
|
break label$1;
|
|
}
|
|
$9 = $2 + $9 | 0;
|
|
if ($13) {
|
|
if ((Math_imul($10, $11) | 0) > ($8 | 0)) {
|
|
break label$1;
|
|
}
|
|
if ($10 >>> 0 < 2) {
|
|
break label$4;
|
|
}
|
|
HEAP16[$5 >> 1] = $1;
|
|
$1 = 1;
|
|
$15 = $10 - 1 | 0;
|
|
if (($15 | 0) == 1) {
|
|
break label$4;
|
|
}
|
|
$2 = ($15 << 1) + $5 | 0;
|
|
while (1) {
|
|
HEAP16[($1 << 1) + $5 >> 1] = HEAPU16[$2 >> 1];
|
|
$1 = $1 + 1 | 0;
|
|
if (($15 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$4;
|
|
}
|
|
if (($2 + $11 | 0) > ($12 | 0)) {
|
|
break label$1;
|
|
}
|
|
break label$4;
|
|
}
|
|
if (($12 | 0) > 1275) {
|
|
break label$1;
|
|
}
|
|
HEAP16[(($10 << 1) + $5 | 0) - 2 >> 1] = $12;
|
|
}
|
|
if ($6) {
|
|
HEAP32[$6 >> 2] = $9 - $0;
|
|
}
|
|
if ($10) {
|
|
$1 = 0;
|
|
while (1) {
|
|
if ($4) {
|
|
HEAP32[($1 << 2) + $4 >> 2] = $9;
|
|
}
|
|
$9 = HEAP16[($1 << 1) + $5 >> 1] + $9 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
if (($10 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($7) {
|
|
HEAP32[$7 >> 2] = ($17 - $0 | 0) + $9;
|
|
}
|
|
if ($3) {
|
|
HEAP8[$3 | 0] = $16;
|
|
}
|
|
$15 = $10;
|
|
}
|
|
return $15;
|
|
}
|
|
function silk_LPC_analysis_filter_FLP($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0;
|
|
label$1 : {
|
|
if (($3 | 0) >= ($4 | 0)) {
|
|
label$3 : {
|
|
label$4 : {
|
|
switch ($4 - 6 | 0) {
|
|
case 0:
|
|
if (($3 | 0) < 7) {
|
|
break label$3;
|
|
}
|
|
$6 = 6;
|
|
while (1) {
|
|
$5 = $6 << 2;
|
|
$7 = $5 + $0 | 0;
|
|
$5 = $2 + $5 | 0;
|
|
HEAPF32[$7 >> 2] = HEAPF32[$5 >> 2] - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$5 - 4 >> 2] * HEAPF32[$1 >> 2]) + Math_fround(HEAPF32[$5 - 8 >> 2] * HEAPF32[$1 + 4 >> 2])) + Math_fround(HEAPF32[$5 - 12 >> 2] * HEAPF32[$1 + 8 >> 2])) + Math_fround(HEAPF32[$5 - 16 >> 2] * HEAPF32[$1 + 12 >> 2])) + Math_fround(HEAPF32[$5 - 20 >> 2] * HEAPF32[$1 + 16 >> 2])) + Math_fround(HEAPF32[$5 - 24 >> 2] * HEAPF32[$1 + 20 >> 2]));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$3;
|
|
case 2:
|
|
if (($3 | 0) < 9) {
|
|
break label$3;
|
|
}
|
|
$6 = 8;
|
|
while (1) {
|
|
$5 = $6 << 2;
|
|
$7 = $5 + $0 | 0;
|
|
$5 = $2 + $5 | 0;
|
|
HEAPF32[$7 >> 2] = HEAPF32[$5 >> 2] - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$5 - 4 >> 2] * HEAPF32[$1 >> 2]) + Math_fround(HEAPF32[$5 - 8 >> 2] * HEAPF32[$1 + 4 >> 2])) + Math_fround(HEAPF32[$5 - 12 >> 2] * HEAPF32[$1 + 8 >> 2])) + Math_fround(HEAPF32[$5 - 16 >> 2] * HEAPF32[$1 + 12 >> 2])) + Math_fround(HEAPF32[$5 - 20 >> 2] * HEAPF32[$1 + 16 >> 2])) + Math_fround(HEAPF32[$5 - 24 >> 2] * HEAPF32[$1 + 20 >> 2])) + Math_fround(HEAPF32[$5 - 28 >> 2] * HEAPF32[$1 + 24 >> 2])) + Math_fround(HEAPF32[$5 - 32 >> 2] * HEAPF32[$1 + 28 >> 2]));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$3;
|
|
case 4:
|
|
if (($3 | 0) < 11) {
|
|
break label$3;
|
|
}
|
|
$6 = 10;
|
|
while (1) {
|
|
$5 = $6 << 2;
|
|
$7 = $5 + $0 | 0;
|
|
$5 = $2 + $5 | 0;
|
|
HEAPF32[$7 >> 2] = HEAPF32[$5 >> 2] - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$5 - 4 >> 2] * HEAPF32[$1 >> 2]) + Math_fround(HEAPF32[$5 - 8 >> 2] * HEAPF32[$1 + 4 >> 2])) + Math_fround(HEAPF32[$5 - 12 >> 2] * HEAPF32[$1 + 8 >> 2])) + Math_fround(HEAPF32[$5 - 16 >> 2] * HEAPF32[$1 + 12 >> 2])) + Math_fround(HEAPF32[$5 - 20 >> 2] * HEAPF32[$1 + 16 >> 2])) + Math_fround(HEAPF32[$5 - 24 >> 2] * HEAPF32[$1 + 20 >> 2])) + Math_fround(HEAPF32[$5 - 28 >> 2] * HEAPF32[$1 + 24 >> 2])) + Math_fround(HEAPF32[$5 - 32 >> 2] * HEAPF32[$1 + 28 >> 2])) + Math_fround(HEAPF32[$5 - 36 >> 2] * HEAPF32[$1 + 32 >> 2])) + Math_fround(HEAPF32[$5 - 40 >> 2] * HEAPF32[$1 + 36 >> 2]));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$3;
|
|
case 6:
|
|
if (($3 | 0) < 13) {
|
|
break label$3;
|
|
}
|
|
$6 = 12;
|
|
while (1) {
|
|
$5 = $6 << 2;
|
|
$7 = $5 + $0 | 0;
|
|
$5 = $2 + $5 | 0;
|
|
HEAPF32[$7 >> 2] = HEAPF32[$5 >> 2] - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$5 - 4 >> 2] * HEAPF32[$1 >> 2]) + Math_fround(HEAPF32[$5 - 8 >> 2] * HEAPF32[$1 + 4 >> 2])) + Math_fround(HEAPF32[$5 - 12 >> 2] * HEAPF32[$1 + 8 >> 2])) + Math_fround(HEAPF32[$5 - 16 >> 2] * HEAPF32[$1 + 12 >> 2])) + Math_fround(HEAPF32[$5 - 20 >> 2] * HEAPF32[$1 + 16 >> 2])) + Math_fround(HEAPF32[$5 - 24 >> 2] * HEAPF32[$1 + 20 >> 2])) + Math_fround(HEAPF32[$5 - 28 >> 2] * HEAPF32[$1 + 24 >> 2])) + Math_fround(HEAPF32[$5 - 32 >> 2] * HEAPF32[$1 + 28 >> 2])) + Math_fround(HEAPF32[$5 - 36 >> 2] * HEAPF32[$1 + 32 >> 2])) + Math_fround(HEAPF32[$5 - 40 >> 2] * HEAPF32[$1 + 36 >> 2])) + Math_fround(HEAPF32[$5 - 44 >> 2] * HEAPF32[$1 + 40 >> 2])) + Math_fround(HEAPF32[$5 - 48 >> 2] * HEAPF32[$1 + 44 >> 2]));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$3;
|
|
case 10:
|
|
break label$4;
|
|
default:
|
|
break label$1;
|
|
}
|
|
}
|
|
if (($3 | 0) < 17) {
|
|
break label$3;
|
|
}
|
|
$6 = 16;
|
|
while (1) {
|
|
$5 = $6 << 2;
|
|
$7 = $5 + $0 | 0;
|
|
$5 = $2 + $5 | 0;
|
|
HEAPF32[$7 >> 2] = HEAPF32[$5 >> 2] - Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAPF32[$5 - 4 >> 2] * HEAPF32[$1 >> 2]) + Math_fround(HEAPF32[$5 - 8 >> 2] * HEAPF32[$1 + 4 >> 2])) + Math_fround(HEAPF32[$5 - 12 >> 2] * HEAPF32[$1 + 8 >> 2])) + Math_fround(HEAPF32[$5 - 16 >> 2] * HEAPF32[$1 + 12 >> 2])) + Math_fround(HEAPF32[$5 - 20 >> 2] * HEAPF32[$1 + 16 >> 2])) + Math_fround(HEAPF32[$5 - 24 >> 2] * HEAPF32[$1 + 20 >> 2])) + Math_fround(HEAPF32[$5 - 28 >> 2] * HEAPF32[$1 + 24 >> 2])) + Math_fround(HEAPF32[$5 - 32 >> 2] * HEAPF32[$1 + 28 >> 2])) + Math_fround(HEAPF32[$5 - 36 >> 2] * HEAPF32[$1 + 32 >> 2])) + Math_fround(HEAPF32[$5 - 40 >> 2] * HEAPF32[$1 + 36 >> 2])) + Math_fround(HEAPF32[$5 - 44 >> 2] * HEAPF32[$1 + 40 >> 2])) + Math_fround(HEAPF32[$5 - 48 >> 2] * HEAPF32[$1 + 44 >> 2])) + Math_fround(HEAPF32[$5 - 52 >> 2] * HEAPF32[$1 + 48 >> 2])) + Math_fround(HEAPF32[$5 - 56 >> 2] * HEAPF32[$1 + 52 >> 2])) + Math_fround(HEAPF32[$5 - 60 >> 2] * HEAPF32[$1 + 56 >> 2])) + Math_fround(HEAPF32[$5 + -64 >> 2] * HEAPF32[$1 + 60 >> 2]));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memset($0, 0, $4 << 2);
|
|
return;
|
|
}
|
|
celt_fatal(9580, 9614, 218);
|
|
abort();
|
|
}
|
|
celt_fatal(9651, 9614, 242);
|
|
abort();
|
|
}
|
|
function remove_doubling($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = Math_fround(0), $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0, $14 = Math_fround(0), $15 = 0, $16 = 0, $17 = Math_fround(0), $18 = 0, $19 = Math_fround(0), $20 = 0, $21 = 0, $22 = Math_fround(0), $23 = Math_fround(0), $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = Math_fround(0), $29 = 0, $30 = 0, $31 = 0, $32 = Math_fround(0), $33 = Math_fround(0), $34 = Math_fround(0), $35 = Math_fround(0), $36 = Math_fround(0);
|
|
$11 = HEAP32[$4 >> 2] / 2 | 0;
|
|
$20 = ($1 | 0) / 2 | 0;
|
|
$15 = ($11 | 0) < ($20 | 0) ? $11 : $20 - 1 | 0;
|
|
HEAP32[$4 >> 2] = $15;
|
|
$12 = $20 << 2;
|
|
$11 = $12 + $0 | 0;
|
|
$18 = ($3 | 0) / 2 | 0;
|
|
$29 = ($5 | 0) / -2 | 0;
|
|
$13 = __stack_pointer;
|
|
$21 = $13 - ($12 + 19 & -16) | 0;
|
|
if (($3 | 0) >= 2) {
|
|
$13 = $11 - ($15 << 2) | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$8 = HEAPF32[$11 + $0 >> 2];
|
|
$22 = Math_fround($22 + Math_fround($8 * HEAPF32[$0 + $13 >> 2]));
|
|
$14 = Math_fround($14 + Math_fround($8 * $8));
|
|
$5 = $5 + 1 | 0;
|
|
if (($18 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$21 >> 2] = $14;
|
|
if (($1 | 0) >= 2) {
|
|
$5 = 1;
|
|
$8 = $14;
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$9 = HEAPF32[$11 - $0 >> 2];
|
|
$10 = Math_fround($8 + Math_fround($9 * $9));
|
|
$8 = HEAPF32[($18 - $5 << 2) + $11 >> 2];
|
|
$8 = Math_fround($10 - Math_fround($8 * $8));
|
|
HEAPF32[$0 + $21 >> 2] = Math_max($8, Math_fround(0));
|
|
$0 = ($5 | 0) != ($20 | 0);
|
|
$5 = $5 + 1 | 0;
|
|
if ($0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$24 = ($2 | 0) / 2 | 0;
|
|
$30 = $24 << 1;
|
|
$31 = Math_imul($24, 3);
|
|
$32 = Math_fround($6 * Math_fround(.5));
|
|
$25 = $15 << 1;
|
|
$23 = HEAPF32[($15 << 2) + $21 >> 2];
|
|
$19 = Math_fround($22 / Math_fround(Math_sqrt(Math_fround(Math_fround($14 * $23) + Math_fround(1)))));
|
|
$33 = Math_fround($19 * Math_fround(.8500000238418579));
|
|
$34 = Math_fround($19 * Math_fround(.8999999761581421));
|
|
$35 = Math_fround($19 * Math_fround(.699999988079071));
|
|
$12 = 2;
|
|
$7 = $15;
|
|
while (1) {
|
|
$5 = $12 << 1;
|
|
$16 = ($12 + $25 >>> 0) / ($5 >>> 0) | 0;
|
|
if (($24 | 0) <= ($16 | 0)) {
|
|
label$8 : {
|
|
if (($12 | 0) == 2) {
|
|
$5 = $15 + $16 | 0;
|
|
$5 = ($5 | 0) > ($20 | 0) ? $15 : $5;
|
|
break label$8;
|
|
}
|
|
$5 = (Math_imul(HEAP32[($12 << 2) + 9808 >> 2], $25) + $12 >>> 0) / ($5 >>> 0) | 0;
|
|
}
|
|
$26 = $5 << 2;
|
|
$27 = $16 << 2;
|
|
$8 = Math_fround(0);
|
|
label$10 : {
|
|
if (($3 | 0) < 2) {
|
|
$9 = Math_fround(0);
|
|
break label$10;
|
|
}
|
|
$13 = $11 - $26 | 0;
|
|
$1 = $11 - $27 | 0;
|
|
$5 = 0;
|
|
$9 = Math_fround(0);
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$10 = HEAPF32[$11 + $0 >> 2];
|
|
$8 = Math_fround($8 + Math_fround($10 * HEAPF32[$0 + $13 >> 2]));
|
|
$9 = Math_fround($9 + Math_fround($10 * HEAPF32[$0 + $1 >> 2]));
|
|
$5 = $5 + 1 | 0;
|
|
if (($18 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = Math_fround(Math_fround($9 + $8) * Math_fround(.5));
|
|
$28 = Math_fround(Math_fround(HEAPF32[$21 + $27 >> 2] + HEAPF32[$21 + $26 >> 2]) * Math_fround(.5));
|
|
$10 = Math_fround(Math_sqrt(Math_fround(Math_fround($14 * $28) + Math_fround(1))));
|
|
$10 = Math_fround($9 / $10);
|
|
$36 = $10;
|
|
$17 = $33;
|
|
$5 = $16 + $29 | 0;
|
|
$0 = $5;
|
|
$8 = $6;
|
|
$5 = $5 >> 31;
|
|
$5 = $5 ^ $5 + $0;
|
|
label$13 : {
|
|
if (($5 | 0) < 2) {
|
|
break label$13;
|
|
}
|
|
$8 = Math_fround(0);
|
|
if (($5 | 0) != 2) {
|
|
break label$13;
|
|
}
|
|
$8 = (Math_imul(Math_imul($12, $12), 5) | 0) < ($15 | 0) ? $32 : Math_fround(0);
|
|
}
|
|
$17 = Math_fround(Math_max(Math_fround($17 - $8), Math_fround(.4000000059604645)));
|
|
label$14 : {
|
|
if (($16 | 0) < ($31 | 0)) {
|
|
break label$14;
|
|
}
|
|
$17 = Math_fround(Math_max(Math_fround($35 - $8), Math_fround(.30000001192092896)));
|
|
if (($16 | 0) >= ($30 | 0)) {
|
|
break label$14;
|
|
}
|
|
$17 = Math_fround(Math_max(Math_fround($34 - $8), Math_fround(.5)));
|
|
}
|
|
$8 = $17;
|
|
if (!($36 > $8 ^ 1)) {
|
|
$7 = $16;
|
|
$23 = $28;
|
|
$22 = $9;
|
|
$19 = $10;
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != 16) {
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
$8 = Math_fround(0);
|
|
$14 = Math_fround(1);
|
|
$9 = Math_fround(Math_max($22, Math_fround(0)));
|
|
if (!($23 <= $9)) {
|
|
$14 = Math_fround($9 / Math_fround($23 + Math_fround(1)));
|
|
}
|
|
label$17 : {
|
|
if (($3 | 0) < 2) {
|
|
$9 = Math_fround(0);
|
|
$10 = Math_fround(0);
|
|
break label$17;
|
|
}
|
|
$13 = ($11 - ($7 << 2) | 0) + 4 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$8 = Math_fround($8 + Math_fround(HEAPF32[$11 + $0 >> 2] * HEAPF32[$0 + $13 >> 2]));
|
|
$5 = $5 + 1 | 0;
|
|
if (($18 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$9 = Math_fround(0);
|
|
if (($3 | 0) <= 1) {
|
|
$10 = Math_fround(0);
|
|
break label$17;
|
|
}
|
|
$13 = $11 - ($7 << 2) | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$9 = Math_fround($9 + Math_fround(HEAPF32[$11 + $0 >> 2] * HEAPF32[$0 + $13 >> 2]));
|
|
$5 = $5 + 1 | 0;
|
|
if (($18 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$10 = Math_fround(0);
|
|
if (($3 | 0) < 2) {
|
|
break label$17;
|
|
}
|
|
$13 = (($7 ^ -1) << 2) + $11 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$10 = Math_fround($10 + Math_fround(HEAPF32[$11 + $0 >> 2] * HEAPF32[$0 + $13 >> 2]));
|
|
$5 = $5 + 1 | 0;
|
|
if (($18 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = 1;
|
|
$5 = Math_fround($10 - $8) > Math_fround(Math_fround($9 - $8) * Math_fround(.699999988079071)) ? $5 : Math_fround($8 - $10) > Math_fround(Math_fround($9 - $10) * Math_fround(.699999988079071)) ? -1 : 0;
|
|
$5 = $5 + ($7 << 1) | 0;
|
|
HEAP32[$4 >> 2] = ($2 | 0) > ($5 | 0) ? $2 : $5;
|
|
return $14 > $19 ? $19 : $14;
|
|
}
|
|
function quant_partition($0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = Math_fround(0), $18 = 0, $19 = 0, $20 = 0, $21 = 0;
|
|
$13 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $13;
|
|
HEAP32[$13 + 24 >> 2] = $8;
|
|
HEAP32[$13 + 28 >> 2] = $3;
|
|
$9 = HEAP32[$0 + 8 >> 2];
|
|
$10 = HEAP32[$9 + 100 >> 2] + HEAP16[HEAP32[$9 + 96 >> 2] + (HEAP32[$0 + 12 >> 2] + Math_imul(HEAP32[$9 + 8 >> 2], $6 + 1 | 0) << 1) >> 1] | 0;
|
|
$9 = HEAPU8[$10 | 0];
|
|
$15 = -1;
|
|
$18 = HEAP32[$0 + 28 >> 2];
|
|
$19 = HEAP32[$0 + 20 >> 2];
|
|
$20 = HEAP32[$0 >> 2];
|
|
label$1 : {
|
|
if (!(($6 | 0) == -1 | ($2 | 0) < 3 | (HEAPU8[$9 + $10 | 0] + 12 | 0) >= ($3 | 0))) {
|
|
$9 = $6 - 1 | 0;
|
|
$3 = $2 >>> 1 | 0;
|
|
$2 = ($3 << 2) + $1 | 0;
|
|
if (($4 | 0) == 1) {
|
|
HEAP32[$13 + 24 >> 2] = $8 & 1 | $8 << 1;
|
|
}
|
|
$14 = $4 + 1 >> 1;
|
|
compute_theta($0, $13, $1, $2, $3, $13 + 28 | 0, $14, $4, $9, 0, $13 + 24 | 0);
|
|
$16 = Math_fround(HEAP32[$13 + 8 >> 2]);
|
|
$17 = Math_fround(HEAP32[$13 + 4 >> 2]);
|
|
$8 = HEAP32[$13 + 20 >> 2];
|
|
$10 = HEAP32[$13 + 12 >> 2];
|
|
$15 = HEAP32[$13 + 16 >> 2];
|
|
$11 = $10;
|
|
label$4 : {
|
|
if (!($15 & 16383) | ($4 | 0) < 2) {
|
|
break label$4;
|
|
}
|
|
$11 = $10 - ($10 >> 5 - $6) | 0;
|
|
if (($15 | 0) >= 8193) {
|
|
break label$4;
|
|
}
|
|
$6 = ($3 << 3 >> 6 - $6) + $10 | 0;
|
|
$11 = $6 & $6 >> 31;
|
|
}
|
|
$10 = $11;
|
|
$16 = Math_fround($16 * Math_fround(30517578125e-15));
|
|
$17 = Math_fround($17 * Math_fround(30517578125e-15));
|
|
$6 = HEAP32[$13 + 28 >> 2];
|
|
$8 = HEAP32[$0 + 32 >> 2] - $8 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $8;
|
|
$12 = $5 ? ($3 << 2) + $5 | 0 : 0;
|
|
$10 = ($6 - $10 | 0) / 2 | 0;
|
|
$10 = ($6 | 0) < ($10 | 0) ? $6 : $10;
|
|
$10 = ($10 | 0) > 0 ? $10 : 0;
|
|
$6 = $6 - $10 | 0;
|
|
if (($6 | 0) <= ($10 | 0)) {
|
|
$11 = HEAP32[$13 + 24 >> 2];
|
|
$1 = quant_partition($0, $1, $3, $10, $14, $5, $9, Math_fround($17 * $7), $11);
|
|
$10 = (HEAP32[$0 + 32 >> 2] - $8 | 0) + $10 | 0;
|
|
$9 = $1 | quant_partition($0, $2, $3, ($15 ? ($10 | 0) > 24 ? $10 - 24 | 0 : 0 : 0) + $6 | 0, $14, $12, $9, Math_fround($16 * $7), $11 >> $14) << ($4 >> 1);
|
|
break label$1;
|
|
}
|
|
$11 = HEAP32[$13 + 24 >> 2];
|
|
$2 = quant_partition($0, $2, $3, $6, $14, $12, $9, Math_fround($16 * $7), $11 >> $14);
|
|
$6 = (HEAP32[$0 + 32 >> 2] - $8 | 0) + $6 | 0;
|
|
$9 = quant_partition($0, $1, $3, (($15 | 0) != 16384 ? ($6 | 0) > 24 ? $6 - 24 | 0 : 0 : 0) + $10 | 0, $14, $5, $9, Math_fround($17 * $7), $11) | $2 << ($4 >> 1);
|
|
break label$1;
|
|
}
|
|
$6 = $3 - 1 | 0;
|
|
$12 = $9 + 1 >>> 1 | 0;
|
|
$3 = ($6 | 0) > HEAPU8[$12 + $10 | 0];
|
|
$9 = $3 ? $9 : $12;
|
|
$11 = $9;
|
|
$12 = $3 ? $12 : 0;
|
|
$3 = ($12 + $9 | 0) + 1 >>> 1 | 0;
|
|
$9 = HEAPU8[$10 + $3 | 0] < ($6 | 0);
|
|
$11 = $9 ? $11 : $3;
|
|
$9 = $9 ? $3 : $12;
|
|
$3 = ($11 + $9 | 0) + 1 >>> 1 | 0;
|
|
$12 = HEAPU8[$10 + $3 | 0] < ($6 | 0);
|
|
$9 = $12 ? $3 : $9;
|
|
$11 = $12 ? $11 : $3;
|
|
$3 = ($9 + $11 | 0) + 1 >>> 1 | 0;
|
|
$12 = HEAPU8[$10 + $3 | 0] < ($6 | 0);
|
|
$9 = $12 ? $3 : $9;
|
|
$11 = $12 ? $11 : $3;
|
|
$3 = ($9 + $11 | 0) + 1 >> 1;
|
|
$12 = HEAPU8[$10 + $3 | 0] < ($6 | 0);
|
|
$11 = $12 ? $11 : $3;
|
|
$21 = $11;
|
|
$12 = $12 ? $3 : $9;
|
|
$3 = ($11 + $12 | 0) + 1 >> 1;
|
|
$11 = HEAPU8[$10 + $3 | 0] < ($6 | 0);
|
|
$9 = $11 ? $21 : $3;
|
|
$3 = $11 ? $3 : $12;
|
|
if ($3) {
|
|
$15 = HEAPU8[$3 + $10 | 0];
|
|
}
|
|
$3 = ($6 - $15 | 0) > (HEAPU8[$9 + $10 | 0] - $6 | 0) ? $9 : $3;
|
|
if ($3) {
|
|
$14 = HEAPU8[$3 + $10 | 0] + 1 | 0;
|
|
}
|
|
$9 = HEAP32[$0 + 32 >> 2] - $14 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $9;
|
|
label$9 : {
|
|
label$10 : {
|
|
if (($9 | 0) > -1) {
|
|
$6 = $3;
|
|
break label$10;
|
|
}
|
|
if (($3 | 0) < 1) {
|
|
$6 = $3;
|
|
break label$10;
|
|
}
|
|
while (1) {
|
|
$9 = $9 + $14 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $9;
|
|
$6 = $3 - 1 | 0;
|
|
if (!$6) {
|
|
HEAP32[$0 + 32 >> 2] = $9;
|
|
break label$9;
|
|
}
|
|
$14 = HEAPU8[$6 + $10 | 0] + 1 | 0;
|
|
$9 = $9 - $14 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $9;
|
|
if (($9 | 0) > -1) {
|
|
break label$10;
|
|
}
|
|
$15 = ($3 | 0) > 1;
|
|
$3 = $6;
|
|
if ($15) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$6) {
|
|
break label$9;
|
|
}
|
|
$6 = ($6 | 0) >= 8 ? ($6 & 7 | 8) << ($6 >>> 3 | 0) - 1 : $6;
|
|
if ($20) {
|
|
$9 = alg_quant($1, $2, $6, $19, $4, $18, $7, HEAP32[$0 + 4 >> 2], HEAP32[$0 + 44 >> 2]);
|
|
break label$1;
|
|
}
|
|
$9 = alg_unquant($1, $2, $6, $19, $4, $18, $7);
|
|
break label$1;
|
|
}
|
|
if (!HEAP32[$0 + 4 >> 2]) {
|
|
$9 = 0;
|
|
break label$1;
|
|
}
|
|
$9 = -1 << $4 ^ -1;
|
|
$14 = $9 & $8;
|
|
HEAP32[$13 + 24 >> 2] = $14;
|
|
if (!$14) {
|
|
$9 = 0;
|
|
memset($1, 0, $2 << 2);
|
|
break label$1;
|
|
}
|
|
label$19 : {
|
|
if ($5) {
|
|
if (($2 | 0) >= 1) {
|
|
$3 = HEAP32[$0 + 40 >> 2];
|
|
$6 = 0;
|
|
while (1) {
|
|
$9 = $6 << 2;
|
|
$3 = Math_imul($3, 1664525) + 1013904223 | 0;
|
|
HEAPF32[$9 + $1 >> 2] = HEAPF32[$5 + $9 >> 2] + ($3 & 32768 ? Math_fround(.00390625) : Math_fround(-.00390625));
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $3;
|
|
}
|
|
$9 = $14;
|
|
break label$19;
|
|
}
|
|
if (($2 | 0) < 1) {
|
|
break label$19;
|
|
}
|
|
$3 = HEAP32[$0 + 40 >> 2];
|
|
$6 = 0;
|
|
while (1) {
|
|
$3 = Math_imul($3, 1664525) + 1013904223 | 0;
|
|
HEAPF32[($6 << 2) + $1 >> 2] = $3 >> 20;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $3;
|
|
}
|
|
renormalise_vector($1, $2, $7, HEAP32[$0 + 44 >> 2]);
|
|
}
|
|
__stack_pointer = $13 + 32 | 0;
|
|
return $9;
|
|
}
|
|
function pitch_search($0, $1, $2, $3, $4, $5) {
|
|
var $6 = Math_fround(0), $7 = Math_fround(0), $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = Math_fround(0), $13 = Math_fround(0), $14 = Math_fround(0), $15 = 0, $16 = 0, $17 = Math_fround(0), $18 = 0, $19 = 0, $20 = Math_fround(0), $21 = 0;
|
|
$5 = __stack_pointer;
|
|
$21 = $5;
|
|
label$1 : {
|
|
if (($2 | 0) > 0) {
|
|
if (($3 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
$11 = $2 >>> 2 | 0;
|
|
$8 = $5 - (($11 << 2) + 15 & -16) | 0;
|
|
$5 = $8;
|
|
__stack_pointer = $5;
|
|
$9 = $2 + $3 | 0;
|
|
$10 = $5 - (($9 & -4) + 15 & -16) | 0;
|
|
$5 = $10;
|
|
__stack_pointer = $5;
|
|
$15 = $3 >>> 1 | 0;
|
|
$16 = $5 - (($15 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $16;
|
|
if ($11) {
|
|
$5 = 0;
|
|
while (1) {
|
|
HEAP32[($5 << 2) + $8 >> 2] = HEAP32[($5 << 3) + $0 >> 2];
|
|
$5 = $5 + 1 | 0;
|
|
if (($11 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($9 | 0) >= 4) {
|
|
$5 = $9 >> 2;
|
|
$9 = ($5 | 0) > 1 ? $5 : 1;
|
|
$5 = 0;
|
|
while (1) {
|
|
HEAP32[($5 << 2) + $10 >> 2] = HEAP32[($5 << 3) + $1 >> 2];
|
|
$5 = $5 + 1 | 0;
|
|
if (($9 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = $3 >> 2;
|
|
celt_pitch_xcorr_c($8, $10, $16, $11, $9, $5);
|
|
$7 = Math_fround(1);
|
|
if ($11) {
|
|
$5 = 0;
|
|
while (1) {
|
|
$6 = HEAPF32[($5 << 2) + $10 >> 2];
|
|
$7 = Math_fround($7 + Math_fround($6 * $6));
|
|
$5 = $5 + 1 | 0;
|
|
if (($11 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$18 = 1;
|
|
if (($3 | 0) > 3) {
|
|
$13 = Math_fround(-1);
|
|
$5 = 0;
|
|
$14 = Math_fround(-1);
|
|
while (1) {
|
|
$8 = $5 << 2;
|
|
$6 = HEAPF32[$16 + $8 >> 2];
|
|
label$11 : {
|
|
if ($6 > Math_fround(0) ^ 1) {
|
|
break label$11;
|
|
}
|
|
$6 = Math_fround($6 * Math_fround(9.999999960041972e-13));
|
|
$6 = Math_fround($6 * $6);
|
|
if (Math_fround($12 * $6) > Math_fround($14 * $7) ^ 1) {
|
|
break label$11;
|
|
}
|
|
if (Math_fround($17 * $6) > Math_fround($13 * $7)) {
|
|
$18 = $19;
|
|
$19 = $5;
|
|
$14 = $13;
|
|
$13 = $6;
|
|
$12 = $17;
|
|
$17 = $7;
|
|
break label$11;
|
|
}
|
|
$18 = $5;
|
|
$14 = $6;
|
|
$12 = $7;
|
|
}
|
|
$6 = HEAPF32[($5 + $11 << 2) + $10 >> 2];
|
|
$20 = Math_fround($6 * $6);
|
|
$6 = HEAPF32[$10 + $8 >> 2];
|
|
$7 = Math_fround(Math_max(Math_fround($7 + Math_fround($20 - Math_fround($6 * $6))), Math_fround(1)));
|
|
$5 = $5 + 1 | 0;
|
|
if (($9 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$13 : {
|
|
if (!$15) {
|
|
$11 = $2 >> 1;
|
|
break label$13;
|
|
}
|
|
$11 = $2 >> 1;
|
|
$18 = $18 << 1;
|
|
$19 = $19 << 1;
|
|
$9 = 0;
|
|
while (1) {
|
|
$10 = $9 << 2;
|
|
$3 = $16 + $10 | 0;
|
|
HEAP32[$3 >> 2] = 0;
|
|
$5 = $9 - $19 | 0;
|
|
$8 = $5;
|
|
$5 = $5 >> 31;
|
|
label$16 : {
|
|
if (($5 ^ $5 + $8) >= 3) {
|
|
$5 = $9 - $18 | 0;
|
|
$8 = $5;
|
|
$5 = $5 >> 31;
|
|
if (($5 ^ $5 + $8) > 2) {
|
|
break label$16;
|
|
}
|
|
}
|
|
$7 = Math_fround(0);
|
|
if (($2 | 0) >= 2) {
|
|
$8 = $1 + $10 | 0;
|
|
$5 = 0;
|
|
while (1) {
|
|
$10 = $5 << 2;
|
|
$7 = Math_fround($7 + Math_fround(HEAPF32[$10 + $0 >> 2] * HEAPF32[$10 + $8 >> 2]));
|
|
$5 = $5 + 1 | 0;
|
|
if (($11 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$3 >> 2] = Math_max($7, Math_fround(-1));
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($15 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = Math_fround(1);
|
|
if (($2 | 0) > 1) {
|
|
$5 = 0;
|
|
while (1) {
|
|
$6 = HEAPF32[($5 << 2) + $1 >> 2];
|
|
$7 = Math_fround($7 + Math_fround($6 * $6));
|
|
$5 = $5 + 1 | 0;
|
|
if (($11 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = 0;
|
|
label$22 : {
|
|
if (!$15) {
|
|
$0 = 0;
|
|
break label$22;
|
|
}
|
|
$13 = Math_fround(-1);
|
|
$17 = Math_fround(0);
|
|
$0 = 0;
|
|
$5 = 0;
|
|
$12 = Math_fround(0);
|
|
$14 = Math_fround(-1);
|
|
while (1) {
|
|
$10 = $5 << 2;
|
|
$6 = HEAPF32[$16 + $10 >> 2];
|
|
label$25 : {
|
|
if ($6 > Math_fround(0) ^ 1) {
|
|
break label$25;
|
|
}
|
|
$6 = Math_fround($6 * Math_fround(9.999999960041972e-13));
|
|
$6 = Math_fround($6 * $6);
|
|
if (Math_fround($12 * $6) > Math_fround($14 * $7) ^ 1) {
|
|
break label$25;
|
|
}
|
|
if (Math_fround($17 * $6) > Math_fround($13 * $7)) {
|
|
$0 = $5;
|
|
$14 = $13;
|
|
$13 = $6;
|
|
$12 = $17;
|
|
$17 = $7;
|
|
break label$25;
|
|
}
|
|
$14 = $6;
|
|
$12 = $7;
|
|
}
|
|
$6 = HEAPF32[($5 + $11 << 2) + $1 >> 2];
|
|
$20 = Math_fround($6 * $6);
|
|
$6 = HEAPF32[$1 + $10 >> 2];
|
|
$7 = Math_fround(Math_max(Math_fround($7 + Math_fround($20 - Math_fround($6 * $6))), Math_fround(1)));
|
|
$5 = $5 + 1 | 0;
|
|
if (($15 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($0 | 0) < 1 | ($15 - 1 | 0) <= ($0 | 0)) {
|
|
break label$22;
|
|
}
|
|
$8 = -1;
|
|
$5 = ($0 << 2) + $16 | 0;
|
|
$6 = HEAPF32[$5 + 4 >> 2];
|
|
$7 = HEAPF32[$5 - 4 >> 2];
|
|
$12 = HEAPF32[$5 >> 2];
|
|
if (Math_fround($6 - $7) > Math_fround(Math_fround($12 - $7) * Math_fround(.699999988079071))) {
|
|
break label$22;
|
|
}
|
|
$8 = Math_fround($7 - $6) > Math_fround(Math_fround($12 - $6) * Math_fround(.699999988079071));
|
|
}
|
|
HEAP32[$4 >> 2] = ($0 << 1) + $8;
|
|
__stack_pointer = $21;
|
|
return;
|
|
}
|
|
celt_fatal(9781, 9768, 302);
|
|
abort();
|
|
}
|
|
celt_fatal(9738, 9768, 303);
|
|
abort();
|
|
}
|
|
function exp_rotation($0, $1, $2, $3, $4, $5) {
|
|
var $6 = Math_fround(0), $7 = 0, $8 = Math_fround(0), $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0;
|
|
label$1 : {
|
|
if (!$5 | $4 << 1 >= ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
$9 = Math_fround(Math_fround($1 | 0) / Math_fround(Math_imul(HEAP32[($5 << 2) + 41524 >> 2], $4) + $1 | 0));
|
|
$9 = Math_fround(Math_fround($9 * $9) * Math_fround(.5));
|
|
$18 = cos(+Math_fround($9 * Math_fround(1.5707963705062866)));
|
|
$19 = cos(+Math_fround(Math_fround(Math_fround(1) - $9) * Math_fround(1.5707963705062866)));
|
|
$5 = 0;
|
|
if ($3 << 3 <= ($1 | 0)) {
|
|
$7 = $3 >> 2;
|
|
$4 = 1;
|
|
while (1) {
|
|
$5 = $4;
|
|
$4 = $4 + 1 | 0;
|
|
if ((Math_imul(Math_imul($5, $5) + $5 | 0, $3) + $7 | 0) < ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($3 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$9 = Math_fround($18);
|
|
$10 = Math_fround($19);
|
|
$14 = ($1 >>> 0) / ($3 >>> 0) | 0;
|
|
$15 = $14 - $5 | 0;
|
|
$12 = $14 - 3 | 0;
|
|
$16 = $14 - 1 | 0;
|
|
$13 = ($5 << 1 ^ -1) + $14 | 0;
|
|
$20 = ($2 | 0) > -1;
|
|
$2 = 0;
|
|
while (1) {
|
|
$11 = Math_imul($2, $14);
|
|
label$5 : {
|
|
if (!$20) {
|
|
label$7 : {
|
|
if (!$5) {
|
|
break label$7;
|
|
}
|
|
$1 = 0;
|
|
$17 = ($11 << 2) + $0 | 0;
|
|
$4 = $17;
|
|
if (($15 | 0) >= 1) {
|
|
while (1) {
|
|
$7 = ($5 << 2) + $4 | 0;
|
|
$8 = HEAPF32[$7 >> 2];
|
|
$6 = HEAPF32[$4 >> 2];
|
|
HEAPF32[$7 >> 2] = Math_fround($6 * $9) + Math_fround($8 * $10);
|
|
HEAPF32[$4 >> 2] = Math_fround($6 * $10) - Math_fround($8 * $9);
|
|
$4 = $4 + 4 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
if (($15 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($13 | 0) < 0) {
|
|
break label$7;
|
|
}
|
|
$4 = ($13 << 2) + $17 | 0;
|
|
$1 = $13;
|
|
while (1) {
|
|
$7 = ($5 << 2) + $4 | 0;
|
|
$8 = HEAPF32[$7 >> 2];
|
|
$6 = HEAPF32[$4 >> 2];
|
|
HEAPF32[$7 >> 2] = Math_fround($6 * $9) + Math_fround($8 * $10);
|
|
HEAPF32[$4 >> 2] = Math_fround($6 * $10) - Math_fround($8 * $9);
|
|
$4 = $4 - 4 | 0;
|
|
$7 = ($1 | 0) > 0;
|
|
$1 = $1 - 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = ($11 << 2) + $0 | 0;
|
|
if (($16 | 0) >= 1) {
|
|
$6 = HEAPF32[$7 >> 2];
|
|
$1 = 0;
|
|
$4 = $7;
|
|
while (1) {
|
|
$8 = HEAPF32[$4 + 4 >> 2];
|
|
HEAPF32[$4 >> 2] = Math_fround($6 * $9) - Math_fround($8 * $10);
|
|
$6 = Math_fround(Math_fround($6 * $10) + Math_fround($8 * $9));
|
|
HEAPF32[$4 + 4 >> 2] = $6;
|
|
$4 = $4 + 4 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
if (($16 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($12 | 0) < 0) {
|
|
break label$5;
|
|
}
|
|
$4 = ($12 << 2) + $7 | 0;
|
|
$1 = $12;
|
|
while (1) {
|
|
$6 = HEAPF32[$4 >> 2];
|
|
$8 = HEAPF32[$4 + 4 >> 2];
|
|
HEAPF32[$4 + 4 >> 2] = Math_fround($6 * $10) + Math_fround($8 * $9);
|
|
HEAPF32[$4 >> 2] = Math_fround($6 * $9) - Math_fround($8 * $10);
|
|
$4 = $4 - 4 | 0;
|
|
$7 = ($1 | 0) > 0;
|
|
$1 = $1 - 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$5;
|
|
}
|
|
$11 = ($11 << 2) + $0 | 0;
|
|
if (($16 | 0) >= 1) {
|
|
$6 = HEAPF32[$11 >> 2];
|
|
$1 = 0;
|
|
$4 = $11;
|
|
while (1) {
|
|
$8 = HEAPF32[$4 + 4 >> 2];
|
|
HEAPF32[$4 >> 2] = Math_fround($6 * $9) + Math_fround($8 * $10);
|
|
$6 = Math_fround(Math_fround($8 * $9) - Math_fround($6 * $10));
|
|
HEAPF32[$4 + 4 >> 2] = $6;
|
|
$4 = $4 + 4 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
if (($16 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($12 | 0) >= 0) {
|
|
$4 = ($12 << 2) + $11 | 0;
|
|
$1 = $12;
|
|
while (1) {
|
|
$6 = HEAPF32[$4 + 4 >> 2];
|
|
$8 = HEAPF32[$4 >> 2];
|
|
HEAPF32[$4 + 4 >> 2] = Math_fround($6 * $9) - Math_fround($8 * $10);
|
|
HEAPF32[$4 >> 2] = Math_fround($8 * $9) + Math_fround($6 * $10);
|
|
$4 = $4 - 4 | 0;
|
|
$7 = ($1 | 0) > 0;
|
|
$1 = $1 - 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$5) {
|
|
break label$5;
|
|
}
|
|
$1 = 0;
|
|
$4 = $11;
|
|
if (($15 | 0) >= 1) {
|
|
while (1) {
|
|
$7 = ($5 << 2) + $4 | 0;
|
|
$6 = HEAPF32[$7 >> 2];
|
|
$8 = HEAPF32[$4 >> 2];
|
|
HEAPF32[$7 >> 2] = Math_fround($6 * $10) - Math_fround($8 * $9);
|
|
HEAPF32[$4 >> 2] = Math_fround($8 * $10) + Math_fround($6 * $9);
|
|
$4 = $4 + 4 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
if (($15 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($13 | 0) < 0) {
|
|
break label$5;
|
|
}
|
|
$4 = ($13 << 2) + $11 | 0;
|
|
$1 = $13;
|
|
while (1) {
|
|
$7 = ($5 << 2) + $4 | 0;
|
|
$6 = HEAPF32[$7 >> 2];
|
|
$8 = HEAPF32[$4 >> 2];
|
|
HEAPF32[$7 >> 2] = Math_fround($6 * $10) - Math_fround($8 * $9);
|
|
HEAPF32[$4 >> 2] = Math_fround($8 * $10) + Math_fround($6 * $9);
|
|
$4 = $4 - 4 | 0;
|
|
$7 = ($1 | 0) > 0;
|
|
$1 = $1 - 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$2 = $2 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function __rem_pio2($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
$6 = __stack_pointer - 48 | 0;
|
|
__stack_pointer = $6;
|
|
label$1 : {
|
|
label$2 : {
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$4 = wasm2js_scratch_load_i32(1) | 0;
|
|
$8 = wasm2js_scratch_load_i32(0) | 0;
|
|
$3 = $4;
|
|
$7 = $4 & 2147483647;
|
|
label$3 : {
|
|
if ($7 >>> 0 <= 1074752122) {
|
|
if (($3 & 1048575) == 598523) {
|
|
break label$3;
|
|
}
|
|
if ($7 >>> 0 <= 1073928572) {
|
|
if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0) {
|
|
$0 = $0 + -1.5707963267341256;
|
|
$2 = $0 + -6.077100506506192e-11;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + -6.077100506506192e-11;
|
|
$3 = 1;
|
|
break label$1;
|
|
}
|
|
$0 = $0 + 1.5707963267341256;
|
|
$2 = $0 + 6.077100506506192e-11;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + 6.077100506506192e-11;
|
|
$3 = -1;
|
|
break label$1;
|
|
}
|
|
if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0) {
|
|
$0 = $0 + -3.1415926534682512;
|
|
$2 = $0 + -1.2154201013012384e-10;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + -1.2154201013012384e-10;
|
|
$3 = 2;
|
|
break label$1;
|
|
}
|
|
$0 = $0 + 3.1415926534682512;
|
|
$2 = $0 + 1.2154201013012384e-10;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + 1.2154201013012384e-10;
|
|
$3 = -2;
|
|
break label$1;
|
|
}
|
|
if ($7 >>> 0 <= 1075594811) {
|
|
if ($7 >>> 0 <= 1075183036) {
|
|
if (($7 | 0) == 1074977148) {
|
|
break label$3;
|
|
}
|
|
if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0) {
|
|
$0 = $0 + -4.712388980202377;
|
|
$2 = $0 + -1.8231301519518578e-10;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + -1.8231301519518578e-10;
|
|
$3 = 3;
|
|
break label$1;
|
|
}
|
|
$0 = $0 + 4.712388980202377;
|
|
$2 = $0 + 1.8231301519518578e-10;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + 1.8231301519518578e-10;
|
|
$3 = -3;
|
|
break label$1;
|
|
}
|
|
if (($7 | 0) == 1075388923) {
|
|
break label$3;
|
|
}
|
|
if (($4 | 0) > 0 ? 1 : ($4 | 0) >= 0) {
|
|
$0 = $0 + -6.2831853069365025;
|
|
$2 = $0 + -2.430840202602477e-10;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + -2.430840202602477e-10;
|
|
$3 = 4;
|
|
break label$1;
|
|
}
|
|
$0 = $0 + 6.2831853069365025;
|
|
$2 = $0 + 2.430840202602477e-10;
|
|
HEAPF64[$1 >> 3] = $2;
|
|
HEAPF64[$1 + 8 >> 3] = $0 - $2 + 2.430840202602477e-10;
|
|
$3 = -4;
|
|
break label$1;
|
|
}
|
|
if ($7 >>> 0 > 1094263290) {
|
|
break label$2;
|
|
}
|
|
}
|
|
$2 = $0 * .6366197723675814 + 6755399441055744 + -6755399441055744;
|
|
$9 = $0 + $2 * -1.5707963267341256;
|
|
$11 = $2 * 6.077100506506192e-11;
|
|
$0 = $9 - $11;
|
|
HEAPF64[$1 >> 3] = $0;
|
|
$10 = $7 >>> 20 | 0;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$5 = wasm2js_scratch_load_i32(1) | 0;
|
|
wasm2js_scratch_load_i32(0) | 0;
|
|
$5 = ($10 - ($5 >>> 20 & 2047) | 0) < 17;
|
|
if (Math_abs($2) < 2147483648) {
|
|
$3 = ~~$2;
|
|
} else {
|
|
$3 = -2147483648;
|
|
}
|
|
label$14 : {
|
|
if ($5) {
|
|
break label$14;
|
|
}
|
|
$0 = $2 * 6.077100506303966e-11;
|
|
$12 = $9 - $0;
|
|
$11 = $2 * 2.0222662487959506e-21 - ($9 - $12 - $0);
|
|
$0 = $12 - $11;
|
|
HEAPF64[$1 >> 3] = $0;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$5 = wasm2js_scratch_load_i32(1) | 0;
|
|
wasm2js_scratch_load_i32(0) | 0;
|
|
if (($10 - ($5 >>> 20 & 2047) | 0) < 50) {
|
|
$9 = $12;
|
|
break label$14;
|
|
}
|
|
$0 = $2 * 2.0222662487111665e-21;
|
|
$9 = $12 - $0;
|
|
$11 = $2 * 8.4784276603689e-32 - ($12 - $9 - $0);
|
|
$0 = $9 - $11;
|
|
HEAPF64[$1 >> 3] = $0;
|
|
}
|
|
HEAPF64[$1 + 8 >> 3] = $9 - $0 - $11;
|
|
break label$1;
|
|
}
|
|
if ($7 >>> 0 >= 2146435072) {
|
|
$0 = $0 - $0;
|
|
HEAPF64[$1 >> 3] = $0;
|
|
HEAPF64[$1 + 8 >> 3] = $0;
|
|
$3 = 0;
|
|
break label$1;
|
|
}
|
|
$5 = $4 & 1048575;
|
|
$5 = $5 | 1096810496;
|
|
wasm2js_scratch_store_i32(0, $8 | 0);
|
|
wasm2js_scratch_store_i32(1, $5 | 0);
|
|
$0 = +wasm2js_scratch_load_f64();
|
|
$3 = 0;
|
|
$5 = 1;
|
|
while (1) {
|
|
$3 = ($6 + 16 | 0) + ($3 << 3) | 0;
|
|
if (Math_abs($0) < 2147483648) {
|
|
$10 = ~~$0;
|
|
} else {
|
|
$10 = -2147483648;
|
|
}
|
|
$2 = +($10 | 0);
|
|
HEAPF64[$3 >> 3] = $2;
|
|
$0 = ($0 - $2) * 16777216;
|
|
$3 = 1;
|
|
$10 = $5 & 1;
|
|
$5 = 0;
|
|
if ($10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF64[$6 + 32 >> 3] = $0;
|
|
label$20 : {
|
|
if ($0 != 0) {
|
|
$3 = 2;
|
|
break label$20;
|
|
}
|
|
$5 = 1;
|
|
while (1) {
|
|
$3 = $5;
|
|
$5 = $3 - 1 | 0;
|
|
if (HEAPF64[($6 + 16 | 0) + ($3 << 3) >> 3] == 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = __rem_pio2_large($6 + 16 | 0, $6, ($7 >>> 20 | 0) - 1046 | 0, $3 + 1 | 0, 1);
|
|
$0 = HEAPF64[$6 >> 3];
|
|
if (($4 | 0) < -1 ? 1 : ($4 | 0) <= -1) {
|
|
HEAPF64[$1 >> 3] = -$0;
|
|
HEAPF64[$1 + 8 >> 3] = -HEAPF64[$6 + 8 >> 3];
|
|
$3 = 0 - $3 | 0;
|
|
break label$1;
|
|
}
|
|
HEAPF64[$1 >> 3] = $0;
|
|
HEAPF64[$1 + 8 >> 3] = HEAPF64[$6 + 8 >> 3];
|
|
}
|
|
__stack_pointer = $6 + 48 | 0;
|
|
return $3;
|
|
}
|
|
function silk_stereo_find_predictor($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0;
|
|
$13 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $13;
|
|
silk_sum_sqr_shift($13 + 4 | 0, $13 + 12 | 0, $1, $4);
|
|
silk_sum_sqr_shift($13, $13 + 8 | 0, $2, $4);
|
|
$6 = HEAP32[$13 + 12 >> 2];
|
|
$11 = HEAP32[$13 + 8 >> 2];
|
|
$9 = ($6 | 0) > ($11 | 0) ? $6 : $11;
|
|
$9 = $9 + ($9 & 1) | 0;
|
|
HEAP32[$13 >> 2] = HEAP32[$13 >> 2] >> $9 - $11;
|
|
$6 = HEAP32[$13 + 4 >> 2] >> $9 - $6;
|
|
HEAP32[$13 + 4 >> 2] = ($6 | 0) > 1 ? $6 : 1;
|
|
$1 = silk_inner_prod_aligned_scale($1, $2, $9, $4);
|
|
$4 = $1 >> 31;
|
|
$11 = Math_clz32($4 ^ $1 + $4);
|
|
$6 = $1 << $11 - 1;
|
|
$15 = $6;
|
|
$4 = HEAP32[$13 + 4 >> 2];
|
|
$2 = $4 >> 31;
|
|
$8 = Math_clz32($2 ^ $2 + $4);
|
|
$12 = $4 << $8 - 1;
|
|
$2 = 536870911 / ($12 >> 16) << 16 >> 16;
|
|
$6 = (Math_imul($2, $6 & 65535) >> 16) + Math_imul($6 >> 16, $2) | 0;
|
|
$10 = $6 >> 31;
|
|
$7 = $10;
|
|
$10 = $12 >> 31;
|
|
$14 = $10;
|
|
$10 = $7;
|
|
$7 = $14;
|
|
$7 = __wasm_i64_mul($6, $10, $12, $7);
|
|
$14 = $7;
|
|
$10 = i64toi32_i32$HIGH_BITS;
|
|
$12 = $15 - ((($10 & 536870911) << 3 | $14 >>> 29) & -8) | 0;
|
|
$2 = (Math_imul($12 >> 16, $2) + $6 | 0) + (Math_imul($12 & 65535, $2) >> 16) | 0;
|
|
$7 = $5;
|
|
$6 = ($11 - $8 | 0) + 16 | 0;
|
|
label$1 : {
|
|
if (($6 | 0) <= -1) {
|
|
$6 = 0 - $6 | 0;
|
|
$11 = 2147483647 >>> $6 | 0;
|
|
$8 = -2147483648 >> $6;
|
|
$2 = (($2 | 0) > ($11 | 0) ? $11 : ($2 | 0) < ($8 | 0) ? $8 : $2) << $6;
|
|
break label$1;
|
|
}
|
|
$2 = ($6 | 0) < 32 ? $2 >> $6 : 0;
|
|
}
|
|
$2 = ($2 | 0) > -16384 ? $2 : -16384;
|
|
$2 = ($2 | 0) < 16384 ? $2 : 16384;
|
|
$11 = (Math_imul($2, $2 & 65535) >> 16) + Math_imul($2 >> 16, $2) | 0;
|
|
$6 = $11 >> 31;
|
|
$6 = $6 ^ $6 + $11;
|
|
$7 = ($5 | 0) > ($6 | 0) ? $7 : $6;
|
|
$5 = $9 >> 1;
|
|
$8 = 0;
|
|
$6 = HEAP32[$3 >> 2];
|
|
$14 = $3;
|
|
$15 = $6;
|
|
label$3 : {
|
|
if (($4 | 0) <= 0) {
|
|
$9 = $7 << 16 >> 16;
|
|
$10 = Math_imul($9, 0 - $6 >> 16);
|
|
break label$3;
|
|
}
|
|
$8 = Math_clz32($4);
|
|
$10 = 24 - $8 | 0;
|
|
$17 = 0 - $10 | 0;
|
|
$12 = ($8 & 1 ? 32768 : 46214) >>> ($8 >>> 1) | 0;
|
|
$16 = $12;
|
|
$9 = $4;
|
|
label$5 : {
|
|
if (!$10) {
|
|
break label$5;
|
|
}
|
|
$9 = $4 << $17 | $4 >>> 56 - $8;
|
|
if ($4 >>> 0 <= 127) {
|
|
break label$5;
|
|
}
|
|
$9 = $4 << $8 + 8 | $4 >>> $10;
|
|
}
|
|
$16 = ((Math_imul(Math_imul($9 & 127, 13959168) >>> 16 | 0, $16) >>> 16 | 0) + $12 << $5) - $6 >> 16;
|
|
$9 = $7 << 16 >> 16;
|
|
$7 = $4;
|
|
label$6 : {
|
|
if (!$10) {
|
|
break label$6;
|
|
}
|
|
$7 = $4 << $17 | $4 >>> 56 - $8;
|
|
if ($4 >>> 0 <= 127) {
|
|
break label$6;
|
|
}
|
|
$7 = $4 << $8 + 8 | $4 >>> $10;
|
|
}
|
|
$8 = (Math_imul(Math_imul($7 & 127, 13959168) >>> 16 | 0, $12) >>> 16 | 0) + $12 | 0;
|
|
$10 = Math_imul($9, $16);
|
|
}
|
|
$6 = ($15 + $10 | 0) + (Math_imul(($8 << $5) - $6 & 65535, $9) >> 16) | 0;
|
|
HEAP32[$14 >> 2] = $6;
|
|
$7 = HEAP32[$13 >> 2] - (Math_imul($1 >> 16, $2) + (Math_imul($1 & 65535, $2) >> 16) << 4) | 0;
|
|
$1 = $11 << 16 >> 16;
|
|
$4 = $7 + ((Math_imul($1, $4 & 65535) >> 16) + Math_imul($4 >> 16, $1) << 6) | 0;
|
|
HEAP32[$13 >> 2] = $4;
|
|
$14 = $3;
|
|
$1 = HEAP32[$3 + 4 >> 2];
|
|
$3 = $1;
|
|
label$7 : {
|
|
if (($4 | 0) < 1) {
|
|
$11 = 0;
|
|
break label$7;
|
|
}
|
|
$11 = Math_clz32($4);
|
|
$12 = 24 - $11 | 0;
|
|
$7 = 0 - $12 | 0;
|
|
$8 = $4;
|
|
label$9 : {
|
|
if (!$12) {
|
|
break label$9;
|
|
}
|
|
$8 = $4 << $7 | $4 >>> 56 - $11;
|
|
if ($4 >>> 0 <= 127) {
|
|
break label$9;
|
|
}
|
|
$8 = $4 << $11 + 8 | $4 >>> $12;
|
|
}
|
|
$10 = Math_imul($8 & 127, 13959168) >>> 16 | 0;
|
|
$8 = ($11 & 1 ? 32768 : 46214) >>> ($11 >>> 1) | 0;
|
|
$10 = $8 + (Math_imul($8, $10) >>> 16 | 0) | 0;
|
|
label$10 : {
|
|
if (!$12) {
|
|
break label$10;
|
|
}
|
|
if ($4 >>> 0 <= 127) {
|
|
$4 = $4 << $7 | $4 >>> 56 - $11;
|
|
break label$10;
|
|
}
|
|
$4 = $4 << $11 + 8 | $4 >>> $12;
|
|
}
|
|
$18 = (Math_imul(Math_imul($4 & 127, 13959168) >>> 16 | 0, $8) >>> 16 | 0) + $8 | 0;
|
|
$11 = $10 << $5;
|
|
}
|
|
$4 = $18;
|
|
$4 = ($3 + Math_imul($11 - $1 >> 16, $9) | 0) + (Math_imul(($4 << $5) - $1 & 65535, $9) >> 16) | 0;
|
|
HEAP32[$14 + 4 >> 2] = $4;
|
|
$3 = $4 >> 31;
|
|
$1 = Math_clz32($3 ^ $3 + $4);
|
|
$3 = $4 << $1 - 1;
|
|
$8 = $3;
|
|
$4 = ($6 | 0) > 1 ? $6 : 1;
|
|
$9 = Math_clz32($4);
|
|
$5 = $4 << $9 - 1;
|
|
$4 = 536870911 / ($5 >> 16) << 16 >> 16;
|
|
$3 = (Math_imul($4, $3 & 65535) >> 16) + Math_imul($3 >> 16, $4) | 0;
|
|
$7 = $3 >> 31;
|
|
$10 = $7;
|
|
$7 = $5 >> 31;
|
|
$14 = $7;
|
|
$7 = $10;
|
|
$14 = __wasm_i64_mul($3, $7, $5, $14);
|
|
$10 = $14;
|
|
$7 = i64toi32_i32$HIGH_BITS;
|
|
$5 = $8 - ((($7 & 536870911) << 3 | $10 >>> 29) & -8) | 0;
|
|
$4 = (Math_imul($5 >> 16, $4) + $3 | 0) + (Math_imul($5 & 65535, $4) >> 16) | 0;
|
|
$3 = ($1 - $9 | 0) + 15 | 0;
|
|
label$12 : {
|
|
if (($3 | 0) <= -1) {
|
|
$3 = 0 - $3 | 0;
|
|
$1 = 2147483647 >>> $3 | 0;
|
|
$9 = -2147483648 >> $3;
|
|
$4 = (($1 | 0) < ($4 | 0) ? $1 : ($4 | 0) < ($9 | 0) ? $9 : $4) << $3;
|
|
break label$12;
|
|
}
|
|
$4 = ($3 | 0) < 32 ? $4 >> $3 : 0;
|
|
}
|
|
$4 = ($4 | 0) > 0 ? $4 : 0;
|
|
HEAP32[$0 >> 2] = ($4 | 0) < 32767 ? $4 : 32767;
|
|
__stack_pointer = $13 + 16 | 0;
|
|
return $2;
|
|
}
|
|
function transient_analysis($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = Math_fround(0), $9 = Math_fround(0), $10 = 0, $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = Math_fround(0), $15 = Math_fround(0), $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = Math_fround(0), $21 = 0, $22 = Math_fround(0), $23 = 0, $24 = 0, $25 = Math_fround(0), $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0;
|
|
$10 = __stack_pointer;
|
|
$21 = $10;
|
|
$10 = $10 - (($1 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $10;
|
|
HEAP32[$6 >> 2] = 0;
|
|
$16 = ($1 | 0) / 2 | 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
if (($2 | 0) < 1) {
|
|
break label$3;
|
|
}
|
|
$22 = $5 ? Math_fround(.03125) : Math_fround(.0625);
|
|
$23 = $16 - 5 | 0;
|
|
$24 = Math_imul($16, 6) - 102 | 0;
|
|
$25 = Math_fround($16 | 0);
|
|
$26 = +($16 | 0);
|
|
$27 = ($1 | 0) < 1;
|
|
$28 = $10;
|
|
$29 = $10;
|
|
$30 = $10;
|
|
$31 = $10;
|
|
$32 = $10;
|
|
$33 = ($1 | 0) < 36;
|
|
while (1) {
|
|
if (!$27) {
|
|
$12 = Math_imul($1, $18);
|
|
$13 = Math_fround(0);
|
|
$7 = 0;
|
|
$14 = Math_fround(0);
|
|
while (1) {
|
|
$9 = HEAPF32[($7 + $12 << 2) + $0 >> 2];
|
|
$8 = Math_fround($13 + $9);
|
|
HEAPF32[($7 << 2) + $10 >> 2] = $8;
|
|
$13 = Math_fround(Math_fround($14 + $8) - Math_fround($9 + $9));
|
|
$14 = Math_fround($9 + Math_fround($8 * Math_fround(-.5)));
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$10 >> 2] = 0;
|
|
HEAP32[$10 + 4 >> 2] = 0;
|
|
$7 = $28;
|
|
HEAP32[$7 + 40 >> 2] = 0;
|
|
HEAP32[$7 + 44 >> 2] = 0;
|
|
HEAP32[$29 + 32 >> 2] = 0;
|
|
HEAP32[$7 + 36 >> 2] = 0;
|
|
HEAP32[$30 + 24 >> 2] = 0;
|
|
HEAP32[$7 + 28 >> 2] = 0;
|
|
HEAP32[$31 + 16 >> 2] = 0;
|
|
HEAP32[$7 + 20 >> 2] = 0;
|
|
HEAP32[$32 + 8 >> 2] = 0;
|
|
HEAP32[$7 + 12 >> 2] = 0;
|
|
$7 = 0;
|
|
$13 = Math_fround(0);
|
|
$9 = Math_fround(0);
|
|
$20 = Math_fround(0);
|
|
$8 = Math_fround(0);
|
|
$11 = ($1 | 0) > 1;
|
|
$15 = $8;
|
|
label$7 : {
|
|
if (!$11) {
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$12 = $7 << 3;
|
|
$8 = HEAPF32[$12 + $10 >> 2];
|
|
$15 = Math_fround($8 * $8);
|
|
$8 = HEAPF32[($12 | 4) + $10 >> 2];
|
|
$8 = Math_fround($15 + Math_fround($8 * $8));
|
|
$9 = Math_fround($9 + Math_fround($22 * Math_fround($8 - $9)));
|
|
HEAPF32[($7 << 2) + $10 >> 2] = $9;
|
|
$13 = Math_fround($13 + $8);
|
|
$7 = $7 + 1 | 0;
|
|
if (($16 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = $16;
|
|
$14 = Math_fround(0);
|
|
$20 = $13;
|
|
$8 = Math_fround(0);
|
|
$15 = $8;
|
|
if (!$11) {
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$12 = $7 - 1 | 0;
|
|
$11 = ($12 << 2) + $10 | 0;
|
|
$8 = Math_fround($8 + Math_fround(Math_fround(HEAPF32[$11 >> 2] - $8) * Math_fround(.125)));
|
|
HEAPF32[$11 >> 2] = $8;
|
|
$14 = $8 < $14 ? $14 : $8;
|
|
$11 = ($7 | 0) > 1;
|
|
$7 = $12;
|
|
if ($11) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$15 = $14;
|
|
}
|
|
$8 = $15;
|
|
$9 = $20;
|
|
$13 = HEAPF32[$10 >> 2];
|
|
if ($13 != $13) {
|
|
break label$2;
|
|
}
|
|
$9 = Math_fround($25 / Math_fround(Math_fround(Math_sqrt(+Math_fround($9 * $8) * .5 * $26)) + Math_fround(1.0000000036274937e-15)));
|
|
if ($9 != $9) {
|
|
break label$1;
|
|
}
|
|
$12 = 0;
|
|
if (!$33) {
|
|
$8 = Math_fround($9 * Math_fround(64));
|
|
$7 = 12;
|
|
while (1) {
|
|
$9 = Math_fround(Math_floor(Math_fround($8 * Math_fround(HEAPF32[($7 << 2) + $10 >> 2] + Math_fround(1.0000000036274937e-15)))));
|
|
$11 = Math_fround(Math_min($9, Math_fround(127))) < Math_fround(0);
|
|
$17 = $11 ? 0 : 127;
|
|
$17 = $9 > Math_fround(127) ? $17 : $11 ? $17 : +$9;
|
|
label$12 : {
|
|
if (Math_abs($17) < 2147483648) {
|
|
$11 = ~~$17;
|
|
break label$12;
|
|
}
|
|
$11 = -2147483648;
|
|
}
|
|
$12 = HEAPU8[$11 + 42832 | 0] + $12 | 0;
|
|
$7 = $7 + 4 | 0;
|
|
if (($23 | 0) > ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = ($12 << 8) / ($24 | 0) | 0;
|
|
if (($19 | 0) < ($7 | 0)) {
|
|
HEAP32[$4 >> 2] = $18;
|
|
$19 = $7;
|
|
}
|
|
$18 = $18 + 1 | 0;
|
|
if (($18 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = ($19 | 0) > 200;
|
|
if (!$5 | $19 - 201 >>> 0 > 398) {
|
|
break label$3;
|
|
}
|
|
HEAP32[$6 >> 2] = 1;
|
|
$7 = 0;
|
|
}
|
|
HEAPF32[$3 >> 2] = Math_sqrt(Math_max(+Math_fround(Math_fround(Math_min(Math_fround(Math_max(Math_fround(Math_fround(Math_sqrt(+(Math_imul($19, 27) | 0))) + Math_fround(-42)), Math_fround(0))), Math_fround(163))) * Math_fround(.006899999920278788)) + -.139, 0));
|
|
__stack_pointer = $21;
|
|
return $7;
|
|
}
|
|
celt_fatal(42960, 42508, 369);
|
|
abort();
|
|
}
|
|
celt_fatal(42998, 42508, 370);
|
|
abort();
|
|
}
|
|
function run_prefilter($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) {
|
|
var $12 = 0, $13 = Math_fround(0), $14 = 0, $15 = 0, $16 = 0, $17 = Math_fround(0), $18 = 0, $19 = Math_fround(0), $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = Math_fround(0), $27 = 0, $28 = 0, $29 = 0;
|
|
$12 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $12;
|
|
$21 = HEAP32[$0 >> 2];
|
|
$20 = HEAP32[$21 + 4 >> 2];
|
|
$15 = $4 + 1024 | 0;
|
|
$14 = $12 - ((Math_imul($15, $3) << 2) + 15 & -16) | 0;
|
|
$18 = $14;
|
|
__stack_pointer = $14;
|
|
$16 = $12;
|
|
HEAP32[$12 + 12 >> 2] = ($15 << 2) + $14;
|
|
HEAP32[$12 + 8 >> 2] = $14;
|
|
$23 = ($3 | 0) > 1 ? $3 : 1;
|
|
$22 = $4 << 2;
|
|
$24 = $4 + $20 | 0;
|
|
$14 = ($20 << 2) + $1 | 0;
|
|
$12 = 0;
|
|
while (1) {
|
|
memcpy(memcpy(HEAP32[($16 + 8 | 0) + ($12 << 2) >> 2], ($12 << 12) + $2 | 0, 4096) + 4096 | 0, (Math_imul($12, $24) << 2) + $14 | 0, $22);
|
|
$12 = $12 + 1 | 0;
|
|
if (($23 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
label$2 : {
|
|
if ($9) {
|
|
$14 = $18;
|
|
$12 = $14 - (($15 << 1 & -4) + 15 & -16) | 0;
|
|
__stack_pointer = $12;
|
|
pitch_downsample($16 + 8 | 0, $12, $15, $3, HEAP32[$0 + 72 >> 2]);
|
|
pitch_search($12 + 2048 | 0, $12, $4, 979, $16 + 4 | 0, HEAP32[$0 + 72 >> 2]);
|
|
HEAP32[$16 + 4 >> 2] = 1024 - HEAP32[$16 + 4 >> 2];
|
|
$13 = remove_doubling($12, 1024, 15, $4, $16 + 4 | 0, HEAP32[$0 + 104 >> 2], HEAPF32[$0 + 108 >> 2], HEAP32[$0 + 72 >> 2]);
|
|
if (HEAP32[$16 + 4 >> 2] >= 1023) {
|
|
HEAP32[$16 + 4 >> 2] = 1022;
|
|
}
|
|
$13 = Math_fround($13 * Math_fround(.699999988079071));
|
|
$12 = HEAP32[$0 + 56 >> 2];
|
|
$13 = ($12 | 0) > 2 ? Math_fround($13 * Math_fround(.5)) : $13;
|
|
$13 = ($12 | 0) > 8 ? Math_fround(0) : ($12 | 0) > 4 ? Math_fround($13 * Math_fround(.5)) : $13;
|
|
break label$2;
|
|
}
|
|
HEAP32[$16 + 4 >> 2] = 15;
|
|
$13 = Math_fround(0);
|
|
}
|
|
$12 = HEAP32[$16 + 4 >> 2];
|
|
$3 = HEAP32[$0 + 104 >> 2];
|
|
$14 = $12 - $3 | 0;
|
|
$9 = $14;
|
|
$13 = HEAP32[$11 >> 2] ? Math_fround($13 * HEAPF32[$11 + 40 >> 2]) : $13;
|
|
$14 = $14 >> 31;
|
|
$17 = (Math_imul($14 ^ $14 + $9, 10) | 0) > ($12 | 0) ? Math_fround(.4000000059604645) : Math_fround(.20000000298023224);
|
|
$17 = ($10 | 0) < 25 ? Math_fround($17 + Math_fround(.10000000149011612)) : $17;
|
|
$19 = ($10 | 0) < 35 ? Math_fround($17 + Math_fround(.10000000149011612)) : $17;
|
|
$17 = HEAPF32[$0 + 108 >> 2];
|
|
$19 = $17 > Math_fround(.4000000059604645) ? Math_fround($19 + Math_fround(-.10000000149011612)) : $19;
|
|
$19 = $17 > Math_fround(.550000011920929) ? Math_fround($19 + Math_fround(-.10000000149011612)) : $19;
|
|
if (!($13 < ($19 > Math_fround(.20000000298023224) ? $19 : Math_fround(.20000000298023224)))) {
|
|
$27 = 1;
|
|
$13 = Math_fround(Math_floor(Math_fround(Math_fround(Math_fround((Math_fround(Math_abs(Math_fround($13 - $17))) < Math_fround(.10000000149011612) ? $17 : $13) * Math_fround(32)) / Math_fround(3)) + Math_fround(.5))));
|
|
label$8 : {
|
|
if (Math_fround(Math_abs($13)) < Math_fround(2147483648)) {
|
|
$12 = ~~$13;
|
|
break label$8;
|
|
}
|
|
$12 = -2147483648;
|
|
}
|
|
$12 = ($12 | 0) > 7 ? 7 : $12 - 1 | 0;
|
|
$25 = ($12 | 0) > 0 ? $12 : 0;
|
|
$26 = Math_fround(Math_fround($25 + 1 | 0) * Math_fround(.09375));
|
|
}
|
|
$28 = 4096 - $22 | 0;
|
|
$14 = $20 << 2;
|
|
$17 = Math_fround(-$26);
|
|
$9 = ($4 | 0) < 1025;
|
|
$29 = 0 - $4 << 2;
|
|
$12 = 0;
|
|
while (1) {
|
|
$15 = HEAP32[$21 + 44 >> 2];
|
|
HEAP32[$0 + 104 >> 2] = ($3 | 0) > 15 ? $3 : 15;
|
|
$10 = ((Math_imul($12, $20) << 2) + $0 | 0) + 244 | 0;
|
|
$3 = memcpy((Math_imul($12, $24) << 2) + $1 | 0, $10, $14);
|
|
$15 = $15 - $20 | 0;
|
|
if ($15) {
|
|
$11 = HEAP32[$0 + 104 >> 2];
|
|
$13 = Math_fround(-HEAPF32[$0 + 108 >> 2]);
|
|
$18 = HEAP32[$0 + 112 >> 2];
|
|
comb_filter($3 + $14 | 0, HEAP32[($16 + 8 | 0) + ($12 << 2) >> 2] + 4096 | 0, $11, $11, $15, $13, $13, $18, $18, 0, 0, HEAP32[$0 + 72 >> 2]);
|
|
}
|
|
$11 = $15 << 2;
|
|
$18 = ($16 + 8 | 0) + ($12 << 2) | 0;
|
|
comb_filter($11 + ($3 + $14 | 0) | 0, (HEAP32[$18 >> 2] + $11 | 0) + 4096 | 0, HEAP32[$0 + 104 >> 2], HEAP32[$16 + 4 >> 2], $4 - $15 | 0, Math_fround(-HEAPF32[$0 + 108 >> 2]), $17, HEAP32[$0 + 112 >> 2], $5, HEAP32[$21 + 60 >> 2], $20, HEAP32[$0 + 72 >> 2]);
|
|
$15 = $4 << 2;
|
|
memcpy($10, $15 + $3 | 0, $14);
|
|
$3 = ($12 << 12) + $2 | 0;
|
|
label$12 : {
|
|
if (!$9) {
|
|
memcpy($3, HEAP32[$18 >> 2] + $15 | 0, 4096);
|
|
break label$12;
|
|
}
|
|
memcpy((memmove($3, $3 + $15 | 0, $28) + $29 | 0) + 4096 | 0, HEAP32[$18 >> 2] + 4096 | 0, $22);
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if (($23 | 0) != ($12 | 0)) {
|
|
$3 = HEAP32[$0 + 104 >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAPF32[$7 >> 2] = $26;
|
|
HEAP32[$6 >> 2] = HEAP32[$16 + 4 >> 2];
|
|
HEAP32[$8 >> 2] = $25;
|
|
__stack_pointer = $16 + 16 | 0;
|
|
return $27;
|
|
}
|
|
function opus_repacketizer_out_range_impl($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
|
|
$7 = -1;
|
|
label$1 : {
|
|
if (($1 | 0) < 0 | ($1 | 0) >= ($2 | 0) | HEAP32[$0 + 4 >> 2] < ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
$10 = $2 - $1 | 0;
|
|
$11 = (($1 << 1) + $0 | 0) + 200 | 0;
|
|
$8 = $5 ? HEAP16[(($10 << 1) + $11 | 0) - 2 >> 1] > 251 ? 2 : 1 : 0;
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
switch ($10 - 1 | 0) {
|
|
case 0:
|
|
$7 = -2;
|
|
$8 = (HEAP16[$11 >> 1] + $8 | 0) + 1 | 0;
|
|
if (($8 | 0) > ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP8[$3 | 0] = HEAPU8[$0 | 0] & 252;
|
|
$7 = $3 + 1 | 0;
|
|
break label$6;
|
|
case 1:
|
|
$7 = HEAPU16[$11 >> 1];
|
|
$9 = $7 << 16 >> 16;
|
|
$12 = HEAPU16[$11 + 2 >> 1];
|
|
if (($12 | 0) == ($7 | 0)) {
|
|
$7 = -2;
|
|
$8 = ($9 << 1 | 1) + $8 | 0;
|
|
if (($8 | 0) > ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP8[$3 | 0] = HEAPU8[$0 | 0] & 252 | 1;
|
|
$7 = $3 + 1 | 0;
|
|
break label$6;
|
|
}
|
|
$7 = -2;
|
|
$8 = (((($12 << 16 >> 16) + $8 | 0) + $9 | 0) + (($9 | 0) > 251) | 0) + 2 | 0;
|
|
if (($8 | 0) > ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP8[$3 | 0] = HEAPU8[$0 | 0] & 252 | 2;
|
|
$7 = $3 + 1 | 0;
|
|
$7 = $7 + encode_size(HEAP16[$11 >> 1], $7) | 0;
|
|
break label$6;
|
|
default:
|
|
break label$7;
|
|
}
|
|
}
|
|
$7 = $3;
|
|
if (($10 | 0) > 2) {
|
|
break label$5;
|
|
}
|
|
}
|
|
if (!$6 | ($4 | 0) <= ($8 | 0)) {
|
|
break label$4;
|
|
}
|
|
}
|
|
$12 = $5 ? HEAP16[(($10 << 1) + $11 | 0) - 2 >> 1] > 251 ? 4 : 3 : 2;
|
|
$7 = 1;
|
|
$9 = HEAP16[$11 >> 1];
|
|
label$13 : {
|
|
label$14 : {
|
|
if (($10 | 0) <= 1) {
|
|
break label$14;
|
|
}
|
|
$8 = $9 & 65535;
|
|
while (1) {
|
|
if (HEAPU16[($7 << 1) + $11 >> 1] == ($8 | 0)) {
|
|
$7 = $7 + 1 | 0;
|
|
if (($10 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break label$14;
|
|
}
|
|
break;
|
|
}
|
|
$7 = 1;
|
|
$8 = ($9 + $12 | 0) + (($9 | 0) > 251 ? 2 : 1) | 0;
|
|
$13 = $10 - 1 | 0;
|
|
$12 = ($1 ^ -1) + $2 | 0;
|
|
if (($12 | 0) >= 2) {
|
|
while (1) {
|
|
$9 = HEAP16[($7 << 1) + $11 >> 1];
|
|
$8 = ($9 + $8 | 0) + (($9 | 0) > 251 ? 2 : 1) | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($12 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = -2;
|
|
$8 = HEAP16[($13 << 1) + $11 >> 1] + $8 | 0;
|
|
if (($8 | 0) > ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
$7 = HEAPU8[$0 | 0];
|
|
$9 = $10 | -128;
|
|
HEAP8[$3 + 1 | 0] = $9;
|
|
HEAP8[$3 | 0] = $7 | 3;
|
|
$7 = 0;
|
|
break label$13;
|
|
}
|
|
$7 = -2;
|
|
$8 = Math_imul($9, $10) + $12 | 0;
|
|
if (($8 | 0) > ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
$7 = HEAPU8[$0 | 0];
|
|
HEAP8[$3 + 1 | 0] = $10;
|
|
HEAP8[$3 | 0] = $7 | 3;
|
|
$9 = $10;
|
|
$7 = 1;
|
|
}
|
|
$13 = $7;
|
|
$7 = $3 + 2 | 0;
|
|
label$19 : {
|
|
if (!$6) {
|
|
break label$19;
|
|
}
|
|
$12 = $4 - $8 | 0;
|
|
if (!$12) {
|
|
break label$19;
|
|
}
|
|
HEAP8[$3 + 1 | 0] = $9 | 64;
|
|
$14 = ($12 - 1 | 0) / 255 | 0;
|
|
if (($12 | 0) >= 256) {
|
|
$9 = ($14 | 0) > 1 ? $14 : 1;
|
|
memset($7, 255, $9);
|
|
$8 = 0;
|
|
while (1) {
|
|
$7 = $7 + 1 | 0;
|
|
$8 = $8 + 1 | 0;
|
|
if (($9 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP8[$7 | 0] = (Math_imul($14, -255) + $12 | 0) - 1;
|
|
$7 = $7 + 1 | 0;
|
|
$8 = $4;
|
|
}
|
|
if (($10 | 0) < 2 | $13) {
|
|
break label$4;
|
|
}
|
|
$2 = ($1 ^ -1) + $2 | 0;
|
|
$9 = ($2 | 0) > 1 ? $2 : 1;
|
|
$2 = 0;
|
|
while (1) {
|
|
$7 = encode_size(HEAP16[($2 << 1) + $11 >> 1], $7) + $7 | 0;
|
|
$2 = $2 + 1 | 0;
|
|
if (($9 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($5) {
|
|
$7 = encode_size(HEAP16[(($10 << 1) + $11 | 0) - 2 >> 1], $7) + $7 | 0;
|
|
}
|
|
if (($10 | 0) >= 1) {
|
|
$0 = (($1 << 2) + $0 | 0) + 8 | 0;
|
|
$1 = 0;
|
|
while (1) {
|
|
$2 = ($1 << 1) + $11 | 0;
|
|
$7 = memmove($7, HEAP32[($1 << 2) + $0 >> 2], HEAP16[$2 >> 1]) + HEAP16[$2 >> 1] | 0;
|
|
$1 = $1 + 1 | 0;
|
|
if (($10 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!(!$6 | $3 + $4 >>> 0 <= $7 >>> 0)) {
|
|
memset($7, 0, ($4 - $7 | 0) + $3 | 0);
|
|
}
|
|
$7 = $8;
|
|
}
|
|
return $7;
|
|
}
|
|
function try_realloc_chunk($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$6 = HEAP32[$0 + 4 >> 2];
|
|
$3 = $6 & 3;
|
|
$5 = $6 & -8;
|
|
$2 = $5 + $0 | 0;
|
|
label$2 : {
|
|
if (!$3) {
|
|
$3 = 0;
|
|
if ($1 >>> 0 < 256) {
|
|
break label$2;
|
|
}
|
|
if ($1 + 4 >>> 0 <= $5 >>> 0) {
|
|
$3 = $0;
|
|
if ($5 - $1 >>> 0 <= HEAP32[13352] << 1 >>> 0) {
|
|
break label$2;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
label$5 : {
|
|
if ($1 >>> 0 <= $5 >>> 0) {
|
|
$3 = $5 - $1 | 0;
|
|
if ($3 >>> 0 < 16) {
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $6 & 1 | $1 | 2;
|
|
$1 = $0 + $1 | 0;
|
|
HEAP32[$1 + 4 >> 2] = $3 | 3;
|
|
HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] | 1;
|
|
dispose_chunk($1, $3);
|
|
break label$5;
|
|
}
|
|
$3 = 0;
|
|
if (HEAP32[13238] == ($2 | 0)) {
|
|
$2 = HEAP32[13235] + $5 | 0;
|
|
if ($2 >>> 0 <= $1 >>> 0) {
|
|
break label$2;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $6 & 1 | $1 | 2;
|
|
$3 = $0 + $1 | 0;
|
|
$1 = $2 - $1 | 0;
|
|
HEAP32[$3 + 4 >> 2] = $1 | 1;
|
|
HEAP32[13235] = $1;
|
|
HEAP32[13238] = $3;
|
|
break label$5;
|
|
}
|
|
if (HEAP32[13237] == ($2 | 0)) {
|
|
$2 = HEAP32[13234] + $5 | 0;
|
|
if ($2 >>> 0 < $1 >>> 0) {
|
|
break label$2;
|
|
}
|
|
$3 = $2 - $1 | 0;
|
|
label$9 : {
|
|
if ($3 >>> 0 >= 16) {
|
|
HEAP32[$0 + 4 >> 2] = $6 & 1 | $1 | 2;
|
|
$1 = $0 + $1 | 0;
|
|
HEAP32[$1 + 4 >> 2] = $3 | 1;
|
|
$2 = $0 + $2 | 0;
|
|
HEAP32[$2 >> 2] = $3;
|
|
HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] & -2;
|
|
break label$9;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $6 & 1 | $2 | 2;
|
|
$1 = $0 + $2 | 0;
|
|
HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
|
|
$3 = 0;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[13237] = $1;
|
|
HEAP32[13234] = $3;
|
|
break label$5;
|
|
}
|
|
$4 = HEAP32[$2 + 4 >> 2];
|
|
if ($4 & 2) {
|
|
break label$2;
|
|
}
|
|
$7 = ($4 & -8) + $5 | 0;
|
|
if ($7 >>> 0 < $1 >>> 0) {
|
|
break label$2;
|
|
}
|
|
$9 = $7 - $1 | 0;
|
|
label$11 : {
|
|
if ($4 >>> 0 <= 255) {
|
|
$3 = HEAP32[$2 + 12 >> 2];
|
|
$2 = HEAP32[$2 + 8 >> 2];
|
|
$4 = $4 >>> 3 | 0;
|
|
$5 = ($4 << 3) + 52968 | 0;
|
|
if (($2 | 0) == ($3 | 0)) {
|
|
HEAP32[13232] = HEAP32[13232] & __wasm_rotl_i32(-2, $4);
|
|
break label$11;
|
|
}
|
|
HEAP32[$2 + 12 >> 2] = $3;
|
|
HEAP32[$3 + 8 >> 2] = $2;
|
|
break label$11;
|
|
}
|
|
$8 = HEAP32[$2 + 24 >> 2];
|
|
$4 = HEAP32[$2 + 12 >> 2];
|
|
label$14 : {
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
$3 = HEAP32[$2 + 8 >> 2];
|
|
HEAP32[$3 + 12 >> 2] = $4;
|
|
HEAP32[$4 + 8 >> 2] = $3;
|
|
break label$14;
|
|
}
|
|
label$17 : {
|
|
$3 = $2 + 20 | 0;
|
|
$5 = HEAP32[$3 >> 2];
|
|
if ($5) {
|
|
break label$17;
|
|
}
|
|
$3 = $2 + 16 | 0;
|
|
$5 = HEAP32[$3 >> 2];
|
|
if ($5) {
|
|
break label$17;
|
|
}
|
|
$4 = 0;
|
|
break label$14;
|
|
}
|
|
while (1) {
|
|
$10 = $3;
|
|
$4 = $5;
|
|
$3 = $4 + 20 | 0;
|
|
$5 = HEAP32[$3 >> 2];
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
$3 = $4 + 16 | 0;
|
|
$5 = HEAP32[$4 + 16 >> 2];
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$10 >> 2] = 0;
|
|
}
|
|
if (!$8) {
|
|
break label$11;
|
|
}
|
|
$5 = HEAP32[$2 + 28 >> 2];
|
|
$3 = ($5 << 2) + 53232 | 0;
|
|
label$19 : {
|
|
if (HEAP32[$3 >> 2] == ($2 | 0)) {
|
|
HEAP32[$3 >> 2] = $4;
|
|
if ($4) {
|
|
break label$19;
|
|
}
|
|
HEAP32[13233] = HEAP32[13233] & __wasm_rotl_i32(-2, $5);
|
|
break label$11;
|
|
}
|
|
HEAP32[(HEAP32[$8 + 16 >> 2] == ($2 | 0) ? 16 : 20) + $8 >> 2] = $4;
|
|
if (!$4) {
|
|
break label$11;
|
|
}
|
|
}
|
|
HEAP32[$4 + 24 >> 2] = $8;
|
|
$3 = HEAP32[$2 + 16 >> 2];
|
|
if ($3) {
|
|
HEAP32[$4 + 16 >> 2] = $3;
|
|
HEAP32[$3 + 24 >> 2] = $4;
|
|
}
|
|
$2 = HEAP32[$2 + 20 >> 2];
|
|
if (!$2) {
|
|
break label$11;
|
|
}
|
|
HEAP32[$4 + 20 >> 2] = $2;
|
|
HEAP32[$2 + 24 >> 2] = $4;
|
|
}
|
|
if ($9 >>> 0 <= 15) {
|
|
HEAP32[$0 + 4 >> 2] = $6 & 1 | $7 | 2;
|
|
$1 = $0 + $7 | 0;
|
|
HEAP32[$1 + 4 >> 2] = HEAP32[$1 + 4 >> 2] | 1;
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $6 & 1 | $1 | 2;
|
|
$1 = $0 + $1 | 0;
|
|
HEAP32[$1 + 4 >> 2] = $9 | 3;
|
|
$2 = $0 + $7 | 0;
|
|
HEAP32[$2 + 4 >> 2] = HEAP32[$2 + 4 >> 2] | 1;
|
|
dispose_chunk($1, $9);
|
|
}
|
|
$3 = $0;
|
|
}
|
|
return $3;
|
|
}
|
|
function silk_A2NLSF($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0;
|
|
$6 = __stack_pointer - 144 | 0;
|
|
__stack_pointer = $6;
|
|
HEAP32[$6 + 12 >> 2] = $6 + 16;
|
|
HEAP32[$6 + 8 >> 2] = $6 + 80;
|
|
$10 = $2 >> 1;
|
|
silk_A2NLSF_init($1, $6 + 80 | 0, $6 + 16 | 0, $10);
|
|
$13 = $6 + 80 | 0;
|
|
$15 = HEAP16[7560];
|
|
$3 = silk_A2NLSF_eval_poly($6 + 80 | 0, $15, $10);
|
|
if (($3 | 0) <= -1) {
|
|
HEAP16[$0 >> 1] = 0;
|
|
$13 = $6 + 16 | 0;
|
|
$3 = silk_A2NLSF_eval_poly($6 + 16 | 0, $15, $10);
|
|
$14 = 1;
|
|
}
|
|
label$2 : while (1) {
|
|
$8 = 1;
|
|
$9 = $15;
|
|
while (1) {
|
|
label$4 : {
|
|
$19 = $8 << 1;
|
|
$4 = HEAP16[$19 + 15120 >> 1];
|
|
$16 = silk_A2NLSF_eval_poly($13, $4, $10);
|
|
label$5 : {
|
|
label$6 : {
|
|
$7 = ($3 | 0) > 0;
|
|
if (!(($3 | 0) < 0 | (0 - $5 | 0) < ($16 | 0) ? !(($5 | 0) <= ($16 | 0) ? !$7 : 0) : 0)) {
|
|
$5 = $4 + $9 | 0;
|
|
$11 = ($5 >> 1) + ($5 & 1) | 0;
|
|
$12 = silk_A2NLSF_eval_poly($13, $11, $10);
|
|
label$9 : {
|
|
label$10 : {
|
|
if ($7) {
|
|
break label$10;
|
|
}
|
|
$5 = -256;
|
|
if (($12 | 0) <= -1) {
|
|
break label$10;
|
|
}
|
|
$7 = $11;
|
|
$17 = $12;
|
|
break label$9;
|
|
}
|
|
$5 = ($12 | 0) < 1 & ($3 | 0) > -1;
|
|
$17 = $5 ? $12 : $16;
|
|
$3 = $5 ? $3 : $12;
|
|
$7 = $5 ? $11 : $4;
|
|
$9 = $5 ? $9 : $11;
|
|
$5 = $5 ? -256 : -128;
|
|
}
|
|
$4 = $7 + $9 | 0;
|
|
$12 = ($4 >> 1) + ($4 & 1) | 0;
|
|
$4 = silk_A2NLSF_eval_poly($13, $12, $10);
|
|
if (($4 | 0) <= -1 | ($3 | 0) > 0) {
|
|
break label$6;
|
|
}
|
|
$17 = $4;
|
|
$7 = $12;
|
|
break label$5;
|
|
}
|
|
$7 = ($8 | 0) < 128;
|
|
$5 = 0;
|
|
$9 = $4;
|
|
$3 = $16;
|
|
$8 = $8 + 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
if ($18 >>> 0 >= 16) {
|
|
$3 = 32768 / ($2 + 1 | 0) | 0;
|
|
HEAP16[$0 >> 1] = $3;
|
|
$8 = 2;
|
|
if (($2 | 0) < 2) {
|
|
break label$4;
|
|
}
|
|
$3 = $3 << 1;
|
|
HEAP16[$0 + 2 >> 1] = $3;
|
|
if (($2 | 0) == 2) {
|
|
break label$4;
|
|
}
|
|
while (1) {
|
|
$3 = HEAPU16[$0 >> 1] + $3 | 0;
|
|
HEAP16[($8 << 1) + $0 >> 1] = $3;
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$4;
|
|
}
|
|
silk_bwexpander_32($1, $2, (-2 << $18) + 65536 | 0);
|
|
silk_A2NLSF_init($1, $6 + 80 | 0, $6 + 16 | 0, $10);
|
|
$14 = 0;
|
|
$13 = $6 + 80 | 0;
|
|
$8 = $18 + 1 | 0;
|
|
$18 = $8;
|
|
$3 = silk_A2NLSF_eval_poly($6 + 80 | 0, $15, $10);
|
|
if (($3 | 0) > -1) {
|
|
continue label$2;
|
|
}
|
|
HEAP16[$0 >> 1] = 0;
|
|
$14 = 1;
|
|
$13 = $6 + 16 | 0;
|
|
$3 = silk_A2NLSF_eval_poly($6 + 16 | 0, $15, $10);
|
|
$18 = $8;
|
|
continue label$2;
|
|
}
|
|
$11 = ($4 | 0) < 1 & ($3 | 0) > -1;
|
|
$17 = $11 ? $4 : $17;
|
|
$3 = $11 ? $3 : $4;
|
|
$9 = $11 ? $9 : $12;
|
|
$5 = $11 ? $5 : $5 | 64;
|
|
$7 = $11 ? $12 : $7;
|
|
}
|
|
$4 = $9 + $7 | 0;
|
|
$4 = silk_A2NLSF_eval_poly($13, ($4 >> 1) + ($4 & 1) | 0, $10);
|
|
label$13 : {
|
|
if (!(($4 | 0) <= -1 | ($3 | 0) > 0)) {
|
|
$7 = $4;
|
|
break label$13;
|
|
}
|
|
$9 = ($4 | 0) < 1 & ($3 | 0) > -1;
|
|
$7 = $9 ? $4 : $17;
|
|
$3 = $9 ? $3 : $4;
|
|
$5 = $9 ? $5 : $5 + 32 | 0;
|
|
}
|
|
$4 = $3 - $7 | 0;
|
|
$7 = $3 >> 31;
|
|
label$15 : {
|
|
if (($7 ^ $3 + $7) >= 65536) {
|
|
$5 = (($3 | 0) / ($4 >> 5) | 0) + $5 | 0;
|
|
break label$15;
|
|
}
|
|
if (!$4) {
|
|
break label$15;
|
|
}
|
|
$5 = ((($3 << 5) + ($4 >> 1) | 0) / ($4 | 0) | 0) + $5 | 0;
|
|
}
|
|
$3 = ($8 << 8) + $5 | 0;
|
|
HEAP16[($14 << 1) + $0 >> 1] = ($3 | 0) < 32767 ? $3 : 32767;
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) >= ($2 | 0)) {
|
|
break label$4;
|
|
}
|
|
$5 = !$16;
|
|
$3 = 4096 - ($14 << 12 & 8192) | 0;
|
|
$9 = HEAP16[$19 + 15118 >> 1];
|
|
$13 = HEAP32[($6 + 8 | 0) + (($14 & 1) << 2) >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
__stack_pointer = $6 + 144 | 0;
|
|
}
|
|
function ec_enc_done($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
$2 = HEAP32[$0 + 28 >> 2];
|
|
$4 = Math_clz32($2);
|
|
$1 = 2147483647 >>> $4 | 0;
|
|
$3 = HEAP32[$0 + 32 >> 2];
|
|
$5 = $1 + $3 & -2147483648 >> $4;
|
|
label$1 : {
|
|
label$2 : {
|
|
if ($2 + $3 >>> 0 <= ($1 | $5) >>> 0) {
|
|
$1 = $1 >>> 1 | 0;
|
|
$5 = $3 + $1 & ($1 ^ -1);
|
|
$4 = $4 + 1 | 0;
|
|
break label$2;
|
|
}
|
|
if (!$4) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$6 = $4;
|
|
while (1) {
|
|
$7 = $5 >>> 23 | 0;
|
|
label$5 : {
|
|
if (($7 | 0) != 255) {
|
|
$3 = $5 >>> 31 | 0;
|
|
$2 = HEAP32[$0 + 40 >> 2];
|
|
if (($2 | 0) >= 0) {
|
|
$1 = -1;
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $4 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $4 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $4 | 0] = $2 + $3;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $1;
|
|
}
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if ($1) {
|
|
$4 = $3 - 1 | 0;
|
|
while (1) {
|
|
$3 = -1;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $2 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $2 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $2 | 0] = $4;
|
|
$3 = 0;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
}
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $7 & 255;
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 36 >> 2] + 1;
|
|
}
|
|
$5 = $5 << 8 & 2147483392;
|
|
$1 = ($6 | 0) > 8;
|
|
$4 = $6 - 8 | 0;
|
|
$6 = $4;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = -1;
|
|
$3 = HEAP32[$0 + 40 >> 2];
|
|
label$12 : {
|
|
label$13 : {
|
|
label$14 : {
|
|
if (($3 | 0) <= -1) {
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if ($1) {
|
|
break label$14;
|
|
}
|
|
break label$12;
|
|
}
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $2 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $2 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $2 | 0] = $3;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $1;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if (!$1) {
|
|
break label$13;
|
|
}
|
|
}
|
|
while (1) {
|
|
$3 = -1;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $2 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $2 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $2 | 0] = 255;
|
|
$3 = 0;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
}
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = 0;
|
|
}
|
|
$3 = HEAP32[$0 + 12 >> 2];
|
|
$5 = HEAP32[$0 + 16 >> 2];
|
|
label$19 : {
|
|
if (($5 | 0) <= 7) {
|
|
$6 = HEAP32[$0 + 44 >> 2];
|
|
break label$19;
|
|
}
|
|
$1 = $5;
|
|
while (1) {
|
|
$2 = -1;
|
|
$6 = HEAP32[$0 + 4 >> 2];
|
|
$5 = HEAP32[$0 + 8 >> 2];
|
|
if ($6 >>> 0 > $5 + HEAP32[$0 + 24 >> 2] >>> 0) {
|
|
$2 = $5 + 1 | 0;
|
|
HEAP32[$0 + 8 >> 2] = $2;
|
|
HEAP8[HEAP32[$0 >> 2] + ($6 - $2 | 0) | 0] = $3;
|
|
$2 = 0;
|
|
}
|
|
$6 = HEAP32[$0 + 44 >> 2] | $2;
|
|
HEAP32[$0 + 44 >> 2] = $6;
|
|
$3 = $3 >>> 8 | 0;
|
|
$2 = ($1 | 0) > 15;
|
|
$5 = $1 - 8 | 0;
|
|
$1 = $5;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$23 : {
|
|
if ($6) {
|
|
break label$23;
|
|
}
|
|
$1 = HEAP32[$0 + 24 >> 2];
|
|
memset($1 + HEAP32[$0 >> 2] | 0, 0, (HEAP32[$0 + 4 >> 2] - $1 | 0) - HEAP32[$0 + 8 >> 2] | 0);
|
|
if (($5 | 0) < 1) {
|
|
break label$23;
|
|
}
|
|
$1 = HEAP32[$0 + 8 >> 2];
|
|
$2 = HEAP32[$0 + 4 >> 2];
|
|
if ($1 >>> 0 >= $2 >>> 0) {
|
|
HEAP32[$0 + 44 >> 2] = -1;
|
|
return;
|
|
}
|
|
$4 = 0 - $4 | 0;
|
|
if (!(HEAP32[$0 + 24 >> 2] + $1 >>> 0 < $2 >>> 0 | ($5 | 0) <= ($4 | 0))) {
|
|
HEAP32[$0 + 44 >> 2] = -1;
|
|
$3 = (-1 << $4 ^ -1) & $3;
|
|
}
|
|
$0 = HEAP32[$0 >> 2] + (($1 ^ -1) + $2 | 0) | 0;
|
|
HEAP8[$0 | 0] = HEAPU8[$0 | 0] | $3;
|
|
}
|
|
}
|
|
function silk_encode_indices($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
$7 = __stack_pointer - 48 | 0;
|
|
__stack_pointer = $7;
|
|
label$1 : {
|
|
label$2 : {
|
|
$2 = $3 ? (Math_imul($2, 36) + $0 | 0) + 6100 | 0 : $0 + 4736 | 0;
|
|
$5 = (HEAP8[$2 + 29 | 0] << 1) + HEAP8[$2 + 30 | 0] | 0;
|
|
if ($5 >>> 0 < 6) {
|
|
if (($5 | 0) <= 1 ? $3 : 0) {
|
|
break label$2;
|
|
}
|
|
label$4 : {
|
|
if (!(($5 | 0) < 2 ? !$3 : 0)) {
|
|
ec_enc_icdf($1, $5 - 2 | 0, 5829, 8);
|
|
break label$4;
|
|
}
|
|
ec_enc_icdf($1, $5, 5833, 8);
|
|
}
|
|
$3 = HEAP8[$2 | 0];
|
|
label$6 : {
|
|
if (($4 | 0) == 2) {
|
|
ec_enc_icdf($1, $3, 7328, 8);
|
|
break label$6;
|
|
}
|
|
ec_enc_icdf($1, $3 >> 3, (HEAP8[$2 + 29 | 0] << 3) + 7296 | 0, 8);
|
|
ec_enc_icdf($1, HEAPU8[$2 | 0] & 7, 5872, 8);
|
|
}
|
|
if (HEAP32[$0 + 4580 >> 2] >= 2) {
|
|
$3 = 1;
|
|
while (1) {
|
|
ec_enc_icdf($1, HEAP8[$2 + $3 | 0], 7328, 8);
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) < HEAP32[$0 + 4580 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = HEAP32[$0 + 4692 >> 2];
|
|
ec_enc_icdf($1, HEAP8[$2 + 8 | 0], HEAP32[$3 + 16 >> 2] + Math_imul(HEAP16[$3 >> 1], HEAP8[$2 + 29 | 0] >> 1) | 0, 8);
|
|
silk_NLSF_unpack($7 + 16 | 0, $7, HEAP32[$0 + 4692 >> 2], HEAP8[$2 + 8 | 0]);
|
|
$5 = HEAP32[$0 + 4692 >> 2];
|
|
$6 = HEAP16[$5 + 2 >> 1];
|
|
if (($6 | 0) != HEAP32[$0 + 4640 >> 2]) {
|
|
break label$1;
|
|
}
|
|
$3 = 0;
|
|
if (($6 | 0) > 0) {
|
|
while (1) {
|
|
$6 = $3;
|
|
$3 = $3 + 1 | 0;
|
|
$8 = $3 + $2 | 0;
|
|
$9 = HEAP8[$8 + 8 | 0];
|
|
label$12 : {
|
|
if (($9 | 0) >= 4) {
|
|
ec_enc_icdf($1, 8, HEAP32[$5 + 28 >> 2] + HEAP16[($7 + 16 | 0) + ($6 << 1) >> 1] | 0, 8);
|
|
ec_enc_icdf($1, HEAP8[$8 + 8 | 0] - 4 | 0, 5880, 8);
|
|
break label$12;
|
|
}
|
|
if (($9 | 0) <= -4) {
|
|
ec_enc_icdf($1, 0, HEAP32[$5 + 28 >> 2] + HEAP16[($7 + 16 | 0) + ($6 << 1) >> 1] | 0, 8);
|
|
ec_enc_icdf($1, -4 - HEAP8[$8 + 8 | 0] | 0, 5880, 8);
|
|
break label$12;
|
|
}
|
|
ec_enc_icdf($1, $9 + 4 | 0, HEAP32[$5 + 28 >> 2] + HEAP16[($7 + 16 | 0) + ($6 << 1) >> 1] | 0, 8);
|
|
}
|
|
$5 = HEAP32[$0 + 4692 >> 2];
|
|
if (HEAP16[$5 + 2 >> 1] > ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (HEAP32[$0 + 4580 >> 2] == 4) {
|
|
ec_enc_icdf($1, HEAP8[$2 + 31 | 0], 5835, 8);
|
|
}
|
|
label$16 : {
|
|
if (HEAPU8[$2 + 29 | 0] != 2) {
|
|
break label$16;
|
|
}
|
|
label$17 : {
|
|
if (!(($4 | 0) != 2 | HEAP32[$0 + 5768 >> 2] != 2)) {
|
|
$3 = HEAP16[$2 + 26 >> 1] - HEAP16[$0 + 5772 >> 1] | 0;
|
|
$6 = $3 + 9 | 0;
|
|
$3 = $3 + 8 | 0;
|
|
ec_enc_icdf($1, $3 >>> 0 > 19 ? 0 : $6, 2080, 8);
|
|
if ($3 >>> 0 < 20) {
|
|
break label$17;
|
|
}
|
|
}
|
|
$3 = HEAP16[$2 + 26 >> 1];
|
|
$5 = HEAP32[$0 + 4576 >> 2] >> 1;
|
|
$6 = ($3 | 0) / ($5 | 0) | 0;
|
|
ec_enc_icdf($1, $6, 2048, 8);
|
|
ec_enc_icdf($1, $3 - Math_imul($6 << 16 >> 16, $5 << 16 >> 16) | 0, HEAP32[$0 + 4684 >> 2], 8);
|
|
}
|
|
HEAP16[$0 + 5772 >> 1] = HEAPU16[$2 + 26 >> 1];
|
|
ec_enc_icdf($1, HEAP8[$2 + 28 | 0], HEAP32[$0 + 4688 >> 2], 8);
|
|
ec_enc_icdf($1, HEAP8[$2 + 32 | 0], 7369, 8);
|
|
if (HEAP32[$0 + 4580 >> 2] >= 1) {
|
|
$3 = 0;
|
|
while (1) {
|
|
ec_enc_icdf($1, HEAP8[($2 + $3 | 0) + 4 | 0], HEAP32[(HEAP8[$2 + 32 | 0] << 2) + 7440 >> 2], 8);
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) < HEAP32[$0 + 4580 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($4) {
|
|
break label$16;
|
|
}
|
|
ec_enc_icdf($1, HEAP8[$2 + 33 | 0], 5826, 8);
|
|
}
|
|
HEAP32[$0 + 5768 >> 2] = HEAP8[$2 + 29 | 0];
|
|
ec_enc_icdf($1, HEAP8[$2 + 34 | 0], 5857, 8);
|
|
__stack_pointer = $7 + 48 | 0;
|
|
return;
|
|
}
|
|
celt_fatal(7919, 7971, 59);
|
|
abort();
|
|
}
|
|
celt_fatal(7993, 7971, 60);
|
|
abort();
|
|
}
|
|
celt_fatal(8047, 7971, 93);
|
|
abort();
|
|
}
|
|
function pitch_downsample($0, $1, $2, $3, $4) {
|
|
var $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = Math_fround(0), $11 = Math_fround(0), $12 = Math_fround(0), $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = Math_fround(0), $18 = Math_fround(0), $19 = Math_fround(0), $20 = Math_fround(0), $21 = Math_fround(0), $22 = Math_fround(0);
|
|
$6 = __stack_pointer - 48 | 0;
|
|
__stack_pointer = $6;
|
|
$13 = $2 >> 1;
|
|
$8 = HEAP32[$0 >> 2];
|
|
if (($2 | 0) >= 4) {
|
|
$15 = ($13 | 0) > 2 ? $13 : 2;
|
|
$7 = 1;
|
|
while (1) {
|
|
$9 = $7 << 3;
|
|
$14 = $9 + $8 | 0;
|
|
HEAPF32[($7 << 2) + $1 >> 2] = Math_fround(HEAPF32[$14 >> 2] + Math_fround(Math_fround(HEAPF32[$14 - 4 >> 2] + HEAPF32[($9 | 4) + $8 >> 2]) * Math_fround(.5))) * Math_fround(.5);
|
|
$7 = $7 + 1 | 0;
|
|
if (($15 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = Math_fround(Math_fround(Math_fround(HEAPF32[$8 + 4 >> 2] * Math_fround(.5)) + HEAPF32[$8 >> 2]) * Math_fround(.5));
|
|
HEAPF32[$1 >> 2] = $5;
|
|
if (($3 | 0) == 2) {
|
|
$8 = HEAP32[$0 + 4 >> 2];
|
|
if (($2 | 0) >= 4) {
|
|
$15 = ($13 | 0) > 2 ? $13 : 2;
|
|
$7 = 1;
|
|
while (1) {
|
|
$9 = ($7 << 2) + $1 | 0;
|
|
$0 = $9;
|
|
$5 = HEAPF32[$9 >> 2];
|
|
$9 = $7 << 3;
|
|
$14 = $9 + $8 | 0;
|
|
HEAPF32[$0 >> 2] = $5 + Math_fround(Math_fround(HEAPF32[$14 >> 2] + Math_fround(Math_fround(HEAPF32[$14 - 4 >> 2] + HEAPF32[($9 | 4) + $8 >> 2]) * Math_fround(.5))) * Math_fround(.5));
|
|
$7 = $7 + 1 | 0;
|
|
if (($15 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = HEAPF32[$1 >> 2];
|
|
}
|
|
HEAPF32[$1 >> 2] = $5 + Math_fround(Math_fround(Math_fround(HEAPF32[$8 + 4 >> 2] * Math_fround(.5)) + HEAPF32[$8 >> 2]) * Math_fround(.5));
|
|
}
|
|
$7 = 0;
|
|
_celt_autocorr($1, $6 + 16 | 0, 0, 0, 4, $13, $4);
|
|
HEAPF32[$6 + 16 >> 2] = HEAPF32[$6 + 16 >> 2] * Math_fround(1.000100016593933);
|
|
$5 = HEAPF32[$6 + 20 >> 2];
|
|
HEAPF32[$6 + 20 >> 2] = $5 - Math_fround(Math_fround($5 * Math_fround(.00800000037997961)) * Math_fround(.00800000037997961));
|
|
$5 = HEAPF32[$6 + 24 >> 2];
|
|
HEAPF32[$6 + 24 >> 2] = $5 - Math_fround(Math_fround($5 * Math_fround(.01600000075995922)) * Math_fround(.01600000075995922));
|
|
$5 = HEAPF32[$6 + 28 >> 2];
|
|
HEAPF32[$6 + 28 >> 2] = $5 - Math_fround(Math_fround($5 * Math_fround(.024000000208616257)) * Math_fround(.024000000208616257));
|
|
$5 = HEAPF32[$6 + 32 >> 2];
|
|
HEAPF32[$6 + 32 >> 2] = $5 - Math_fround(Math_fround($5 * Math_fround(.03200000151991844)) * Math_fround(.03200000151991844));
|
|
_celt_lpc($6, $6 + 16 | 0, 4);
|
|
$5 = Math_fround(HEAPF32[$6 + 8 >> 2] * Math_fround(.7289999127388));
|
|
HEAPF32[$6 + 8 >> 2] = $5;
|
|
$10 = Math_fround(HEAPF32[$6 + 12 >> 2] * Math_fround(.6560999155044556));
|
|
HEAPF32[$6 + 12 >> 2] = $10;
|
|
$11 = Math_fround(HEAPF32[$6 + 4 >> 2] * Math_fround(.809999942779541));
|
|
HEAPF32[$6 + 4 >> 2] = $11;
|
|
$12 = Math_fround(HEAPF32[$6 >> 2] * Math_fround(.8999999761581421));
|
|
HEAPF32[$6 >> 2] = $12;
|
|
if (($2 | 0) >= 2) {
|
|
$17 = Math_fround($10 + Math_fround($5 * Math_fround(.800000011920929)));
|
|
$18 = Math_fround($5 + Math_fround($11 * Math_fround(.800000011920929)));
|
|
$19 = Math_fround($11 + Math_fround($12 * Math_fround(.800000011920929)));
|
|
$20 = Math_fround($10 * Math_fround(.800000011920929));
|
|
$21 = Math_fround($12 + Math_fround(.800000011920929));
|
|
$5 = Math_fround(0);
|
|
$10 = Math_fround(0);
|
|
$11 = Math_fround(0);
|
|
$12 = Math_fround(0);
|
|
while (1) {
|
|
$8 = ($7 << 2) + $1 | 0;
|
|
$16 = HEAPF32[$8 >> 2];
|
|
HEAPF32[$8 >> 2] = Math_fround($20 * $22) + Math_fround(Math_fround($17 * $5) + Math_fround(Math_fround($18 * $10) + Math_fround(Math_fround($19 * $11) + Math_fround(Math_fround($21 * $12) + $16))));
|
|
$22 = $5;
|
|
$5 = $10;
|
|
$10 = $11;
|
|
$11 = $12;
|
|
$12 = $16;
|
|
$7 = $7 + 1 | 0;
|
|
if (($13 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $6 + 48 | 0;
|
|
}
|
|
function quant_coarse_energy_impl($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) {
|
|
var $15 = 0, $16 = Math_fround(0), $17 = Math_fround(0), $18 = 0, $19 = Math_fround(0), $20 = Math_fround(0), $21 = Math_fround(0), $22 = 0, $23 = Math_fround(0), $24 = Math_fround(0), $25 = 0, $26 = Math_fround(0), $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0, $32 = 0, $33 = 0;
|
|
$15 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $15;
|
|
HEAP32[$15 + 8 >> 2] = 0;
|
|
HEAP32[$15 + 12 >> 2] = 0;
|
|
if (($6 + 3 | 0) <= ($5 | 0)) {
|
|
ec_enc_bit_logp($9, $12, 3);
|
|
}
|
|
if ($12) {
|
|
$19 = Math_fround(.149993896484375);
|
|
} else {
|
|
$12 = $11 << 2;
|
|
$26 = HEAPF32[$12 + 33376 >> 2];
|
|
$19 = HEAPF32[$12 + 33392 >> 2];
|
|
}
|
|
if (($1 | 0) < ($2 | 0)) {
|
|
$27 = ($10 | 0) > 1 ? $10 : 1;
|
|
$28 = Math_imul($10, 3);
|
|
$29 = $5 + 32 | 0;
|
|
$5 = HEAP32[$0 + 8 >> 2];
|
|
$11 = $1;
|
|
while (1) {
|
|
$30 = ($14 | 0) != 0 & ($11 | 0) > 1;
|
|
$31 = Math_imul($11 - $2 | 0, $28);
|
|
$12 = (($11 | 0) < 20 ? $11 : 20) << 1;
|
|
$32 = $12 + $7 | 0;
|
|
$33 = ($12 | 1) + $7 | 0;
|
|
$10 = 0;
|
|
while (1) {
|
|
$12 = Math_imul($5, $10) + $11 << 2;
|
|
$16 = HEAPF32[$12 + $3 >> 2];
|
|
$17 = HEAPF32[$4 + $12 >> 2];
|
|
$20 = Math_fround(Math_fround(Math_max($17, Math_fround(-28))) - $13);
|
|
$5 = $16 < $20 ^ 1;
|
|
$21 = Math_fround($26 * Math_fround(Math_max($17, Math_fround(-9))));
|
|
$22 = ($15 + 8 | 0) + ($10 << 2) | 0;
|
|
$17 = HEAPF32[$22 >> 2];
|
|
$23 = Math_fround(Math_fround($16 - $21) - $17);
|
|
$24 = Math_fround(Math_floor(Math_fround($23 + Math_fround(.5))));
|
|
label$7 : {
|
|
if (Math_fround(Math_abs($24)) < Math_fround(2147483648)) {
|
|
$12 = ~~$24;
|
|
break label$7;
|
|
}
|
|
$12 = -2147483648;
|
|
}
|
|
if (!($5 | ($12 | 0) > -1)) {
|
|
$16 = Math_fround($20 - $16);
|
|
label$10 : {
|
|
if (Math_fround(Math_abs($16)) < Math_fround(2147483648)) {
|
|
$5 = ~~$16;
|
|
break label$10;
|
|
}
|
|
$5 = -2147483648;
|
|
}
|
|
$12 = $12 + $5 | 0;
|
|
$12 = $12 & $12 >> 31;
|
|
}
|
|
HEAP32[$15 + 4 >> 2] = $12;
|
|
$6 = ($29 - HEAP32[$9 + 20 >> 2] | 0) - Math_clz32(HEAP32[$9 + 28 >> 2]) | 0;
|
|
$5 = $12;
|
|
label$12 : {
|
|
if (($1 | 0) == ($11 | 0)) {
|
|
break label$12;
|
|
}
|
|
$18 = $6 + $31 | 0;
|
|
if (($18 | 0) > 23) {
|
|
break label$12;
|
|
}
|
|
$5 = ($12 | 0) < 1 ? $12 : 1;
|
|
HEAP32[$15 + 4 >> 2] = $5;
|
|
if (($18 | 0) > 15) {
|
|
break label$12;
|
|
}
|
|
$5 = ($5 | 0) > -1 ? $5 : -1;
|
|
HEAP32[$15 + 4 >> 2] = $5;
|
|
}
|
|
if ($30) {
|
|
$5 = $5 >> 31 & $5;
|
|
HEAP32[$15 + 4 >> 2] = $5;
|
|
}
|
|
label$14 : {
|
|
if (($6 | 0) >= 15) {
|
|
ec_laplace_encode($9, $15 + 4 | 0, HEAPU8[$32 | 0] << 7, HEAPU8[$33 | 0] << 6);
|
|
break label$14;
|
|
}
|
|
if (($6 | 0) >= 2) {
|
|
$5 = ($5 | 0) < 1 ? $5 : 1;
|
|
$5 = ($5 | 0) > -1 ? $5 : -1;
|
|
HEAP32[$15 + 4 >> 2] = $5;
|
|
ec_enc_icdf($9, $5 << 1 ^ $5 >> 31, 33408, 2);
|
|
break label$14;
|
|
}
|
|
if (($6 | 0) == 1) {
|
|
$5 = $5 >> 31 & $5;
|
|
HEAP32[$15 + 4 >> 2] = $5;
|
|
ec_enc_bit_logp($9, 0 - $5 | 0, 1);
|
|
break label$14;
|
|
}
|
|
HEAP32[$15 + 4 >> 2] = -1;
|
|
}
|
|
$5 = HEAP32[$0 + 8 >> 2];
|
|
$6 = Math_imul($10, $5) + $11 << 2;
|
|
$18 = HEAP32[$15 + 4 >> 2];
|
|
$16 = Math_fround($18 | 0);
|
|
HEAPF32[$8 + $6 >> 2] = $23 - $16;
|
|
HEAPF32[$4 + $6 >> 2] = Math_fround($17 + $21) + $16;
|
|
HEAPF32[$22 >> 2] = Math_fround($17 + $16) - Math_fround($19 * $16);
|
|
$12 = $12 - $18 | 0;
|
|
$6 = $12;
|
|
$12 = $12 >> 31;
|
|
$25 = ($12 ^ $12 + $6) + $25 | 0;
|
|
$10 = $10 + 1 | 0;
|
|
if (($27 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $15 + 16 | 0;
|
|
return $14 ? 0 : $25;
|
|
}
|
|
function compute_dense($0, $1, $2) {
|
|
var $3 = Math_fround(0), $4 = Math_fround(0), $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
$7 = HEAP32[$0 + 12 >> 2];
|
|
label$1 : {
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$9 = HEAP32[$0 + 8 >> 2];
|
|
$6 = HEAP32[$0 >> 2];
|
|
while (1) {
|
|
HEAPF32[($5 << 2) + $1 >> 2] = HEAP8[$5 + $6 | 0];
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$10 = HEAP32[$0 + 4 >> 2];
|
|
$6 = 0;
|
|
$11 = ($9 | 0) < 1;
|
|
while (1) {
|
|
if (!$11) {
|
|
$8 = ($6 << 2) + $1 | 0;
|
|
$3 = HEAPF32[$8 >> 2];
|
|
$5 = 0;
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($5 << 2) + $2 >> 2] * Math_fround(HEAP8[(Math_imul($5, $7) + $6 | 0) + $10 | 0])));
|
|
HEAPF32[$8 >> 2] = $3;
|
|
$5 = $5 + 1 | 0;
|
|
if (($9 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = $6 + 1 | 0;
|
|
if (($7 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
$6 = ($5 << 2) + $1 | 0;
|
|
HEAPF32[$6 >> 2] = HEAPF32[$6 >> 2] * Math_fround(.0078125);
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$7 : {
|
|
if (HEAP32[$0 + 16 >> 2]) {
|
|
$5 = 0;
|
|
if (($7 | 0) <= 0) {
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$3 = Math_fround(1);
|
|
$6 = ($5 << 2) + $1 | 0;
|
|
$4 = Math_fround(HEAPF32[$6 >> 2] * Math_fround(.5));
|
|
label$10 : {
|
|
if ($4 < Math_fround(8) ^ 1) {
|
|
break label$10;
|
|
}
|
|
$3 = Math_fround(0);
|
|
if ($4 > Math_fround(-8) ^ 1) {
|
|
break label$10;
|
|
}
|
|
$3 = Math_fround(.5);
|
|
if ($4 != $4) {
|
|
break label$10;
|
|
}
|
|
$9 = $4 < Math_fround(0);
|
|
$4 = $9 ? Math_fround(-$4) : $4;
|
|
$3 = Math_fround(Math_floor(Math_fround(Math_fround($4 * Math_fround(25)) + Math_fround(.5))));
|
|
label$11 : {
|
|
if (Math_fround(Math_abs($3)) < Math_fround(2147483648)) {
|
|
$8 = ~~$3;
|
|
break label$11;
|
|
}
|
|
$8 = -2147483648;
|
|
}
|
|
$3 = HEAPF32[($8 << 2) + 48128 >> 2];
|
|
$4 = Math_fround($4 + Math_fround(Math_fround($8 | 0) * Math_fround(-.03999999910593033)));
|
|
$3 = Math_fround($3 + Math_fround(Math_fround(Math_fround(1) - Math_fround($3 * $4)) * Math_fround($4 * Math_fround(Math_fround(1) - Math_fround($3 * $3)))));
|
|
$3 = Math_fround(Math_fround(($9 ? Math_fround(-$3) : $3) * Math_fround(.5)) + Math_fround(.5));
|
|
}
|
|
HEAPF32[$6 >> 2] = $3;
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$7;
|
|
}
|
|
$5 = 0;
|
|
if (($7 | 0) <= 0) {
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$3 = Math_fround(1);
|
|
$6 = ($5 << 2) + $1 | 0;
|
|
$4 = HEAPF32[$6 >> 2];
|
|
label$14 : {
|
|
if ($4 < Math_fround(8) ^ 1) {
|
|
break label$14;
|
|
}
|
|
$3 = Math_fround(-1);
|
|
if ($4 > Math_fround(-8) ^ 1) {
|
|
break label$14;
|
|
}
|
|
$3 = Math_fround(0);
|
|
if ($4 != $4) {
|
|
break label$14;
|
|
}
|
|
$9 = $4 < Math_fround(0);
|
|
$4 = $9 ? Math_fround(-$4) : $4;
|
|
$3 = Math_fround(Math_floor(Math_fround(Math_fround($4 * Math_fround(25)) + Math_fround(.5))));
|
|
label$15 : {
|
|
if (Math_fround(Math_abs($3)) < Math_fround(2147483648)) {
|
|
$8 = ~~$3;
|
|
break label$15;
|
|
}
|
|
$8 = -2147483648;
|
|
}
|
|
$3 = HEAPF32[($8 << 2) + 48128 >> 2];
|
|
$4 = Math_fround($4 + Math_fround(Math_fround($8 | 0) * Math_fround(-.03999999910593033)));
|
|
$3 = Math_fround($3 + Math_fround(Math_fround(Math_fround(1) - Math_fround($3 * $4)) * Math_fround($4 * Math_fround(Math_fround(1) - Math_fround($3 * $3)))));
|
|
$3 = $9 ? Math_fround(-$3) : $3;
|
|
}
|
|
HEAPF32[$6 >> 2] = $3;
|
|
$5 = $5 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_NLSF_stabilize($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
|
|
$12 = ($2 << 1) + $1 | 0;
|
|
$13 = $2 - 1 | 0;
|
|
$11 = ($13 << 1) + $0 | 0;
|
|
$16 = ($2 | 0) < 2;
|
|
label$1 : {
|
|
while (1) {
|
|
$5 = HEAP16[$0 >> 1];
|
|
$9 = HEAP16[$1 >> 1];
|
|
$3 = $5 - $9 | 0;
|
|
$4 = 1;
|
|
$6 = 0;
|
|
if (!$16) {
|
|
while (1) {
|
|
$7 = $5 << 16;
|
|
$10 = $4 << 1;
|
|
$5 = HEAP16[$10 + $0 >> 1];
|
|
$7 = ($5 - ($7 >> 16) | 0) - HEAP16[$1 + $10 >> 1] | 0;
|
|
$8 = $7;
|
|
$7 = ($3 | 0) > ($7 | 0);
|
|
$3 = $7 ? $8 : $3;
|
|
$6 = $7 ? $4 : $6;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = HEAP16[$12 >> 1];
|
|
$4 = 32768 - ($5 + HEAP16[$11 >> 1] | 0) | 0;
|
|
$8 = $4;
|
|
$4 = ($3 | 0) > ($4 | 0);
|
|
if ((($4 ? $8 : $3) | 0) > -1) {
|
|
break label$1;
|
|
}
|
|
$3 = $4 ? $2 : $6;
|
|
label$5 : {
|
|
if (!$3) {
|
|
HEAP16[$0 >> 1] = $9;
|
|
break label$5;
|
|
}
|
|
label$7 : {
|
|
label$8 : {
|
|
if (($2 | 0) != ($3 | 0)) {
|
|
if (($3 | 0) >= 1) {
|
|
break label$8;
|
|
}
|
|
$9 = 0;
|
|
break label$7;
|
|
}
|
|
HEAP16[$11 >> 1] = -32768 - $5;
|
|
break label$5;
|
|
}
|
|
$4 = 1;
|
|
if (($3 | 0) == 1) {
|
|
break label$7;
|
|
}
|
|
while (1) {
|
|
$9 = HEAP16[($4 << 1) + $1 >> 1] + $9 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $3 << 1;
|
|
$14 = $8 + $1 | 0;
|
|
$10 = HEAP16[$14 >> 1] >> 1;
|
|
$7 = $10 + $9 | 0;
|
|
$6 = 32768;
|
|
label$11 : {
|
|
if (($2 | 0) <= ($3 | 0)) {
|
|
break label$11;
|
|
}
|
|
$6 = 32768 - $5 | 0;
|
|
$4 = $13;
|
|
if (($4 | 0) <= ($3 | 0)) {
|
|
break label$11;
|
|
}
|
|
while (1) {
|
|
$6 = $6 - HEAP16[($4 << 1) + $1 >> 1] | 0;
|
|
$4 = $4 - 1 | 0;
|
|
if (($4 | 0) > ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $0 + $8 | 0;
|
|
$9 = $4 - 2 | 0;
|
|
$3 = HEAP16[$4 >> 1] + HEAP16[$9 >> 1] | 0;
|
|
$3 = ($3 >> 1) + ($3 & 1) | 0;
|
|
$6 = $6 - $10 | 0;
|
|
label$13 : {
|
|
if (($7 | 0) > ($6 | 0)) {
|
|
$5 = $7;
|
|
$8 = $5;
|
|
if (($3 | 0) > ($5 | 0)) {
|
|
break label$13;
|
|
}
|
|
$8 = ($3 | 0) < ($6 | 0) ? $6 : $3;
|
|
break label$13;
|
|
}
|
|
$5 = $6;
|
|
$8 = $5;
|
|
if (($3 | 0) > ($5 | 0)) {
|
|
break label$13;
|
|
}
|
|
$8 = ($3 | 0) < ($7 | 0) ? $7 : $3;
|
|
}
|
|
$5 = $8;
|
|
$3 = $5 - $10 | 0;
|
|
HEAP16[$9 >> 1] = $3;
|
|
HEAP16[$4 >> 1] = HEAPU16[$14 >> 1] + $3;
|
|
}
|
|
$15 = $15 + 1 | 0;
|
|
if (($15 | 0) != 20) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
silk_insertion_sort_increasing_all_values_int16($0, $2);
|
|
$4 = HEAP16[$0 >> 1];
|
|
$3 = HEAP16[$1 >> 1];
|
|
$3 = ($3 | 0) < ($4 | 0) ? $4 : $3;
|
|
HEAP16[$0 >> 1] = $3;
|
|
$7 = ($2 | 0) < 2;
|
|
if (!$7) {
|
|
$4 = 1;
|
|
while (1) {
|
|
$6 = $4 << 1;
|
|
$5 = $6 + $0 | 0;
|
|
$8 = $5;
|
|
$5 = HEAP16[$5 >> 1];
|
|
$3 = HEAP16[$1 + $6 >> 1] + ($3 << 16 >> 16) | 0;
|
|
$3 = ($3 | 0) < 32767 ? $3 : 32767;
|
|
$3 = ($3 | 0) > -32768 ? $3 : -32768;
|
|
$3 = ($3 | 0) < ($5 | 0) ? $5 : $3;
|
|
HEAP16[$8 >> 1] = $3;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = HEAP16[$11 >> 1];
|
|
$3 = 32768 - HEAP16[$12 >> 1] | 0;
|
|
$3 = ($3 | 0) > ($4 | 0) ? $4 : $3;
|
|
HEAP16[$11 >> 1] = $3;
|
|
if ($7) {
|
|
break label$1;
|
|
}
|
|
$4 = $2 - 2 | 0;
|
|
while (1) {
|
|
$6 = $4 << 1;
|
|
$5 = $6 + $0 | 0;
|
|
$2 = $5;
|
|
$5 = HEAP16[$5 >> 1];
|
|
$3 = ($3 << 16 >> 16) - HEAP16[($1 + $6 | 0) + 2 >> 1] | 0;
|
|
$3 = ($3 | 0) > ($5 | 0) ? $5 : $3;
|
|
HEAP16[$2 >> 1] = $3;
|
|
$6 = ($4 | 0) > 0;
|
|
$4 = $4 - 1 | 0;
|
|
if ($6) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function clt_mdct_forward_c($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = Math_fround(0), $15 = 0, $16 = 0, $17 = Math_fround(0), $18 = 0, $19 = Math_fround(0), $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = Math_fround(0), $25 = 0;
|
|
$7 = __stack_pointer;
|
|
$22 = $7;
|
|
$15 = HEAP32[$0 >> 2];
|
|
$9 = $15 >> 1;
|
|
$20 = HEAP32[(($5 << 2) + $0 | 0) + 8 >> 2];
|
|
$17 = HEAPF32[$20 + 4 >> 2];
|
|
$16 = HEAP32[$0 + 24 >> 2];
|
|
if (($5 | 0) >= 1) {
|
|
$0 = 0;
|
|
while (1) {
|
|
$15 = $9;
|
|
$9 = $9 >> 1;
|
|
$16 = ($15 << 2) + $16 | 0;
|
|
$0 = $0 + 1 | 0;
|
|
if (($5 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$0 = $4 << 1 & -4;
|
|
$10 = $9 << 2;
|
|
$5 = ($0 + ($10 + $1 | 0) | 0) - 4 | 0;
|
|
$10 = $7 - ($10 + 15 & -16) | 0;
|
|
$7 = $10;
|
|
__stack_pointer = $7;
|
|
$21 = $4 + 3 >> 2;
|
|
$1 = $0 + $1 | 0;
|
|
$11 = $15 >> 2;
|
|
$12 = $7 - (($11 << 3) + 15 & -16) | 0;
|
|
__stack_pointer = $12;
|
|
label$3 : {
|
|
if (($4 | 0) < 1) {
|
|
$7 = 0;
|
|
$0 = $10;
|
|
break label$3;
|
|
}
|
|
$7 = ($21 | 0) > 1 ? $21 : 1;
|
|
$8 = $0 + $3 | 0;
|
|
$18 = $8 - 4 | 0;
|
|
$25 = 0 - $9 << 2;
|
|
$0 = $10;
|
|
while (1) {
|
|
$13 = HEAPF32[$18 >> 2];
|
|
$14 = HEAPF32[$8 >> 2];
|
|
HEAPF32[$0 >> 2] = Math_fround($13 * HEAPF32[($9 << 2) + $1 >> 2]) + Math_fround($14 * HEAPF32[$5 >> 2]);
|
|
HEAPF32[$0 + 4 >> 2] = Math_fround($14 * HEAPF32[$1 >> 2]) - Math_fround($13 * HEAPF32[$5 + $25 >> 2]);
|
|
$18 = $18 - 8 | 0;
|
|
$8 = $8 + 8 | 0;
|
|
$5 = $5 - 8 | 0;
|
|
$1 = $1 + 8 | 0;
|
|
$0 = $0 + 8 | 0;
|
|
$23 = $23 + 1 | 0;
|
|
if (($23 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $11 - $21 | 0;
|
|
if (($8 | 0) > ($7 | 0)) {
|
|
while (1) {
|
|
HEAP32[$0 >> 2] = HEAP32[$5 >> 2];
|
|
HEAP32[$0 + 4 >> 2] = HEAP32[$1 >> 2];
|
|
$5 = $5 - 8 | 0;
|
|
$1 = $1 + 8 | 0;
|
|
$0 = $0 + 8 | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($8 | 0) > ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = $8;
|
|
}
|
|
if (($7 | 0) < ($11 | 0)) {
|
|
$8 = (($4 << 2) + $3 | 0) - 4 | 0;
|
|
$18 = 0 - $9 << 2;
|
|
while (1) {
|
|
HEAPF32[$0 >> 2] = Math_fround(HEAPF32[$8 >> 2] * HEAPF32[$5 >> 2]) - Math_fround(HEAPF32[$3 >> 2] * HEAPF32[$1 + $18 >> 2]);
|
|
HEAPF32[$0 + 4 >> 2] = Math_fround(HEAPF32[$8 >> 2] * HEAPF32[$1 >> 2]) + Math_fround(HEAPF32[$3 >> 2] * HEAPF32[($9 << 2) + $5 >> 2]);
|
|
$8 = $8 - 8 | 0;
|
|
$3 = $3 + 8 | 0;
|
|
$5 = $5 - 8 | 0;
|
|
$1 = $1 + 8 | 0;
|
|
$0 = $0 + 8 | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($11 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($15 | 0) <= 3) {
|
|
opus_fft_impl($20, $12);
|
|
__stack_pointer = $22;
|
|
return;
|
|
}
|
|
$1 = ($11 | 0) > 1 ? $11 : 1;
|
|
$0 = 0;
|
|
while (1) {
|
|
$5 = (HEAP16[HEAP32[$20 + 44 >> 2] + ($0 << 1) >> 1] << 3) + $12 | 0;
|
|
$13 = HEAPF32[($0 + $11 << 2) + $16 >> 2];
|
|
$14 = HEAPF32[$10 >> 2];
|
|
$19 = HEAPF32[($0 << 2) + $16 >> 2];
|
|
$24 = HEAPF32[$10 + 4 >> 2];
|
|
HEAPF32[$5 + 4 >> 2] = $17 * Math_fround(Math_fround($13 * $14) + Math_fround($19 * $24));
|
|
HEAPF32[$5 >> 2] = $17 * Math_fround(Math_fround($19 * $14) - Math_fround($13 * $24));
|
|
$10 = $10 + 8 | 0;
|
|
$0 = $0 + 1 | 0;
|
|
if (($1 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
opus_fft_impl($20, $12);
|
|
if (($15 | 0) >= 4) {
|
|
$1 = ($11 | 0) > 1 ? $11 : 1;
|
|
$0 = 0;
|
|
$5 = (Math_imul($9 - 1 | 0, $6) << 2) + $2 | 0;
|
|
$7 = $6 << 1;
|
|
$9 = 0 - $7 << 2;
|
|
while (1) {
|
|
$13 = HEAPF32[$12 + 4 >> 2];
|
|
$14 = HEAPF32[($0 + $11 << 2) + $16 >> 2];
|
|
$17 = HEAPF32[$12 >> 2];
|
|
$19 = HEAPF32[($0 << 2) + $16 >> 2];
|
|
HEAPF32[$2 >> 2] = Math_fround($13 * $14) - Math_fround($17 * $19);
|
|
HEAPF32[$5 >> 2] = Math_fround($14 * $17) + Math_fround($13 * $19);
|
|
$12 = $12 + 8 | 0;
|
|
$5 = $5 + $9 | 0;
|
|
$2 = ($7 << 2) + $2 | 0;
|
|
$0 = $0 + 1 | 0;
|
|
if (($1 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $22;
|
|
}
|
|
function speex_resampler_process_float($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0;
|
|
$8 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $8;
|
|
$16 = HEAP32[$0 + 24 >> 2];
|
|
$17 = $16 - 1 | 0;
|
|
$13 = HEAP32[$0 + 72 >> 2];
|
|
$18 = HEAP32[$0 + 28 >> 2];
|
|
$19 = Math_imul($18, $1);
|
|
$14 = $13 + ($19 << 2) | 0;
|
|
$20 = HEAP32[$0 + 88 >> 2];
|
|
$11 = HEAP32[$5 >> 2];
|
|
$12 = HEAP32[$3 >> 2];
|
|
$6 = $1 << 2;
|
|
$7 = $6 + HEAP32[$0 + 68 >> 2] | 0;
|
|
label$1 : {
|
|
if (HEAP32[$7 >> 2]) {
|
|
HEAP32[$8 + 12 >> 2] = $11;
|
|
HEAP32[$8 + 8 >> 2] = HEAP32[$7 >> 2];
|
|
HEAP32[$0 + 56 >> 2] = 1;
|
|
$9 = FUNCTION_TABLE[HEAP32[$0 + 84 >> 2]]($0, $1, $14, $8 + 8 | 0, $4, $8 + 12 | 0) | 0;
|
|
$7 = HEAP32[$8 + 8 >> 2];
|
|
$6 = HEAP32[$0 + 60 >> 2] + $6 | 0;
|
|
$10 = HEAP32[$6 >> 2];
|
|
if (($7 | 0) > ($10 | 0)) {
|
|
HEAP32[$8 + 8 >> 2] = $10;
|
|
$7 = $10;
|
|
}
|
|
HEAP32[$8 + 12 >> 2] = $9;
|
|
HEAP32[$6 >> 2] = HEAP32[$6 >> 2] - $7;
|
|
$7 = HEAP32[$8 + 8 >> 2];
|
|
if (($16 | 0) >= 2) {
|
|
$6 = 0;
|
|
while (1) {
|
|
HEAP32[($6 << 2) + $14 >> 2] = HEAP32[($6 + $7 << 2) + $14 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($17 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$15 = HEAP32[$0 + 68 >> 2] + ($1 << 2) | 0;
|
|
$9 = HEAP32[$15 >> 2] - $7 | 0;
|
|
HEAP32[$15 >> 2] = $9;
|
|
if ($9) {
|
|
$6 = 0;
|
|
$10 = HEAP32[$8 + 8 >> 2];
|
|
while (1) {
|
|
$7 = $6 + $17 | 0;
|
|
HEAP32[($7 << 2) + $14 >> 2] = HEAP32[($7 + $10 << 2) + $14 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($9 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = HEAP32[$8 + 12 >> 2];
|
|
$11 = $11 - $6 | 0;
|
|
if (HEAP32[$15 >> 2]) {
|
|
break label$1;
|
|
}
|
|
$4 = (Math_imul(HEAP32[$0 + 92 >> 2], $6) << 2) + $4 | 0;
|
|
}
|
|
if (!$11 | !$12) {
|
|
break label$1;
|
|
}
|
|
$15 = $18 - $17 | 0;
|
|
$18 = (($16 + $19 << 2) + $13 | 0) - 4 | 0;
|
|
while (1) {
|
|
$7 = $12 >>> 0 > $15 >>> 0 ? $15 : $12;
|
|
HEAP32[$8 + 12 >> 2] = $7;
|
|
HEAP32[$8 + 8 >> 2] = $11;
|
|
label$9 : {
|
|
if ($2) {
|
|
$6 = 0;
|
|
if (!$7) {
|
|
break label$9;
|
|
}
|
|
while (1) {
|
|
HEAP32[($6 + $17 << 2) + $14 >> 2] = HEAP32[(Math_imul($6, $20) << 2) + $2 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($7 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$9;
|
|
}
|
|
if (!$7) {
|
|
break label$9;
|
|
}
|
|
memset($18, 0, $7 << 2);
|
|
}
|
|
HEAP32[$0 + 56 >> 2] = 1;
|
|
$10 = HEAP32[$0 + 24 >> 2];
|
|
$7 = HEAP32[$0 + 72 >> 2] + (Math_imul(HEAP32[$0 + 28 >> 2], $1) << 2) | 0;
|
|
$16 = FUNCTION_TABLE[HEAP32[$0 + 84 >> 2]]($0, $1, $7, $8 + 12 | 0, $4, $8 + 8 | 0) | 0;
|
|
$9 = HEAP32[$8 + 12 >> 2];
|
|
$6 = HEAP32[$0 + 60 >> 2] + ($1 << 2) | 0;
|
|
$13 = HEAP32[$6 >> 2];
|
|
if (($9 | 0) > ($13 | 0)) {
|
|
HEAP32[$8 + 12 >> 2] = $13;
|
|
$9 = $13;
|
|
}
|
|
HEAP32[$8 + 8 >> 2] = $16;
|
|
HEAP32[$6 >> 2] = HEAP32[$6 >> 2] - $9;
|
|
$9 = HEAP32[$8 + 12 >> 2];
|
|
$6 = $9;
|
|
if (($10 | 0) >= 2) {
|
|
$10 = $10 - 1 | 0;
|
|
$6 = 0;
|
|
while (1) {
|
|
HEAP32[($6 << 2) + $7 >> 2] = HEAP32[($6 + $9 << 2) + $7 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($10 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = HEAP32[$8 + 12 >> 2];
|
|
}
|
|
$12 = $12 - $9 | 0;
|
|
$7 = HEAP32[$8 + 8 >> 2];
|
|
$11 = $11 - $7 | 0;
|
|
if (!$11) {
|
|
break label$1;
|
|
}
|
|
$2 = $2 ? (Math_imul($6, $20) << 2) + $2 | 0 : 0;
|
|
$4 = (Math_imul(HEAP32[$0 + 92 >> 2], $7) << 2) + $4 | 0;
|
|
if ($12) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$3 >> 2] = HEAP32[$3 >> 2] - $12;
|
|
HEAP32[$5 >> 2] = HEAP32[$5 >> 2] - $11;
|
|
__stack_pointer = $8 + 16 | 0;
|
|
$6 = HEAP32[$0 + 84 >> 2];
|
|
return ($6 | 0) == 9;
|
|
}
|
|
function check_control_input($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
label$10 : {
|
|
if ($0) {
|
|
$1 = HEAP32[$0 + 8 >> 2];
|
|
label$12 : {
|
|
if (($1 | 0) <= 23999) {
|
|
if (($1 | 0) == 8e3 | ($1 | 0) == 12e3) {
|
|
break label$12;
|
|
}
|
|
if (($1 | 0) != 16e3) {
|
|
break label$1;
|
|
}
|
|
break label$12;
|
|
}
|
|
if (($1 | 0) <= 44099) {
|
|
if (($1 | 0) == 24e3 | ($1 | 0) == 32e3) {
|
|
break label$12;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) == 48e3) {
|
|
break label$12;
|
|
}
|
|
if (($1 | 0) != 44100) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$1 = HEAP32[$0 + 20 >> 2];
|
|
if (($1 | 0) != 12e3 ? !(($1 | 0) == 8e3 | ($1 | 0) == 16e3) : 0) {
|
|
break label$1;
|
|
}
|
|
$2 = HEAP32[$0 + 12 >> 2];
|
|
if (($2 | 0) != 12e3 ? !(($2 | 0) == 8e3 | ($2 | 0) == 16e3) : 0) {
|
|
break label$1;
|
|
}
|
|
$3 = HEAP32[$0 + 16 >> 2];
|
|
if ((($3 | 0) != 12e3 ? !(($3 | 0) == 8e3 | ($3 | 0) == 16e3) : 0) | (($1 | 0) < ($3 | 0) | ($1 | 0) > ($2 | 0))) {
|
|
break label$1;
|
|
}
|
|
if (($2 | 0) < ($3 | 0)) {
|
|
break label$1;
|
|
}
|
|
label$18 : {
|
|
label$19 : {
|
|
$1 = HEAP32[$0 + 24 >> 2];
|
|
switch ($1 - 10 | 0) {
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
break label$10;
|
|
case 0:
|
|
case 10:
|
|
break label$18;
|
|
default:
|
|
break label$19;
|
|
}
|
|
}
|
|
if (($1 | 0) == 40) {
|
|
break label$18;
|
|
}
|
|
if (($1 | 0) != 60) {
|
|
break label$10;
|
|
}
|
|
}
|
|
if (HEAPU32[$0 + 32 >> 2] >= 101) {
|
|
break label$9;
|
|
}
|
|
if (HEAPU32[$0 + 48 >> 2] >= 2) {
|
|
break label$8;
|
|
}
|
|
if (HEAPU32[$0 + 52 >> 2] >= 2) {
|
|
break label$7;
|
|
}
|
|
if (HEAPU32[$0 + 40 >> 2] >= 2) {
|
|
break label$6;
|
|
}
|
|
$1 = HEAP32[$0 >> 2];
|
|
if ($1 - 1 >>> 0 >= 2) {
|
|
break label$5;
|
|
}
|
|
$2 = HEAP32[$0 + 4 >> 2];
|
|
if ($2 - 1 >>> 0 >= 2) {
|
|
break label$4;
|
|
}
|
|
if (($1 | 0) < ($2 | 0)) {
|
|
break label$3;
|
|
}
|
|
if (HEAPU32[$0 + 36 >> 2] >= 11) {
|
|
break label$2;
|
|
}
|
|
return 0;
|
|
}
|
|
celt_fatal(1952, 1989, 41);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 69);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 73);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 77);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 81);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 85);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 89);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 93);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 97);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 101);
|
|
abort();
|
|
}
|
|
celt_fatal(2016, 1989, 62);
|
|
abort();
|
|
}
|
|
function silk_NLSF_encode($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0;
|
|
$7 = __stack_pointer - 128 | 0;
|
|
$10 = $7;
|
|
__stack_pointer = $7;
|
|
if ($6 >>> 0 < 3) {
|
|
silk_NLSF_stabilize($1, HEAP32[$2 + 36 >> 2], HEAP16[$2 + 2 >> 1]);
|
|
$7 = $7 - ((HEAPU16[$2 >> 1] << 2) + 15 & 524272) | 0;
|
|
__stack_pointer = $7;
|
|
silk_NLSF_VQ($7, $1, HEAP32[$2 + 8 >> 2], HEAP32[$2 + 12 >> 2], HEAP16[$2 >> 1], HEAP16[$2 + 2 >> 1]);
|
|
$9 = ($5 << 2) + 15 & -16;
|
|
$18 = $7 - $9 | 0;
|
|
$8 = $18;
|
|
__stack_pointer = $8;
|
|
silk_insertion_sort_increasing($7, $8, HEAP16[$2 >> 1], $5);
|
|
$15 = $8 - $9 | 0;
|
|
$7 = $15;
|
|
__stack_pointer = $7;
|
|
$19 = $7 - ($5 << 4) | 0;
|
|
__stack_pointer = $19;
|
|
if (($5 | 0) >= 1) {
|
|
$23 = $6 >>> 1 | 0;
|
|
$24 = $4 << 14 >> 16;
|
|
while (1) {
|
|
$22 = $16 << 2;
|
|
$17 = HEAP32[$22 + $18 >> 2];
|
|
$20 = HEAP16[$2 + 2 >> 1];
|
|
if (($20 | 0) >= 1) {
|
|
$7 = Math_imul($17, $20);
|
|
$25 = $7 + HEAP32[$2 + 8 >> 2] | 0;
|
|
$26 = HEAP32[$2 + 12 >> 2] + ($7 << 1) | 0;
|
|
$6 = 0;
|
|
while (1) {
|
|
$7 = $6 << 1;
|
|
$8 = HEAP16[$26 + $7 >> 1];
|
|
HEAP16[($10 + 80 | 0) + $7 >> 1] = Math_imul(HEAPU16[$1 + $7 >> 1] - (HEAPU8[$6 + $25 | 0] << 7) << 16 >> 16, $8) >>> 14;
|
|
$9 = HEAP16[$3 + $7 >> 1];
|
|
$11 = $9 >> 31;
|
|
$11 = Math_clz32($11 ^ $9 + $11);
|
|
$9 = $9 << $11 - 1;
|
|
$27 = $9;
|
|
$8 = Math_imul($8, $8);
|
|
$14 = Math_clz32($8);
|
|
$13 = $8 << $14 - 1;
|
|
$8 = 536870911 / ($13 >> 16) << 16 >> 16;
|
|
$9 = (Math_imul($8, $9 & 65535) >> 16) + Math_imul($9 >> 16, $8) | 0;
|
|
$12 = $9 >> 31;
|
|
$21 = $12;
|
|
$12 = $13 >> 31;
|
|
$28 = $12;
|
|
$12 = $21;
|
|
$21 = __wasm_i64_mul($9, $12, $13, $28);
|
|
$12 = i64toi32_i32$HIGH_BITS;
|
|
$13 = $27 - ((($12 & 536870911) << 3 | $21 >>> 29) & -8) | 0;
|
|
$8 = (Math_imul($13 >> 16, $8) + $9 | 0) + (Math_imul($13 & 65535, $8) >> 16) | 0;
|
|
$9 = $11 - $14 | 0;
|
|
$11 = $9 + 8 | 0;
|
|
$7 = ($10 + 48 | 0) + $7 | 0;
|
|
$9 = $9 + 29 | 0;
|
|
label$6 : {
|
|
if (($9 | 0) <= 20) {
|
|
$9 = 0 - $11 | 0;
|
|
$11 = 2147483647 >>> $9 | 0;
|
|
$14 = -2147483648 >> $9;
|
|
$8 = (($8 | 0) > ($11 | 0) ? $11 : ($8 | 0) < ($14 | 0) ? $14 : $8) << $9;
|
|
break label$6;
|
|
}
|
|
$8 = ($9 | 0) < 53 ? $8 >> $11 : 0;
|
|
}
|
|
HEAP16[$7 >> 1] = $8;
|
|
$6 = $6 + 1 | 0;
|
|
if (($20 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_NLSF_unpack($10, $10 + 32 | 0, $2, $17);
|
|
$6 = $15 + $22 | 0;
|
|
HEAP32[$6 >> 2] = silk_NLSF_del_dec_quant(($16 << 4) + $19 | 0, $10 + 80 | 0, $10 + 48 | 0, $10 + 32 | 0, $10, HEAP32[$2 + 32 >> 2], HEAP16[$2 + 4 >> 1], HEAP16[$2 + 6 >> 1], $4, HEAP16[$2 + 2 >> 1]);
|
|
$7 = HEAP32[$2 + 16 >> 2] + Math_imul(HEAP16[$2 >> 1], $23) | 0;
|
|
$12 = $6;
|
|
if ($17) {
|
|
$7 = $7 + $17 | 0;
|
|
$8 = HEAPU8[$7 - 1 | 0];
|
|
} else {
|
|
$8 = 256;
|
|
}
|
|
HEAP32[$12 >> 2] = Math_imul(67108864 - (silk_lin2log($8 - HEAPU8[$7 | 0] | 0) << 16) >> 16, $24) + HEAP32[$6 >> 2];
|
|
$16 = $16 + 1 | 0;
|
|
if (($16 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_insertion_sort_increasing($15, $10 + 124 | 0, $5, 1);
|
|
$7 = HEAP32[$10 + 124 >> 2];
|
|
HEAP8[$0 | 0] = HEAP32[($7 << 2) + $18 >> 2];
|
|
memcpy($0 + 1 | 0, ($7 << 4) + $19 | 0, HEAP16[$2 + 2 >> 1]);
|
|
silk_NLSF_decode($1, $0, $2);
|
|
__stack_pointer = $10 + 128 | 0;
|
|
$7 = HEAP32[$15 >> 2];
|
|
return $7;
|
|
}
|
|
celt_fatal(15776, 15829, 63);
|
|
abort();
|
|
}
|
|
function _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
label$5 : {
|
|
label$6 : {
|
|
label$7 : {
|
|
label$8 : {
|
|
label$9 : {
|
|
label$11 : {
|
|
$5 = $1;
|
|
if ($5) {
|
|
$7 = $2;
|
|
if (!$7) {
|
|
break label$11;
|
|
}
|
|
$4 = $3;
|
|
if (!$4) {
|
|
break label$9;
|
|
}
|
|
$5 = Math_clz32($4) - Math_clz32($5) | 0;
|
|
if ($5 >>> 0 <= 31) {
|
|
break label$8;
|
|
}
|
|
break label$2;
|
|
}
|
|
$4 = $3;
|
|
if (($4 | 0) == 1 | $4 >>> 0 > 1) {
|
|
break label$2;
|
|
}
|
|
$5 = $0;
|
|
$7 = $2;
|
|
$5 = ($5 >>> 0) / ($7 >>> 0) | 0;
|
|
i64toi32_i32$HIGH_BITS = 0;
|
|
return $5;
|
|
}
|
|
$7 = $3;
|
|
if (!$0) {
|
|
break label$7;
|
|
}
|
|
if (!$7) {
|
|
break label$6;
|
|
}
|
|
$4 = $7 - 1 | 0;
|
|
if ($4 & $7) {
|
|
break label$6;
|
|
}
|
|
$9 = $5 >>> __wasm_ctz_i32($7) | 0;
|
|
i64toi32_i32$HIGH_BITS = 0;
|
|
return $9;
|
|
}
|
|
if (!($7 - 1 & $7)) {
|
|
break label$5;
|
|
}
|
|
$5 = (Math_clz32($7) + 33 | 0) - Math_clz32($5) | 0;
|
|
$7 = 0 - $5 | 0;
|
|
break label$3;
|
|
}
|
|
$7 = 63 - $5 | 0;
|
|
$5 = $5 + 1 | 0;
|
|
break label$3;
|
|
}
|
|
$4 = ($5 >>> 0) / ($7 >>> 0) | 0;
|
|
i64toi32_i32$HIGH_BITS = 0;
|
|
return $4;
|
|
}
|
|
$5 = Math_clz32($7) - Math_clz32($5) | 0;
|
|
if ($5 >>> 0 < 31) {
|
|
break label$4;
|
|
}
|
|
break label$2;
|
|
}
|
|
if (($7 | 0) == 1) {
|
|
break label$1;
|
|
}
|
|
$4 = $1;
|
|
$9 = $0;
|
|
$10 = 0;
|
|
$8 = __wasm_ctz_i32($7);
|
|
$6 = $8 & 31;
|
|
if (($8 & 63) >>> 0 >= 32) {
|
|
$9 = $4 >>> $6 | 0;
|
|
} else {
|
|
$10 = $4 >>> $6 | 0;
|
|
$9 = ((1 << $6) - 1 & $4) << 32 - $6 | $9 >>> $6;
|
|
}
|
|
i64toi32_i32$HIGH_BITS = $10;
|
|
return $9;
|
|
}
|
|
$7 = 63 - $5 | 0;
|
|
$5 = $5 + 1 | 0;
|
|
}
|
|
$9 = $1;
|
|
$4 = $0;
|
|
$10 = 0;
|
|
$8 = $5 & 63;
|
|
$6 = $8 & 31;
|
|
if (($8 & 63) >>> 0 >= 32) {
|
|
$12 = $9 >>> $6 | 0;
|
|
} else {
|
|
$10 = $9 >>> $6 | 0;
|
|
$12 = ((1 << $6) - 1 & $9) << 32 - $6 | $4 >>> $6;
|
|
}
|
|
$13 = $10;
|
|
$10 = $1;
|
|
$9 = $0;
|
|
$8 = $7 & 63;
|
|
$6 = $8 & 31;
|
|
if (($8 & 63) >>> 0 >= 32) {
|
|
$4 = $9 << $6;
|
|
$0 = 0;
|
|
} else {
|
|
$4 = (1 << $6) - 1 & $9 >>> 32 - $6 | $10 << $6;
|
|
$0 = $9 << $6;
|
|
}
|
|
$1 = $4;
|
|
if ($5) {
|
|
$4 = $3 - 1 | 0;
|
|
$6 = $2 - 1 | 0;
|
|
$4 = ($6 | 0) != -1 ? $4 + 1 | 0 : $4;
|
|
$7 = $6;
|
|
$9 = $4;
|
|
while (1) {
|
|
$4 = $12;
|
|
$8 = $4 << 1;
|
|
$4 = $13 << 1 | $4 >>> 31;
|
|
$12 = $8 | $1 >>> 31;
|
|
$11 = $12;
|
|
$10 = $4;
|
|
$4 = $7;
|
|
$8 = $11;
|
|
$6 = $9 - (($4 >>> 0 < $8 >>> 0) + $10 | 0) | 0;
|
|
$13 = $3 & $6 >> 31;
|
|
$4 = $8;
|
|
$11 = $6 >> 31;
|
|
$8 = $11 & $2;
|
|
$12 = $4 - $8 | 0;
|
|
$13 = $10 - (($4 >>> 0 < $8 >>> 0) + $13 | 0) | 0;
|
|
$4 = $1 << 1 | $0 >>> 31;
|
|
$0 = $0 << 1 | $14;
|
|
$1 = $4 | $16;
|
|
$15 = 0;
|
|
$11 = $11 & 1;
|
|
$14 = $11;
|
|
$5 = $5 - 1 | 0;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
i64toi32_i32$HIGH_BITS = $15 | ($1 << 1 | $0 >>> 31);
|
|
return $0 << 1 | $11;
|
|
}
|
|
$0 = 0;
|
|
$1 = 0;
|
|
}
|
|
i64toi32_i32$HIGH_BITS = $1;
|
|
return $0;
|
|
}
|
|
function silk_NSQ_wrapper_FLP($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0;
|
|
$7 = __stack_pointer - 1008 | 0;
|
|
__stack_pointer = $7;
|
|
label$1 : {
|
|
label$2 : {
|
|
$10 = HEAP32[$0 + 4580 >> 2];
|
|
if (($10 | 0) < 1) {
|
|
break label$2;
|
|
}
|
|
$11 = HEAP32[$0 + 4636 >> 2];
|
|
$13 = ($11 | 0) < 1;
|
|
while (1) {
|
|
if (!$13) {
|
|
$9 = Math_imul($12, 24);
|
|
$6 = 0;
|
|
while (1) {
|
|
$8 = $6 + $9 | 0;
|
|
HEAP16[($7 + 48 | 0) + ($8 << 1) >> 1] = lrintf(Math_fround(HEAPF32[(($8 << 2) + $1 | 0) + 244 >> 2] * Math_fround(8192)));
|
|
$6 = $6 + 1 | 0;
|
|
if (($11 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$9 = 0;
|
|
if (($10 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
while (1) {
|
|
$6 = $9 << 2;
|
|
$8 = $6 + $1 | 0;
|
|
$11 = lrintf(Math_fround(HEAPF32[$8 + 644 >> 2] * Math_fround(16384)));
|
|
HEAP32[($7 + 32 | 0) + $6 >> 2] = lrintf(Math_fround(HEAPF32[$8 + 628 >> 2] * Math_fround(16384))) & 65535 | $11 << 16;
|
|
HEAP32[($7 + 16 | 0) + $6 >> 2] = lrintf(Math_fround(HEAPF32[$8 + 660 >> 2] * Math_fround(16384)));
|
|
HEAP32[$6 + $7 >> 2] = lrintf(Math_fround(HEAPF32[$8 + 676 >> 2] * Math_fround(16384)));
|
|
$9 = $9 + 1 | 0;
|
|
if (($10 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$11 = lrintf(Math_fround(HEAPF32[$1 + 692 >> 2] * Math_fround(1024)));
|
|
if (($10 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$6 = Math_imul($10, 5);
|
|
$8 = ($6 | 0) > 1 ? $6 : 1;
|
|
$6 = 0;
|
|
while (1) {
|
|
HEAP16[($7 + 240 | 0) + ($6 << 1) >> 1] = lrintf(Math_fround(HEAPF32[(($6 << 2) + $1 | 0) + 144 >> 2] * Math_fround(16384)));
|
|
$6 = $6 + 1 | 0;
|
|
if (($8 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
$11 = lrintf(Math_fround(HEAPF32[$1 + 692 >> 2] * Math_fround(1024)));
|
|
}
|
|
$6 = 0;
|
|
$8 = HEAP32[$0 + 4640 >> 2];
|
|
label$8 : {
|
|
if (($8 | 0) <= 0) {
|
|
break label$8;
|
|
}
|
|
while (1) {
|
|
HEAP16[($7 + 288 | 0) + ($6 << 1) >> 1] = lrintf(Math_fround(HEAPF32[(($6 << 2) + $1 | 0) + 16 >> 2] * Math_fround(4096)));
|
|
$6 = $6 + 1 | 0;
|
|
if (($8 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = 0;
|
|
if (($8 | 0) <= 0) {
|
|
break label$8;
|
|
}
|
|
while (1) {
|
|
HEAP16[(($6 << 1) + $7 | 0) + 320 >> 1] = lrintf(Math_fround(HEAPF32[(($6 << 2) + $1 | 0) + 80 >> 2] * Math_fround(4096)));
|
|
$6 = $6 + 1 | 0;
|
|
if (($8 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = 0;
|
|
if (($10 | 0) > 0) {
|
|
while (1) {
|
|
$8 = $6 << 2;
|
|
HEAP32[$8 + ($7 + 352 | 0) >> 2] = lrintf(Math_fround(HEAPF32[$1 + $8 >> 2] * Math_fround(65536)));
|
|
$6 = $6 + 1 | 0;
|
|
if (($10 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = 0;
|
|
$9 = 0;
|
|
$9 = HEAPU8[$2 + 29 | 0] == 2 ? HEAP16[(HEAP8[$2 + 33 | 0] << 1) + 5848 >> 1] : $9;
|
|
$8 = HEAP32[$0 + 4584 >> 2];
|
|
if (($8 | 0) >= 1) {
|
|
while (1) {
|
|
HEAP16[($7 + 368 | 0) + ($6 << 1) >> 1] = lrintf(HEAPF32[($6 << 2) + $5 >> 2]);
|
|
$6 = $6 + 1 | 0;
|
|
if (($8 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$16 : {
|
|
if (!(HEAP32[$0 + 4672 >> 2] < 1 ? HEAP32[$0 + 4628 >> 2] <= 1 : 0)) {
|
|
silk_NSQ_del_dec_c($0, $3, $2, $7 + 368 | 0, $4, $7 + 288 | 0, $7 + 240 | 0, $7 + 48 | 0, $7, $7 + 16 | 0, $7 + 32 | 0, $7 + 352 | 0, $1 + 228 | 0, $11, $9);
|
|
break label$16;
|
|
}
|
|
silk_NSQ_c($0, $3, $2, $7 + 368 | 0, $4, $7 + 288 | 0, $7 + 240 | 0, $7 + 48 | 0, $7, $7 + 16 | 0, $7 + 32 | 0, $7 + 352 | 0, $1 + 228 | 0, $11, $9);
|
|
}
|
|
__stack_pointer = $7 + 1008 | 0;
|
|
}
|
|
function ec_dec_uint($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
if ($1 >>> 0 > 1) {
|
|
$10 = $1 - 1 | 0;
|
|
label$2 : {
|
|
if ($10 >>> 0 >= 256) {
|
|
$4 = HEAP32[$0 + 28 >> 2];
|
|
$7 = 24 - Math_clz32($10) | 0;
|
|
$2 = $10 >>> $7 | 0;
|
|
$3 = $2 + 1 | 0;
|
|
$1 = ($4 >>> 0) / ($3 >>> 0) | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
$5 = HEAP32[$0 + 32 >> 2];
|
|
$8 = $5;
|
|
$5 = ($5 >>> 0) / ($1 >>> 0) | 0;
|
|
$6 = $5 + 1 | 0;
|
|
$3 = $6 - $3 | 0;
|
|
$11 = ($3 >>> 0 > $6 >>> 0 ? 0 : $3) + ($2 - $5 | 0) | 0;
|
|
$2 = Math_imul($2 - $11 | 0, $1);
|
|
$3 = $8 - $2 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $3;
|
|
$2 = $11 ? $1 : $4 - $2 | 0;
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
if ($2 >>> 0 <= 8388608) {
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
$5 = HEAP32[$0 + 40 >> 2];
|
|
$6 = HEAP32[$0 + 20 >> 2];
|
|
$12 = HEAP32[$0 + 4 >> 2];
|
|
while (1) {
|
|
$8 = $2 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $8;
|
|
$6 = $6 + 8 | 0;
|
|
HEAP32[$0 + 20 >> 2] = $6;
|
|
$1 = 0;
|
|
if ($4 >>> 0 < $12 >>> 0) {
|
|
$9 = $4 + 1 | 0;
|
|
HEAP32[$0 + 24 >> 2] = $9;
|
|
$1 = HEAPU8[HEAP32[$0 >> 2] + $4 | 0];
|
|
$4 = $9;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $1;
|
|
$3 = (($5 << 8 | $1) >>> 1 & 255 | $3 << 8 & 2147483392) ^ 255;
|
|
HEAP32[$0 + 32 >> 2] = $3;
|
|
$9 = $2 >>> 0 < 32769;
|
|
$5 = $1;
|
|
$2 = $8;
|
|
if ($9) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $11 << $7;
|
|
$3 = HEAP32[$0 + 12 >> 2];
|
|
$1 = HEAP32[$0 + 16 >> 2];
|
|
label$7 : {
|
|
if ($7 >>> 0 <= $1 >>> 0) {
|
|
$6 = $1;
|
|
break label$7;
|
|
}
|
|
$2 = HEAP32[$0 + 8 >> 2];
|
|
$5 = HEAP32[$0 + 4 >> 2];
|
|
while (1) {
|
|
$4 = 0;
|
|
if ($2 >>> 0 < $5 >>> 0) {
|
|
$2 = $2 + 1 | 0;
|
|
HEAP32[$0 + 8 >> 2] = $2;
|
|
$4 = HEAPU8[HEAP32[$0 >> 2] + ($5 - $2 | 0) | 0];
|
|
}
|
|
$3 = $4 << $1 | $3;
|
|
$4 = ($1 | 0) < 17;
|
|
$6 = $1 + 8 | 0;
|
|
$1 = $6;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 16 >> 2] = $6 - $7;
|
|
HEAP32[$0 + 12 >> 2] = $3 >>> $7;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $7;
|
|
$7 = (-1 << $7 ^ -1) & $3 | $8;
|
|
if ($10 >>> 0 >= $7 >>> 0) {
|
|
break label$2;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = 1;
|
|
return $10;
|
|
}
|
|
$4 = HEAP32[$0 + 28 >> 2];
|
|
$2 = ($4 >>> 0) / ($1 >>> 0) | 0;
|
|
HEAP32[$0 + 36 >> 2] = $2;
|
|
$3 = HEAP32[$0 + 32 >> 2];
|
|
$8 = $3;
|
|
$3 = ($3 >>> 0) / ($2 >>> 0) | 0;
|
|
$9 = ($3 ^ -1) + $1 | 0;
|
|
$3 = $3 + 1 | 0;
|
|
$5 = $3 - $1 | 0;
|
|
$7 = $9 + ($3 >>> 0 < $5 >>> 0 ? 0 : $5) | 0;
|
|
$1 = Math_imul(($7 ^ -1) + $1 | 0, $2);
|
|
$3 = $8 - $1 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $3;
|
|
$2 = $7 ? $2 : $4 - $1 | 0;
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
if ($2 >>> 0 > 8388608) {
|
|
break label$2;
|
|
}
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
$5 = HEAP32[$0 + 40 >> 2];
|
|
$6 = HEAP32[$0 + 20 >> 2];
|
|
$12 = HEAP32[$0 + 4 >> 2];
|
|
while (1) {
|
|
$8 = $2 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $8;
|
|
$6 = $6 + 8 | 0;
|
|
HEAP32[$0 + 20 >> 2] = $6;
|
|
$1 = 0;
|
|
if ($4 >>> 0 < $12 >>> 0) {
|
|
$9 = $4 + 1 | 0;
|
|
HEAP32[$0 + 24 >> 2] = $9;
|
|
$1 = HEAPU8[HEAP32[$0 >> 2] + $4 | 0];
|
|
$4 = $9;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $1;
|
|
$3 = (($5 << 8 | $1) >>> 1 & 255 | $3 << 8 & 2147483392) ^ 255;
|
|
HEAP32[$0 + 32 >> 2] = $3;
|
|
$9 = $2 >>> 0 < 32769;
|
|
$5 = $1;
|
|
$2 = $8;
|
|
if ($9) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $7;
|
|
}
|
|
celt_fatal(9274, 9298, 203);
|
|
abort();
|
|
}
|
|
function downmix_and_resample($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
var $10 = Math_fround(0), $11 = 0, $12 = Math_fround(0), $13 = Math_fround(0), $14 = Math_fround(0), $15 = Math_fround(0), $16 = 0, $17 = Math_fround(0), $18 = Math_fround(0), $19 = Math_fround(0), $20 = 0;
|
|
$11 = __stack_pointer;
|
|
$16 = $11;
|
|
if (!$4) {
|
|
__stack_pointer = $16;
|
|
return Math_fround(0);
|
|
}
|
|
label$2 : {
|
|
if (($9 | 0) == 48e3) {
|
|
$5 = $5 << 1;
|
|
$4 = $4 << 1;
|
|
break label$2;
|
|
}
|
|
if (($9 | 0) != 16e3) {
|
|
break label$2;
|
|
}
|
|
$5 = ($5 << 1) / 3 | 0;
|
|
$4 = ($4 << 1) / 3 | 0;
|
|
}
|
|
$11 = $11 - (($4 << 2) + 15 & -16) | 0;
|
|
$20 = $11;
|
|
__stack_pointer = $11;
|
|
FUNCTION_TABLE[$0 | 0]($1, $11, $4, $5, $6, $7, $8);
|
|
$10 = ($7 | 0) == -2 ? Math_fround(Math_fround(30517578125e-15) / Math_fround($8 | 0)) : ($7 | 0) > -1 ? Math_fround(152587890625e-16) : Math_fround(30517578125e-15);
|
|
if (($4 | 0) >= 1) {
|
|
$7 = 0;
|
|
while (1) {
|
|
$5 = ($7 << 2) + $11 | 0;
|
|
HEAPF32[$5 >> 2] = $10 * HEAPF32[$5 >> 2];
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$8 : {
|
|
if (($9 | 0) == 48e3) {
|
|
$9 = ($4 | 0) / 2 | 0;
|
|
if (($4 | 0) < 2) {
|
|
break label$8;
|
|
}
|
|
$7 = 0;
|
|
while (1) {
|
|
$5 = $7 << 3;
|
|
$10 = HEAPF32[$11 + $5 >> 2];
|
|
$12 = HEAPF32[$3 >> 2];
|
|
$13 = Math_fround(Math_fround($10 - $12) * Math_fround(.6074370741844177));
|
|
HEAPF32[$3 >> 2] = $10 + $13;
|
|
$10 = HEAPF32[($5 | 4) + $11 >> 2];
|
|
$14 = HEAPF32[$3 + 4 >> 2];
|
|
$15 = Math_fround(Math_fround($10 - $14) * Math_fround(.15062999725341797));
|
|
HEAPF32[$3 + 4 >> 2] = $10 + $15;
|
|
$17 = HEAPF32[$3 + 8 >> 2];
|
|
$18 = Math_fround(Math_fround(Math_fround(-$10) - $17) * Math_fround(.15062999725341797));
|
|
HEAPF32[$3 + 8 >> 2] = $18 - $10;
|
|
$10 = Math_fround($12 + $13);
|
|
HEAPF32[($7 << 2) + $2 >> 2] = Math_fround(Math_fround($14 + $10) + $15) * Math_fround(.5);
|
|
$10 = Math_fround(Math_fround($10 + $17) + $18);
|
|
$19 = Math_fround($19 + Math_fround($10 * $10));
|
|
$7 = $7 + 1 | 0;
|
|
if (($9 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$8;
|
|
}
|
|
if (($9 | 0) != 16e3) {
|
|
if (($9 | 0) != 24e3) {
|
|
break label$8;
|
|
}
|
|
memcpy($2, $11, $4 << 2);
|
|
break label$8;
|
|
}
|
|
$1 = $20;
|
|
$0 = Math_imul($4, 3);
|
|
$8 = $1 - (($0 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $8;
|
|
if (($4 | 0) >= 1) {
|
|
$7 = 0;
|
|
while (1) {
|
|
$5 = Math_imul($7, 12) + $8 | 0;
|
|
$9 = HEAP32[($7 << 2) + $11 >> 2];
|
|
HEAP32[$5 + 8 >> 2] = $9;
|
|
HEAP32[$5 + 4 >> 2] = $9;
|
|
HEAP32[$5 >> 2] = $9;
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = ($0 | 0) / 2 | 0;
|
|
if (($0 | 0) >= 2) {
|
|
$7 = 0;
|
|
while (1) {
|
|
$11 = $7 << 3;
|
|
$10 = HEAPF32[$11 + $8 >> 2];
|
|
$12 = HEAPF32[$3 >> 2];
|
|
$13 = Math_fround(Math_fround($10 - $12) * Math_fround(.6074370741844177));
|
|
HEAPF32[$3 >> 2] = $10 + $13;
|
|
$10 = HEAPF32[($11 | 4) + $8 >> 2];
|
|
$14 = HEAPF32[$3 + 4 >> 2];
|
|
$15 = Math_fround(Math_fround($10 - $14) * Math_fround(.15062999725341797));
|
|
HEAPF32[$3 + 4 >> 2] = $10 + $15;
|
|
HEAPF32[$3 + 8 >> 2] = Math_fround(Math_fround(Math_fround(-$10) - HEAPF32[$3 + 8 >> 2]) * Math_fround(.15062999725341797)) - $10;
|
|
HEAPF32[($7 << 2) + $2 >> 2] = Math_fround(Math_fround($14 + Math_fround($12 + $13)) + $15) * Math_fround(.5);
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
__stack_pointer = $16;
|
|
return $19;
|
|
}
|
|
function op_pvq_search_c($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = Math_fround(0), $7 = Math_fround(0), $8 = 0, $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = 0, $18 = Math_fround(0);
|
|
$4 = __stack_pointer;
|
|
$17 = $4;
|
|
$5 = ($3 << 2) + 15 & -16;
|
|
$4 = $4 - $5 | 0;
|
|
__stack_pointer = $4;
|
|
$14 = $4 - $5 | 0;
|
|
__stack_pointer = $14;
|
|
$11 = ($3 | 0) > 1 ? $3 : 1;
|
|
$12 = memset($4, 0, $11 << 2);
|
|
$4 = 0;
|
|
while (1) {
|
|
$5 = $4 << 2;
|
|
$8 = $5 + $0 | 0;
|
|
$6 = HEAPF32[$8 >> 2];
|
|
HEAP32[$5 + $14 >> 2] = $6 < Math_fround(0);
|
|
HEAPF32[$8 >> 2] = Math_abs($6);
|
|
HEAP32[$1 + $5 >> 2] = 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = Math_fround(0);
|
|
if (($2 | 0) > $3 >> 1) {
|
|
$4 = 0;
|
|
while (1) {
|
|
$6 = Math_fround($6 + HEAPF32[($4 << 2) + $0 >> 2]);
|
|
$4 = $4 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!($6 < Math_fround(64) ? !($6 > Math_fround(1.0000000036274937e-15) ^ 1) : 0)) {
|
|
HEAP32[$0 >> 2] = 1065353216;
|
|
memset($0 + 4 | 0, 0, ((($3 | 0) > 2 ? $3 : 2) << 2) - 4 | 0);
|
|
$6 = Math_fround(1);
|
|
}
|
|
$9 = Math_fround(Math_fround(Math_fround($2 | 0) + Math_fround(.800000011920929)) * Math_fround(Math_fround(1) / $6));
|
|
$5 = 0;
|
|
$6 = Math_fround(0);
|
|
while (1) {
|
|
$8 = $5 << 2;
|
|
$15 = $8 + $1 | 0;
|
|
$10 = HEAPF32[$0 + $8 >> 2];
|
|
$7 = Math_fround(Math_floor(Math_fround($9 * $10)));
|
|
label$7 : {
|
|
if (Math_fround(Math_abs($7)) < Math_fround(2147483648)) {
|
|
$4 = ~~$7;
|
|
break label$7;
|
|
}
|
|
$4 = -2147483648;
|
|
}
|
|
HEAP32[$15 >> 2] = $4;
|
|
$7 = Math_fround($4 | 0);
|
|
HEAPF32[$8 + $12 >> 2] = $7 + $7;
|
|
$13 = Math_fround($13 + Math_fround($10 * $7));
|
|
$2 = $2 - $4 | 0;
|
|
$6 = Math_fround($6 + Math_fround($7 * $7));
|
|
$5 = $5 + 1 | 0;
|
|
if (($11 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$9 : {
|
|
if (($3 + 3 | 0) < ($2 | 0)) {
|
|
$10 = HEAPF32[$12 >> 2];
|
|
HEAP32[$1 >> 2] = HEAP32[$1 >> 2] + $2;
|
|
$7 = Math_fround($2 | 0);
|
|
$6 = Math_fround(Math_fround($6 + Math_fround($7 * $7)) + Math_fround($10 * $7));
|
|
break label$9;
|
|
}
|
|
if (($2 | 0) < 1) {
|
|
break label$9;
|
|
}
|
|
$15 = ($3 | 0) > 2 ? $3 : 2;
|
|
$18 = HEAPF32[$0 >> 2];
|
|
$3 = 0;
|
|
while (1) {
|
|
$16 = Math_fround($6 + Math_fround(1));
|
|
$6 = Math_fround($16 + HEAPF32[$12 >> 2]);
|
|
$7 = Math_fround($13 + $18);
|
|
$7 = Math_fround($7 * $7);
|
|
$4 = 1;
|
|
$8 = 0;
|
|
while (1) {
|
|
$5 = $4 << 2;
|
|
$10 = Math_fround($16 + HEAPF32[$12 + $5 >> 2]);
|
|
$9 = Math_fround($13 + HEAPF32[$0 + $5 >> 2]);
|
|
$9 = Math_fround($9 * $9);
|
|
$5 = Math_fround($6 * $9) > Math_fround($7 * $10);
|
|
$6 = $5 ? $10 : $6;
|
|
$7 = $5 ? $9 : $7;
|
|
$8 = $5 ? $4 : $8;
|
|
$4 = $4 + 1 | 0;
|
|
if (($15 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $8 << 2;
|
|
$7 = HEAPF32[$4 + $0 >> 2];
|
|
$5 = $4 + $12 | 0;
|
|
$6 = HEAPF32[$5 >> 2];
|
|
HEAPF32[$5 >> 2] = $6 + Math_fround(2);
|
|
$4 = $1 + $4 | 0;
|
|
HEAP32[$4 >> 2] = HEAP32[$4 >> 2] + 1;
|
|
$6 = Math_fround($16 + $6);
|
|
$13 = Math_fround($13 + $7);
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = 0;
|
|
while (1) {
|
|
$5 = $4 << 2;
|
|
$8 = $5 + $1 | 0;
|
|
$5 = HEAP32[$5 + $14 >> 2];
|
|
HEAP32[$8 >> 2] = $5 + (HEAP32[$8 >> 2] ^ 0 - $5);
|
|
$4 = $4 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
__stack_pointer = $17;
|
|
return $6;
|
|
}
|
|
function silk_LP_variable_cutoff($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
$5 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $5;
|
|
$11 = HEAP32[$0 + 12 >> 2];
|
|
if ($11) {
|
|
$12 = HEAP32[$0 + 8 >> 2];
|
|
$3 = 262144 - ($12 << 10) | 0;
|
|
label$2 : {
|
|
if (($3 | 0) <= 262143) {
|
|
$7 = $3 >> 16;
|
|
$4 = $3 & 64512;
|
|
if ($4) {
|
|
$10 = $7 + 1 | 0;
|
|
$3 = $4 << 16 >> 16;
|
|
if ($4 >>> 0 >= 32768) {
|
|
$4 = Math_imul($10, 12);
|
|
$8 = HEAP32[$4 + 5896 >> 2];
|
|
$6 = Math_imul($7, 12);
|
|
$9 = $8 - HEAP32[$6 + 5896 >> 2] | 0;
|
|
HEAP32[$5 + 24 >> 2] = (Math_imul($9 >> 16, $3) + $8 | 0) + (Math_imul($9 & 65535, $3) >> 16);
|
|
$8 = HEAP32[$4 + 5892 >> 2];
|
|
$9 = $8 - HEAP32[$6 + 5892 >> 2] | 0;
|
|
HEAP32[$5 + 20 >> 2] = (Math_imul($9 >> 16, $3) + $8 | 0) + (Math_imul($9 & 65535, $3) >> 16);
|
|
$4 = HEAP32[$4 + 5888 >> 2];
|
|
$6 = $4 - HEAP32[$6 + 5888 >> 2] | 0;
|
|
HEAP32[$5 + 16 >> 2] = (Math_imul($6 >> 16, $3) + $4 | 0) + (Math_imul($6 & 65535, $3) >> 16);
|
|
$4 = $10 << 3;
|
|
$10 = HEAP32[$4 + 5956 >> 2];
|
|
$7 = $7 << 3;
|
|
$6 = $10 - HEAP32[$7 + 5956 >> 2] | 0;
|
|
HEAP32[$5 + 12 >> 2] = (Math_imul($6 >> 16, $3) + $10 | 0) + (Math_imul($6 & 65535, $3) >> 16);
|
|
$4 = HEAP32[$4 + 5952 >> 2];
|
|
$7 = $4 - HEAP32[$7 + 5952 >> 2] | 0;
|
|
HEAP32[$5 + 8 >> 2] = (Math_imul($7 >> 16, $3) + $4 | 0) + (Math_imul($7 & 65535, $3) >> 16);
|
|
break label$2;
|
|
}
|
|
$4 = Math_imul($10, 12);
|
|
$6 = Math_imul($7, 12);
|
|
$8 = HEAP32[$6 + 5896 >> 2];
|
|
$9 = HEAP32[$4 + 5896 >> 2] - $8 | 0;
|
|
HEAP32[$5 + 24 >> 2] = (Math_imul($9 >> 16, $3) + $8 | 0) + (Math_imul($9 & 65535, $3) >> 16);
|
|
$8 = HEAP32[$6 + 5892 >> 2];
|
|
$9 = HEAP32[$4 + 5892 >> 2] - $8 | 0;
|
|
HEAP32[$5 + 20 >> 2] = (Math_imul($9 >> 16, $3) + $8 | 0) + (Math_imul($9 & 65535, $3) >> 16);
|
|
$8 = HEAP32[$4 + 5888 >> 2];
|
|
$4 = HEAP32[$6 + 5888 >> 2];
|
|
$6 = $8 - $4 | 0;
|
|
HEAP32[$5 + 16 >> 2] = (Math_imul($6 >> 16, $3) + $4 | 0) + (Math_imul($6 & 65535, $3) >> 16);
|
|
$4 = $10 << 3;
|
|
$7 = $7 << 3;
|
|
$10 = HEAP32[$7 + 5956 >> 2];
|
|
$6 = HEAP32[$4 + 5956 >> 2] - $10 | 0;
|
|
HEAP32[$5 + 12 >> 2] = (Math_imul($6 >> 16, $3) + $10 | 0) + (Math_imul($6 & 65535, $3) >> 16);
|
|
$7 = HEAP32[$7 + 5952 >> 2];
|
|
$4 = HEAP32[$4 + 5952 >> 2] - $7 | 0;
|
|
HEAP32[$5 + 8 >> 2] = (Math_imul($4 >> 16, $3) + $7 | 0) + (Math_imul($4 & 65535, $3) >> 16);
|
|
break label$2;
|
|
}
|
|
$3 = Math_imul($7, 12);
|
|
HEAP32[$5 + 24 >> 2] = HEAP32[$3 + 5896 >> 2];
|
|
$6 = $3 + 5888 | 0;
|
|
$4 = HEAP32[$6 >> 2];
|
|
$3 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$5 + 16 >> 2] = $4;
|
|
HEAP32[$5 + 20 >> 2] = $3;
|
|
$6 = ($7 << 3) + 5952 | 0;
|
|
$3 = HEAP32[$6 >> 2];
|
|
$4 = HEAP32[$6 + 4 >> 2];
|
|
HEAP32[$5 + 8 >> 2] = $3;
|
|
HEAP32[$5 + 12 >> 2] = $4;
|
|
break label$2;
|
|
}
|
|
HEAP32[$5 + 24 >> 2] = HEAP32[1486];
|
|
$3 = HEAP32[1485];
|
|
$4 = HEAP32[1484];
|
|
HEAP32[$5 + 16 >> 2] = $4;
|
|
HEAP32[$5 + 20 >> 2] = $3;
|
|
$4 = HEAP32[1497];
|
|
$3 = HEAP32[1496];
|
|
HEAP32[$5 + 8 >> 2] = $3;
|
|
HEAP32[$5 + 12 >> 2] = $4;
|
|
}
|
|
$3 = $11 + $12 | 0;
|
|
$3 = ($3 | 0) > 0 ? $3 : 0;
|
|
HEAP32[$0 + 8 >> 2] = ($3 | 0) < 256 ? $3 : 256;
|
|
silk_biquad_alt_stride1($1, $5 + 16 | 0, $5 + 8 | 0, $0, $1, $2);
|
|
}
|
|
__stack_pointer = $5 + 32 | 0;
|
|
}
|
|
function silk_resampler_init($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
$4 = memset($0, 0, 300);
|
|
$0 = $4;
|
|
label$3 : {
|
|
if ($3) {
|
|
label$5 : {
|
|
if (($1 | 0) <= 15999) {
|
|
if (($1 | 0) == 8e3 | ($1 | 0) == 12e3) {
|
|
break label$5;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) == 16e3 | ($1 | 0) == 48e3) {
|
|
break label$5;
|
|
}
|
|
if (($1 | 0) != 24e3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
if (($2 | 0) != 16e3 ? !(($2 | 0) == 8e3 | ($2 | 0) == 12e3) : 0) {
|
|
break label$1;
|
|
}
|
|
$3 = (Math_imul(($1 >>> 12 | 0) - (($1 | 0) > 16e3) >> (($1 | 0) > 24e3), 3) + ($2 >>> 12 | 0) | 0) + 6487 | 0;
|
|
break label$3;
|
|
}
|
|
if (($1 | 0) != 12e3 ? !(($1 | 0) == 8e3 | ($1 | 0) == 16e3) : 0) {
|
|
break label$2;
|
|
}
|
|
label$9 : {
|
|
if (($2 | 0) <= 15999) {
|
|
if (($2 | 0) == 8e3 | ($2 | 0) == 12e3) {
|
|
break label$9;
|
|
}
|
|
break label$2;
|
|
}
|
|
if (($2 | 0) == 16e3 | ($2 | 0) == 24e3) {
|
|
break label$9;
|
|
}
|
|
if (($2 | 0) != 48e3) {
|
|
break label$2;
|
|
}
|
|
}
|
|
$3 = (Math_imul($1 >>> 12 | 0, 5) + (($2 >>> 12 | 0) - (($2 | 0) > 16e3) >> (($2 | 0) > 24e3)) | 0) + 6500 | 0;
|
|
}
|
|
HEAP32[$0 + 292 >> 2] = HEAP8[$3 | 0];
|
|
HEAP32[$4 + 288 >> 2] = (($2 & 65535) >>> 0) / 1e3;
|
|
$3 = (($1 & 65535) >>> 0) / 1e3 | 0;
|
|
HEAP32[$4 + 284 >> 2] = $3;
|
|
HEAP32[$4 + 268 >> 2] = Math_imul($3, 10);
|
|
label$11 : {
|
|
if (($1 | 0) < ($2 | 0)) {
|
|
$5 = 1;
|
|
if ($1 << 1 == ($2 | 0)) {
|
|
HEAP32[$4 + 264 >> 2] = 1;
|
|
$5 = 0;
|
|
break label$11;
|
|
}
|
|
HEAP32[$4 + 264 >> 2] = 2;
|
|
break label$11;
|
|
}
|
|
if (($1 | 0) > ($2 | 0)) {
|
|
HEAP32[$4 + 264 >> 2] = 3;
|
|
$3 = $2 << 2;
|
|
if (($3 | 0) == (Math_imul($1, 3) | 0)) {
|
|
HEAP32[$4 + 296 >> 2] = 6e3;
|
|
HEAP32[$4 + 276 >> 2] = 18;
|
|
HEAP32[$4 + 280 >> 2] = 3;
|
|
break label$11;
|
|
}
|
|
$0 = Math_imul($2, 3);
|
|
if (($0 | 0) == $1 << 1) {
|
|
HEAP32[$4 + 296 >> 2] = 6064;
|
|
HEAP32[$4 + 276 >> 2] = 18;
|
|
HEAP32[$4 + 280 >> 2] = 2;
|
|
break label$11;
|
|
}
|
|
if ($2 << 1 == ($1 | 0)) {
|
|
HEAP32[$4 + 296 >> 2] = 6112;
|
|
HEAP32[$4 + 276 >> 2] = 24;
|
|
HEAP32[$4 + 280 >> 2] = 1;
|
|
break label$11;
|
|
}
|
|
if (($0 | 0) == ($1 | 0)) {
|
|
HEAP32[$4 + 296 >> 2] = 6144;
|
|
HEAP32[$4 + 276 >> 2] = 36;
|
|
HEAP32[$4 + 280 >> 2] = 1;
|
|
break label$11;
|
|
}
|
|
if (($1 | 0) == ($3 | 0)) {
|
|
HEAP32[$4 + 296 >> 2] = 6192;
|
|
HEAP32[$4 + 276 >> 2] = 36;
|
|
HEAP32[$4 + 280 >> 2] = 1;
|
|
break label$11;
|
|
}
|
|
if ((Math_imul($2, 6) | 0) == ($1 | 0)) {
|
|
HEAP32[$4 + 296 >> 2] = 6240;
|
|
HEAP32[$4 + 276 >> 2] = 36;
|
|
HEAP32[$4 + 280 >> 2] = 1;
|
|
break label$11;
|
|
}
|
|
celt_fatal(6454, 6474, 154);
|
|
abort();
|
|
}
|
|
HEAP32[$4 + 264 >> 2] = 0;
|
|
}
|
|
$0 = $1 << $5;
|
|
$3 = $2 << 16 >> 16;
|
|
$6 = ($2 >>> 15 | 0) + 1 >>> 1 | 0;
|
|
$1 = ($1 << ($5 | 14)) / ($2 | 0) << 2;
|
|
while (1) {
|
|
$2 = $1;
|
|
$1 = $2 + 1 | 0;
|
|
if (((Math_imul($2 >> 16, $3) + Math_imul($2, $6) | 0) + (Math_imul($2 & 65535, $3) >> 16) | 0) < ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$4 + 272 >> 2] = $2;
|
|
return 0;
|
|
}
|
|
celt_fatal(6454, 6474, 101);
|
|
abort();
|
|
}
|
|
celt_fatal(6454, 6474, 94);
|
|
abort();
|
|
}
|
|
function comb_filter($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) {
|
|
var $12 = Math_fround(0), $13 = Math_fround(0), $14 = Math_fround(0), $15 = Math_fround(0), $16 = 0, $17 = Math_fround(0), $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = Math_fround(0), $23 = Math_fround(0), $24 = Math_fround(0), $25 = Math_fround(0), $26 = Math_fround(0), $27 = Math_fround(0), $28 = Math_fround(0), $29 = Math_fround(0), $30 = Math_fround(0);
|
|
label$1 : {
|
|
if (!($5 != Math_fround(0) | $6 != Math_fround(0))) {
|
|
if (($0 | 0) == ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
memmove($0, $1, $4 << 2);
|
|
return;
|
|
}
|
|
$11 = ($3 | 0) > 15 ? $3 : 15;
|
|
$18 = -2 - $11 | 0;
|
|
$19 = $11 ^ -1;
|
|
$20 = 1 - $11 | 0;
|
|
$21 = 0 - $11 | 0;
|
|
$3 = Math_imul($8, 12);
|
|
$22 = Math_fround(HEAPF32[$3 + 1704 >> 2] * $6);
|
|
$23 = Math_fround(HEAPF32[$3 + 1700 >> 2] * $6);
|
|
$24 = Math_fround(HEAPF32[$3 + 1696 >> 2] * $6);
|
|
$3 = $5 == $6 ? ($7 | 0) == ($8 | 0) ? 0 : $10 : $10;
|
|
$8 = ($2 | 0) > 15 ? $2 : 15;
|
|
$3 = ($11 | 0) == ($8 | 0) ? $3 : $10;
|
|
if (($3 | 0) >= 1) {
|
|
$10 = Math_imul($7, 12);
|
|
$25 = Math_fround(HEAPF32[$10 + 1704 >> 2] * $5);
|
|
$26 = Math_fround(HEAPF32[$10 + 1700 >> 2] * $5);
|
|
$27 = Math_fround(HEAPF32[$10 + 1696 >> 2] * $5);
|
|
$7 = 2 - $11 | 0;
|
|
$12 = HEAPF32[($20 << 2) + $1 >> 2];
|
|
$13 = HEAPF32[($21 << 2) + $1 >> 2];
|
|
$14 = HEAPF32[($19 << 2) + $1 >> 2];
|
|
$5 = HEAPF32[($18 << 2) + $1 >> 2];
|
|
$10 = 0;
|
|
while (1) {
|
|
$2 = $10 << 2;
|
|
$16 = $2 + $0 | 0;
|
|
$15 = HEAPF32[($7 + $10 << 2) + $1 >> 2];
|
|
$17 = Math_fround($5 + $15);
|
|
$5 = HEAPF32[$2 + $9 >> 2];
|
|
$5 = Math_fround($5 * $5);
|
|
$17 = Math_fround($17 * Math_fround($22 * $5));
|
|
$28 = Math_fround(Math_fround($12 + $14) * Math_fround($23 * $5));
|
|
$29 = Math_fround($13 * Math_fround($24 * $5));
|
|
$30 = HEAPF32[$1 + $2 >> 2];
|
|
$2 = ($10 - $8 << 2) + $1 | 0;
|
|
$5 = Math_fround(Math_fround(1) - $5);
|
|
HEAPF32[$16 >> 2] = $17 + Math_fround($28 + Math_fround($29 + Math_fround(Math_fround(Math_fround($30 + Math_fround(HEAPF32[$2 >> 2] * Math_fround($27 * $5))) + Math_fround(Math_fround($26 * $5) * Math_fround(HEAPF32[$2 + 4 >> 2] + HEAPF32[$2 - 4 >> 2]))) + Math_fround(Math_fround($25 * $5) * Math_fround(HEAPF32[$2 + 8 >> 2] + HEAPF32[$2 - 8 >> 2])))));
|
|
$5 = $14;
|
|
$14 = $13;
|
|
$13 = $12;
|
|
$12 = $15;
|
|
$10 = $10 + 1 | 0;
|
|
if (($10 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$16 = $3;
|
|
}
|
|
if ($6 == Math_fround(0)) {
|
|
if (($0 | 0) == ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
$10 = $3 << 2;
|
|
memmove($10 + $0 | 0, $1 + $10 | 0, $4 - $3 << 2);
|
|
return;
|
|
}
|
|
$3 = $4 - $16 | 0;
|
|
if (($3 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$10 = $16 << 2;
|
|
$0 = $10 + $0 | 0;
|
|
$9 = 2 - $11 | 0;
|
|
$2 = $1 + $10 | 0;
|
|
$14 = HEAPF32[$2 + ($18 << 2) >> 2];
|
|
$5 = HEAPF32[($19 << 2) + $2 >> 2];
|
|
$12 = HEAPF32[($21 << 2) + $2 >> 2];
|
|
$13 = HEAPF32[($20 << 2) + $2 >> 2];
|
|
$10 = 0;
|
|
while (1) {
|
|
$1 = $10 << 2;
|
|
$15 = HEAPF32[($9 + $10 << 2) + $2 >> 2];
|
|
HEAPF32[$1 + $0 >> 2] = Math_fround($22 * Math_fround($14 + $15)) + Math_fround(Math_fround($23 * Math_fround($5 + $13)) + Math_fround(Math_fround($24 * $12) + HEAPF32[$1 + $2 >> 2]));
|
|
$14 = $5;
|
|
$5 = $12;
|
|
$12 = $13;
|
|
$13 = $15;
|
|
$10 = $10 + 1 | 0;
|
|
if (($10 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function compute_stereo_width($0, $1, $2, $3) {
|
|
var $4 = Math_fround(0), $5 = Math_fround(0), $6 = Math_fround(0), $7 = Math_fround(0), $8 = Math_fround(0), $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0, $12 = Math_fround(0), $13 = Math_fround(0), $14 = Math_fround(0), $15 = Math_fround(0), $16 = Math_fround(0), $17 = 0;
|
|
$11 = ($2 | 0) / ($1 | 0) | 0;
|
|
$12 = Math_fround(Math_fround(Math_fround(-25) / Math_fround((($11 | 0) > 50 ? $11 : 50) | 0)) + Math_fround(1));
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($1 | 0) >= 4) {
|
|
$17 = $1 - 3 | 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = $2 << 3;
|
|
$4 = HEAPF32[$1 + $0 >> 2];
|
|
$5 = HEAPF32[($1 | 4) + $0 >> 2];
|
|
$6 = HEAPF32[($1 | 8) + $0 >> 2];
|
|
$7 = HEAPF32[($1 | 12) + $0 >> 2];
|
|
$8 = HEAPF32[($1 | 16) + $0 >> 2];
|
|
$13 = HEAPF32[($1 | 20) + $0 >> 2];
|
|
$14 = HEAPF32[($1 | 24) + $0 >> 2];
|
|
$15 = HEAPF32[($1 | 28) + $0 >> 2];
|
|
$16 = Math_fround($16 + Math_fround(Math_fround(Math_fround(Math_fround($4 * $5) + Math_fround($6 * $7)) + Math_fround($8 * $13)) + Math_fround($14 * $15)));
|
|
$9 = Math_fround($9 + Math_fround(Math_fround(Math_fround(Math_fround($5 * $5) + Math_fround($7 * $7)) + Math_fround($13 * $13)) + Math_fround($15 * $15)));
|
|
$10 = Math_fround($10 + Math_fround(Math_fround(Math_fround(Math_fround($4 * $4) + Math_fround($6 * $6)) + Math_fround($8 * $8)) + Math_fround($14 * $14)));
|
|
$2 = $2 + 4 | 0;
|
|
if (($17 | 0) > ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($10 < Math_fround(1e9) ^ 1) {
|
|
break label$2;
|
|
}
|
|
}
|
|
if ($9 < Math_fround(1e9) ^ 1) {
|
|
break label$2;
|
|
}
|
|
if ($9 == $9 & $10 == $10) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$9 = Math_fround(0);
|
|
$16 = Math_fround(0);
|
|
$10 = Math_fround(0);
|
|
}
|
|
$4 = HEAPF32[$3 + 8 >> 2];
|
|
$4 = Math_fround(Math_max(Math_fround($4 + Math_fround($12 * Math_fround($9 - $4))), Math_fround(0)));
|
|
HEAPF32[$3 + 8 >> 2] = $4;
|
|
$5 = HEAPF32[$3 + 4 >> 2];
|
|
$6 = Math_fround(Math_max(Math_fround($5 + Math_fround($12 * Math_fround($16 - $5))), Math_fround(0)));
|
|
HEAPF32[$3 + 4 >> 2] = $6;
|
|
$5 = HEAPF32[$3 >> 2];
|
|
$5 = Math_fround(Math_max(Math_fround($5 + Math_fround($12 * Math_fround($10 - $5))), Math_fround(0)));
|
|
HEAPF32[$3 >> 2] = $5;
|
|
label$6 : {
|
|
if (!(($4 < $5 ? $5 : $4) > Math_fround(.0007999999797903001))) {
|
|
$4 = HEAPF32[$3 + 16 >> 2];
|
|
break label$6;
|
|
}
|
|
$5 = Math_fround(Math_sqrt($5));
|
|
$7 = Math_fround(Math_sqrt($4));
|
|
$4 = Math_fround($5 * $7);
|
|
$6 = $4 > $6 ? $6 : $4;
|
|
HEAPF32[$3 + 4 >> 2] = $6;
|
|
$5 = Math_fround(Math_sqrt($5));
|
|
$7 = Math_fround(Math_sqrt($7));
|
|
$4 = Math_fround($6 / Math_fround($4 + Math_fround(1.0000000036274937e-15)));
|
|
$8 = HEAPF32[$3 + 12 >> 2];
|
|
$4 = Math_fround(Math_fround(Math_fround(Math_fround(Math_abs(Math_fround($5 - $7))) / Math_fround(Math_fround($5 + Math_fround(1.0000000036274937e-15)) + $7)) * Math_fround(Math_sqrt(Math_fround(Math_fround(1) - Math_fround($4 * $4))))) - $8);
|
|
$5 = Math_fround($11 | 0);
|
|
$4 = Math_fround($8 + Math_fround($4 / $5));
|
|
HEAPF32[$3 + 12 >> 2] = $4;
|
|
$5 = Math_fround(HEAPF32[$3 + 16 >> 2] + Math_fround(Math_fround(-.019999999552965164) / $5));
|
|
$4 = $4 < $5 ? $5 : $4;
|
|
HEAPF32[$3 + 16 >> 2] = $4;
|
|
}
|
|
return Math_fround(Math_min(Math_fround($4 * Math_fround(20)), Math_fround(1)));
|
|
}
|
|
function silk_process_gains_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = Math_fround(0), $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = 0;
|
|
$7 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $7;
|
|
label$1 : {
|
|
if (HEAPU8[$0 + 4765 | 0] != 2) {
|
|
$5 = HEAP32[$0 + 4580 >> 2];
|
|
break label$1;
|
|
}
|
|
$8 = exp(+Math_fround(Math_fround(HEAPF32[$1 + 708 >> 2] + Math_fround(-12)) * Math_fround(-.25)));
|
|
$5 = HEAP32[$0 + 4580 >> 2];
|
|
if (($5 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$6 = Math_fround(Math_fround(Math_fround(1 / ($8 + 1)) * Math_fround(-.5)) + Math_fround(1));
|
|
while (1) {
|
|
$4 = ($3 << 2) + $1 | 0;
|
|
HEAPF32[$4 >> 2] = $6 * HEAPF32[$4 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = 0;
|
|
$4 = HEAP32[$0 + 4588 >> 2];
|
|
$8 = exp2(+Math_fround(Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4716 >> 2]) * Math_fround(-.0078125)) + Math_fround(21)) * Math_fround(.33000001311302185)));
|
|
label$4 : {
|
|
if (($5 | 0) <= 0) {
|
|
break label$4;
|
|
}
|
|
$9 = Math_fround($8 / +($4 | 0));
|
|
while (1) {
|
|
$4 = ($3 << 2) + $1 | 0;
|
|
$6 = HEAPF32[$4 >> 2];
|
|
$6 = Math_fround(Math_sqrt(Math_fround(Math_fround($6 * $6) + Math_fround(HEAPF32[$4 + 712 >> 2] * $9))));
|
|
HEAPF32[$4 >> 2] = $6 < Math_fround(32767) ? $6 : Math_fround(32767);
|
|
$3 = $3 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = 0;
|
|
if (($5 | 0) <= 0) {
|
|
break label$4;
|
|
}
|
|
while (1) {
|
|
$4 = $3 << 2;
|
|
$10 = $7 + $4 | 0;
|
|
$6 = Math_fround(HEAPF32[$1 + $4 >> 2] * Math_fround(65536));
|
|
label$7 : {
|
|
if (Math_fround(Math_abs($6)) < Math_fround(2147483648)) {
|
|
$4 = ~~$6;
|
|
break label$7;
|
|
}
|
|
$4 = -2147483648;
|
|
}
|
|
HEAP32[$10 >> 2] = $4;
|
|
$3 = $3 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memcpy($1 + 728 | 0, $7, $5 << 2);
|
|
HEAP8[$1 + 744 | 0] = HEAPU8[$0 + 7168 | 0];
|
|
silk_gains_quant($0 + 4736 | 0, $7, $0 + 7168 | 0, ($2 | 0) == 2, HEAP32[$0 + 4580 >> 2]);
|
|
$5 = HEAP32[$0 + 4580 >> 2];
|
|
if (($5 | 0) >= 1) {
|
|
$3 = 0;
|
|
while (1) {
|
|
$4 = $3 << 2;
|
|
HEAPF32[$4 + $1 >> 2] = Math_fround(HEAP32[$4 + $7 >> 2]) * Math_fround(152587890625e-16);
|
|
$3 = $3 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = HEAPU8[$0 + 4765 | 0];
|
|
label$11 : {
|
|
if (($4 | 0) != 2) {
|
|
$3 = HEAP8[$0 + 4766 | 0];
|
|
break label$11;
|
|
}
|
|
$3 = Math_fround(HEAPF32[$1 + 708 >> 2] + Math_fround(Math_fround(HEAP32[$0 + 4712 >> 2]) * Math_fround(30517578125e-15))) > Math_fround(1) ^ 1;
|
|
HEAP8[$0 + 4766 | 0] = $3;
|
|
}
|
|
HEAPF32[$1 + 692 >> 2] = Math_fround(Math_fround(Math_fround(HEAP16[(($4 << 24 >> 24 << 1 & -4) + ($3 << 1) | 0) + 5840 >> 1]) * Math_fround(.0009765625)) * Math_fround(.800000011920929)) + Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4628 >> 2]) * Math_fround(-.05000000074505806)) + Math_fround(1.2000000476837158)) + Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4532 >> 2]) * Math_fround(.20000000298023224)) * Math_fround(-.00390625))) + Math_fround(HEAPF32[$1 + 696 >> 2] * Math_fround(-.10000000149011612))) - Math_fround(HEAPF32[$1 + 700 >> 2] * Math_fround(.20000000298023224)));
|
|
__stack_pointer = $7 + 16 | 0;
|
|
}
|
|
function silk_find_pred_coefs_FLP($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = Math_fround(0);
|
|
$5 = __stack_pointer - 2064 | 0;
|
|
__stack_pointer = $5;
|
|
label$1 : {
|
|
label$2 : {
|
|
$7 = HEAP32[$0 + 4580 >> 2];
|
|
label$3 : {
|
|
if (($7 | 0) >= 1) {
|
|
while (1) {
|
|
$8 = $6 << 2;
|
|
HEAPF32[$8 + ($5 + 1568 | 0) >> 2] = Math_fround(1) / HEAPF32[$1 + $8 >> 2];
|
|
$6 = $6 + 1 | 0;
|
|
if (($7 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (HEAPU8[$0 + 4765 | 0] == 2) {
|
|
break label$3;
|
|
}
|
|
if (($7 | 0) < 1) {
|
|
break label$2;
|
|
}
|
|
$4 = HEAP32[$0 + 4640 >> 2];
|
|
$6 = $3 - ($4 << 2) | 0;
|
|
$8 = HEAP32[$0 + 4588 >> 2];
|
|
$3 = 0;
|
|
$2 = $5;
|
|
while (1) {
|
|
silk_scale_copy_vector_FLP($2, $6, HEAPF32[($5 + 1568 | 0) + ($3 << 2) >> 2], $4 + $8 | 0);
|
|
$8 = HEAP32[$0 + 4588 >> 2];
|
|
$6 = ($8 << 2) + $6 | 0;
|
|
$4 = HEAP32[$0 + 4640 >> 2];
|
|
$2 = ($8 + $4 << 2) + $2 | 0;
|
|
$3 = $3 + 1 | 0;
|
|
$7 = HEAP32[$0 + 4580 >> 2];
|
|
if (($3 | 0) < ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$2;
|
|
}
|
|
if (HEAPU8[$0 + 4765 | 0] != 2) {
|
|
break label$2;
|
|
}
|
|
}
|
|
if ((HEAP32[$1 + 228 >> 2] + 2 | 0) <= (HEAP32[$0 + 4592 >> 2] - HEAP32[$0 + 4640 >> 2] | 0)) {
|
|
$6 = $1 + 228 | 0;
|
|
silk_find_LTP_FLP($5 + 1664 | 0, $5 + 1584 | 0, $2, $6, HEAP32[$0 + 4588 >> 2], $7);
|
|
$8 = $1 + 144 | 0;
|
|
silk_quant_LTP_gains_FLP($8, $0 + 4740 | 0, $0 + 4768 | 0, $0 + 4656 | 0, $1 + 708 | 0, $5 + 1664 | 0, $5 + 1584 | 0, HEAP32[$0 + 4588 >> 2], HEAP32[$0 + 4580 >> 2], HEAP32[$0 + 5092 >> 2]);
|
|
silk_LTP_scale_ctrl_FLP($0, $1, $4);
|
|
$7 = HEAP32[$0 + 4640 >> 2];
|
|
silk_LTP_analysis_filter_FLP($5, $3 - ($7 << 2) | 0, $8, $6, $5 + 1568 | 0, HEAP32[$0 + 4588 >> 2], HEAP32[$0 + 4580 >> 2], $7);
|
|
break label$1;
|
|
}
|
|
celt_fatal(16745, 16862, 62);
|
|
abort();
|
|
}
|
|
memset($1 + 144 | 0, 0, Math_imul($7, 20));
|
|
HEAP32[$1 + 708 >> 2] = 0;
|
|
HEAP32[$0 + 4656 >> 2] = 0;
|
|
}
|
|
$9 = Math_fround(.009999999776482582);
|
|
$2 = $0;
|
|
$4 = $5 + 1536 | 0;
|
|
$3 = $5;
|
|
if (!HEAP32[$0 + 4664 >> 2]) {
|
|
$9 = HEAPF32[$1 + 700 >> 2];
|
|
$9 = Math_fround(Math_fround(Math_fround(exp2(+Math_fround(HEAPF32[$1 + 708 >> 2] / Math_fround(3)))) / Math_fround(1e4)) / Math_fround(Math_fround($9 * Math_fround(.75)) + Math_fround(.25)));
|
|
}
|
|
silk_find_LPC_FLP($2, $4, $3, $9);
|
|
$6 = $1 + 16 | 0;
|
|
silk_process_NLSFs_FLP($0, $6, $5 + 1536 | 0, $0 + 4500 | 0);
|
|
silk_residual_energy_FLP($1 + 712 | 0, $5, $6, $1, HEAP32[$0 + 4588 >> 2], HEAP32[$0 + 4580 >> 2], HEAP32[$0 + 4640 >> 2]);
|
|
$3 = $5 + 1560 | 0;
|
|
$2 = HEAP32[$3 >> 2];
|
|
$1 = HEAP32[$3 + 4 >> 2];
|
|
$3 = $2;
|
|
$2 = $0 + 4524 | 0;
|
|
HEAP32[$2 >> 2] = $3;
|
|
HEAP32[$2 + 4 >> 2] = $1;
|
|
$3 = $5 + 1552 | 0;
|
|
$1 = HEAP32[$3 >> 2];
|
|
$2 = HEAP32[$3 + 4 >> 2];
|
|
$3 = $1;
|
|
$1 = $0 + 4516 | 0;
|
|
HEAP32[$1 >> 2] = $3;
|
|
HEAP32[$1 + 4 >> 2] = $2;
|
|
$1 = HEAP32[$5 + 1548 >> 2];
|
|
$2 = HEAP32[$5 + 1544 >> 2];
|
|
$3 = $2;
|
|
$2 = $0 + 4508 | 0;
|
|
HEAP32[$2 >> 2] = $3;
|
|
HEAP32[$2 + 4 >> 2] = $1;
|
|
$2 = HEAP32[$5 + 1540 >> 2];
|
|
$1 = HEAP32[$5 + 1536 >> 2];
|
|
HEAP32[$0 + 4500 >> 2] = $1;
|
|
HEAP32[$0 + 4504 >> 2] = $2;
|
|
__stack_pointer = $5 + 2064 | 0;
|
|
}
|
|
function spreading_decision($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
var $11 = 0, $12 = 0, $13 = 0, $14 = Math_fround(0), $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $29 = 0, $30 = Math_fround(0);
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($7 | 0) > 0) {
|
|
$18 = HEAP32[$0 + 32 >> 2];
|
|
$12 = $18 + ($7 << 1) | 0;
|
|
label$4 : {
|
|
if ((Math_imul(HEAP16[$12 >> 1] - HEAP16[$12 - 2 >> 1] | 0, $9) | 0) < 9) {
|
|
break label$4;
|
|
}
|
|
$25 = Math_imul(HEAP32[$0 + 44 >> 2], $9);
|
|
$26 = ($8 | 0) > 1 ? $8 : 1;
|
|
$27 = HEAPU16[$18 >> 1];
|
|
while (1) {
|
|
$28 = (Math_imul($19, $25) << 2) + $1 | 0;
|
|
$20 = $27;
|
|
$15 = 0;
|
|
while (1) {
|
|
$11 = $20 << 16;
|
|
$24 = $15 + 1 | 0;
|
|
$20 = HEAP16[($24 << 1) + $18 >> 1];
|
|
$11 = $11 >> 16;
|
|
$13 = Math_imul($20 - $11 | 0, $9);
|
|
if (($13 | 0) >= 9) {
|
|
$29 = (Math_imul($9, $11) << 2) + $28 | 0;
|
|
$30 = Math_fround($13 | 0);
|
|
$21 = 0;
|
|
$12 = 0;
|
|
$16 = 0;
|
|
$11 = 0;
|
|
while (1) {
|
|
$14 = HEAPF32[($11 << 2) + $29 >> 2];
|
|
$14 = Math_fround(Math_fround($14 * $14) * $30);
|
|
$21 = ($14 < Math_fround(.015625)) + $21 | 0;
|
|
$12 = ($14 < Math_fround(.0625)) + $12 | 0;
|
|
$16 = ($14 < Math_fround(.25)) + $16 | 0;
|
|
$11 = $11 + 1 | 0;
|
|
if (($13 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$11 = HEAP32[($15 << 2) + $10 >> 2];
|
|
$22 = Math_imul($11, (($12 << 1 >= ($13 | 0)) + ($16 << 1 >= ($13 | 0)) | 0) + ($21 << 1 >= ($13 | 0)) | 0) + $22 | 0;
|
|
$23 = $11 + $23 | 0;
|
|
$17 = (HEAP32[$0 + 8 >> 2] - 4 | 0) < ($15 | 0) ? (($12 + $16 << 5 >>> 0) / ($13 >>> 0) | 0) + $17 | 0 : $17;
|
|
}
|
|
$15 = $24;
|
|
if (($15 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$19 = $19 + 1 | 0;
|
|
if (($26 | 0) != ($19 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($6) {
|
|
$11 = $17 ? ($17 >>> 0) / (Math_imul(($7 - HEAP32[$0 + 8 >> 2] | 0) + 4 | 0, $8) >>> 0) | 0 : 0;
|
|
$11 = $11 + HEAP32[$4 >> 2] >> 1;
|
|
HEAP32[$4 >> 2] = $11;
|
|
label$13 : {
|
|
label$14 : {
|
|
switch (HEAP32[$5 >> 2]) {
|
|
case 2:
|
|
$11 = $11 + 4 | 0;
|
|
break label$13;
|
|
case 0:
|
|
break label$14;
|
|
default:
|
|
break label$13;
|
|
}
|
|
}
|
|
$11 = $11 - 4 | 0;
|
|
}
|
|
HEAP32[$5 >> 2] = ($11 | 0) > 22 ? 2 : ($11 | 0) > 18;
|
|
}
|
|
if (($23 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
if (($22 | 0) <= -1) {
|
|
break label$1;
|
|
}
|
|
$12 = HEAP32[$2 >> 2] + (($22 << 8 >>> 0) / ($23 >>> 0) | 0) >> 1;
|
|
HEAP32[$2 >> 2] = $12;
|
|
$11 = 3;
|
|
$12 = (Math_imul($12, 3) - ($3 << 7) | 0) + 448 | 0;
|
|
if (($12 | 0) < 318) {
|
|
break label$4;
|
|
}
|
|
$11 = 2;
|
|
if (($12 | 0) < 1022) {
|
|
break label$4;
|
|
}
|
|
$11 = ($12 | 0) < 1534;
|
|
}
|
|
return $11;
|
|
}
|
|
celt_fatal(41813, 41800, 489);
|
|
abort();
|
|
}
|
|
celt_fatal(41837, 41800, 545);
|
|
abort();
|
|
}
|
|
celt_fatal(41865, 41800, 546);
|
|
abort();
|
|
}
|
|
function decode_pulses($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = Math_fround(0), $7 = 0, $8 = Math_fround(0), $9 = 0, $10 = 0, $11 = 0;
|
|
$4 = $2 + 1 | 0;
|
|
$5 = ($1 | 0) > ($2 | 0);
|
|
$5 = ec_dec_uint($3, HEAP32[HEAP32[(($5 ? $4 : $1) << 2) + 36320 >> 2] + ((($1 | 0) > ($4 | 0) ? $1 : $4) << 2) >> 2] + HEAP32[HEAP32[((($1 | 0) < ($2 | 0) ? $1 : $2) << 2) + 36320 >> 2] + (($5 ? $1 : $2) << 2) >> 2] | 0);
|
|
label$1 : {
|
|
if (($2 | 0) > 0) {
|
|
if (($1 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) != 2) {
|
|
while (1) {
|
|
$9 = $1;
|
|
label$5 : {
|
|
if (($1 | 0) <= ($2 | 0)) {
|
|
$3 = $2;
|
|
$7 = $9 << 2;
|
|
$10 = HEAP32[$7 + 36320 >> 2];
|
|
$4 = HEAP32[($10 + ($2 << 2) | 0) + 4 >> 2];
|
|
$11 = $5 >>> 0 >= $4 >>> 0 ? -1 : 0;
|
|
$4 = $5 - ($4 & $11) | 0;
|
|
label$7 : {
|
|
if ($4 >>> 0 < HEAPU32[$7 + $10 >> 2]) {
|
|
while (1) {
|
|
$1 = $1 - 1 | 0;
|
|
$5 = HEAP32[HEAP32[($1 << 2) + 36320 >> 2] + $7 >> 2];
|
|
if ($5 >>> 0 > $4 >>> 0) {
|
|
continue;
|
|
}
|
|
break label$7;
|
|
}
|
|
}
|
|
while (1) {
|
|
$1 = $3;
|
|
$3 = $1 - 1 | 0;
|
|
$5 = HEAP32[($1 << 2) + $10 >> 2];
|
|
if ($5 >>> 0 > $4 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = (($2 + $11 | 0) - $1 ^ $11) << 16 >> 16;
|
|
HEAP32[$0 >> 2] = $3;
|
|
$6 = Math_fround($3 | 0);
|
|
$8 = Math_fround($8 + Math_fround($6 * $6));
|
|
$2 = $1;
|
|
$5 = $4 - $5 | 0;
|
|
break label$5;
|
|
}
|
|
$4 = $9 << 2;
|
|
$3 = $2 << 2;
|
|
$1 = HEAP32[$4 + HEAP32[$3 + 36324 >> 2] >> 2];
|
|
$3 = HEAP32[HEAP32[$3 + 36320 >> 2] + $4 >> 2];
|
|
if (!($5 >>> 0 < $3 >>> 0 | $1 >>> 0 <= $5 >>> 0)) {
|
|
HEAP32[$0 >> 2] = 0;
|
|
$5 = $5 - $3 | 0;
|
|
break label$5;
|
|
}
|
|
$7 = $1 >>> 0 <= $5 >>> 0 ? -1 : 0;
|
|
$3 = $5 - ($7 & $1) | 0;
|
|
$1 = $2;
|
|
while (1) {
|
|
$1 = $1 - 1 | 0;
|
|
$5 = HEAP32[HEAP32[($1 << 2) + 36320 >> 2] + $4 >> 2];
|
|
if ($5 >>> 0 > $3 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = (($2 + $7 | 0) - $1 ^ $7) << 16 >> 16;
|
|
HEAP32[$0 >> 2] = $4;
|
|
$6 = Math_fround($4 | 0);
|
|
$8 = Math_fround($8 + Math_fround($6 * $6));
|
|
$2 = $1;
|
|
$5 = $3 - $5 | 0;
|
|
}
|
|
$1 = $9 - 1 | 0;
|
|
$0 = $0 + 4 | 0;
|
|
if (($9 | 0) > 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = $2 << 1 | 1;
|
|
$4 = $5 >>> 0 >= $1 >>> 0;
|
|
$2 = $2 - $4 | 0;
|
|
$4 = $4 ? -1 : 0;
|
|
$3 = $5 - ($4 & $1) | 0;
|
|
$5 = $3 + 1 | 0;
|
|
$1 = $5 >>> 1 | 0;
|
|
$4 = ($2 - $1 ^ $4) << 16 >> 16;
|
|
HEAP32[$0 >> 2] = $4;
|
|
$3 = $3 - ($1 ? ($5 & -2) - 1 | 0 : 0) | 0;
|
|
$1 = ($1 - $3 ^ 0 - $3) << 16 >> 16;
|
|
HEAP32[$0 + 4 >> 2] = $1;
|
|
$6 = Math_fround($4 | 0);
|
|
$6 = Math_fround($8 + Math_fround($6 * $6));
|
|
$8 = Math_fround($1 | 0);
|
|
return Math_fround($6 + Math_fround($8 * $8));
|
|
}
|
|
celt_fatal(36272, 36295, 469);
|
|
abort();
|
|
}
|
|
celt_fatal(41504, 36295, 470);
|
|
abort();
|
|
}
|
|
function resampler_basic_interpolate_single($0, $1, $2, $3, $4, $5) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$5 = $5 | 0;
|
|
var $6 = Math_fround(0), $7 = Math_fround(0), $8 = Math_fround(0), $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = Math_fround(0), $15 = Math_fround(0), $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = Math_fround(0), $22 = Math_fround(0), $23 = 0, $24 = 0, $25 = 0, $26 = Math_fround(0), $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = Math_fround(0);
|
|
$1 = $1 << 2;
|
|
$16 = $1 + HEAP32[$0 + 64 >> 2] | 0;
|
|
$12 = HEAP32[$16 >> 2];
|
|
$17 = HEAP32[$0 + 60 >> 2] + $1 | 0;
|
|
$9 = HEAP32[$17 >> 2];
|
|
$18 = HEAP32[$3 >> 2];
|
|
label$1 : {
|
|
if (($9 | 0) >= ($18 | 0)) {
|
|
break label$1;
|
|
}
|
|
$23 = HEAP32[$0 + 40 >> 2];
|
|
$24 = HEAP32[$0 + 36 >> 2];
|
|
$25 = HEAP32[$0 + 92 >> 2];
|
|
$3 = HEAP32[$5 >> 2];
|
|
$19 = ($3 | 0) > 0 ? $3 : 0;
|
|
$10 = HEAP32[$0 + 12 >> 2];
|
|
$26 = Math_fround($10 >>> 0);
|
|
$20 = HEAP32[$0 + 24 >> 2];
|
|
$27 = ($20 | 0) < 1;
|
|
while (1) {
|
|
if (($11 | 0) == ($19 | 0)) {
|
|
$11 = $19;
|
|
break label$1;
|
|
}
|
|
$5 = HEAP32[$0 + 48 >> 2];
|
|
$3 = Math_imul($12, $5);
|
|
$1 = $3;
|
|
$3 = ($3 >>> 0) / ($10 >>> 0) | 0;
|
|
$7 = Math_fround(Math_fround($1 - Math_imul($10, $3) >>> 0) / $26);
|
|
label$4 : {
|
|
if ($27) {
|
|
$8 = Math_fround(0);
|
|
$13 = Math_fround(0);
|
|
$14 = Math_fround(0);
|
|
$15 = Math_fround(0);
|
|
break label$4;
|
|
}
|
|
$28 = ($9 << 2) + $2 | 0;
|
|
$29 = 4 - $3 | 0;
|
|
$30 = HEAP32[$0 + 76 >> 2];
|
|
$3 = 0;
|
|
$15 = Math_fround(0);
|
|
$14 = Math_fround(0);
|
|
$13 = Math_fround(0);
|
|
$8 = Math_fround(0);
|
|
while (1) {
|
|
$6 = HEAPF32[($3 << 2) + $28 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
$1 = (Math_imul($5, $3) + $29 << 2) + $30 | 0;
|
|
$14 = Math_fround($14 + Math_fround($6 * HEAPF32[$1 >> 2]));
|
|
$15 = Math_fround($15 + Math_fround($6 * HEAPF32[$1 + 4 >> 2]));
|
|
$13 = Math_fround($13 + Math_fround($6 * HEAPF32[$1 - 4 >> 2]));
|
|
$8 = Math_fround($8 + Math_fround($6 * HEAPF32[$1 - 8 >> 2]));
|
|
if (($3 | 0) != ($20 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = Math_fround($7 * Math_fround(.16666999459266663));
|
|
$21 = Math_fround($7 * Math_fround($7 * $6));
|
|
$22 = Math_fround($21 - $6);
|
|
$31 = Math_fround($22 * $8);
|
|
$6 = Math_fround($7 * Math_fround($7 * Math_fround(.5)));
|
|
$8 = Math_fround(Math_fround($7 + $6) - Math_fround($7 * $6));
|
|
$6 = Math_fround(Math_fround($6 + Math_fround($7 * Math_fround(-.3333300054073334))) - $21);
|
|
HEAPF32[(Math_imul($11, $25) << 2) + $4 >> 2] = Math_fround(Math_fround($31 + Math_fround($8 * $13)) + Math_fround($14 * Math_fround(1 - +$22 - +$8 - +$6))) + Math_fround($6 * $15);
|
|
$3 = $12 + $23 | 0;
|
|
$12 = $3 - ($3 >>> 0 < $10 >>> 0 ? 0 : $10) | 0;
|
|
$11 = $11 + 1 | 0;
|
|
$9 = ($9 + $24 | 0) + ($3 >>> 0 >= $10 >>> 0) | 0;
|
|
if (($18 | 0) > ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$17 >> 2] = $9;
|
|
HEAP32[$16 >> 2] = $12;
|
|
return $11 | 0;
|
|
}
|
|
function opus_encoder_init($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
$4 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $4;
|
|
$6 = -1;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($1 | 0) <= 15999) {
|
|
if (($1 | 0) == 8e3 | ($1 | 0) == 12e3) {
|
|
break label$2;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) == 16e3 | ($1 | 0) == 48e3) {
|
|
break label$2;
|
|
}
|
|
if (($1 | 0) != 24e3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
if ($2 - 1 >>> 0 > 1) {
|
|
break label$1;
|
|
}
|
|
$5 = $3 - 2048 | 0;
|
|
if ($5 >>> 0 > 3 | ($5 | 0) == 2) {
|
|
break label$1;
|
|
}
|
|
$5 = 0;
|
|
if (!silk_Get_Encoder_Size($4 + 28 | 0)) {
|
|
HEAP32[$4 + 28 >> 2] = HEAP32[$4 + 28 >> 2] + 3 & -4;
|
|
$5 = (celt_encoder_get_size($2) + HEAP32[$4 + 28 >> 2] | 0) + 18140 | 0;
|
|
}
|
|
$0 = memset($0, 0, $5);
|
|
if (silk_Get_Encoder_Size($4 + 28 | 0)) {
|
|
break label$1;
|
|
}
|
|
$6 = HEAP32[$4 + 28 >> 2] + 3 & -4;
|
|
HEAP32[$4 + 28 >> 2] = $6;
|
|
HEAP32[$0 + 14192 >> 2] = $2;
|
|
HEAP32[$0 + 112 >> 2] = $2;
|
|
HEAP32[$0 + 4 >> 2] = 18140;
|
|
HEAP32[$0 + 180 >> 2] = 0;
|
|
HEAP32[$0 + 144 >> 2] = $1;
|
|
$5 = $6 + 18140 | 0;
|
|
HEAP32[$0 >> 2] = $5;
|
|
$6 = -3;
|
|
if (silk_InitEncoder($0 + 18140 | 0, 0, $0 + 8 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $2;
|
|
HEAP32[$0 + 12 >> 2] = $2;
|
|
HEAP32[$0 + 76 >> 2] = 0;
|
|
HEAP32[$0 + 56 >> 2] = 0;
|
|
HEAP32[$0 + 60 >> 2] = 0;
|
|
HEAP32[$0 + 44 >> 2] = 9;
|
|
HEAP32[$0 + 48 >> 2] = 0;
|
|
HEAP32[$0 + 36 >> 2] = 25e3;
|
|
HEAP32[$0 + 40 >> 2] = 0;
|
|
HEAP32[$0 + 28 >> 2] = 16e3;
|
|
HEAP32[$0 + 32 >> 2] = 20;
|
|
HEAP32[$0 + 20 >> 2] = 16e3;
|
|
HEAP32[$0 + 24 >> 2] = 8e3;
|
|
HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 144 >> 2];
|
|
$5 = $0 + $5 | 0;
|
|
if (celt_encoder_init($5, $1, $2, HEAP32[$0 + 180 >> 2])) {
|
|
break label$1;
|
|
}
|
|
$6 = 0;
|
|
HEAP32[$4 + 16 >> 2] = 0;
|
|
opus_custom_encoder_ctl($5, 10016, $4 + 16 | 0);
|
|
HEAP32[$4 >> 2] = HEAP32[$0 + 44 >> 2];
|
|
opus_custom_encoder_ctl($5, 4010, $4);
|
|
HEAP32[$0 + 148 >> 2] = 1;
|
|
HEAP32[$0 + 152 >> 2] = 1;
|
|
HEAP32[$0 + 160 >> 2] = Math_imul($1, $2) + 3e3;
|
|
HEAP32[$0 + 128 >> 2] = -1e3;
|
|
HEAP32[$0 + 132 >> 2] = 1105;
|
|
HEAP32[$0 + 108 >> 2] = $3;
|
|
HEAP32[$0 + 136 >> 2] = -1e3;
|
|
HEAP32[$0 + 140 >> 2] = -1;
|
|
HEAP32[$0 + 120 >> 2] = -1e3;
|
|
HEAP32[$0 + 124 >> 2] = -1e3;
|
|
HEAP32[$0 + 164 >> 2] = -1e3;
|
|
HEAP32[$0 + 168 >> 2] = 24;
|
|
HEAP32[$0 + 156 >> 2] = 5e3;
|
|
HEAP32[$0 + 14204 >> 2] = 1065353216;
|
|
HEAP16[$0 + 14196 >> 1] = 16384;
|
|
$1 = HEAP32[$0 + 144 >> 2];
|
|
HEAP32[$0 + 172 >> 2] = ($1 | 0) / 100;
|
|
HEAP32[$0 + 116 >> 2] = ($1 | 0) / 250;
|
|
$1 = silk_lin2log(60);
|
|
HEAP32[$0 + 14252 >> 2] = 1;
|
|
HEAP32[$0 + 14240 >> 2] = 1105;
|
|
HEAP32[$0 + 14224 >> 2] = 1001;
|
|
HEAP32[$0 + 14200 >> 2] = $1 << 8;
|
|
tonality_analysis_init($0 + 188 | 0, HEAP32[$0 + 144 >> 2]);
|
|
HEAP32[$0 + 192 >> 2] = HEAP32[$0 + 108 >> 2];
|
|
}
|
|
__stack_pointer = $4 + 32 | 0;
|
|
return $6;
|
|
}
|
|
function resampler_basic_interpolate_double($0, $1, $2, $3, $4, $5) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$5 = $5 | 0;
|
|
var $6 = Math_fround(0), $7 = 0, $8 = Math_fround(0), $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = Math_fround(0), $23 = 0, $24 = 0, $25 = 0, $26 = Math_fround(0), $27 = 0, $28 = 0, $29 = 0, $30 = 0, $31 = 0;
|
|
$1 = $1 << 2;
|
|
$17 = $1 + HEAP32[$0 + 64 >> 2] | 0;
|
|
$13 = HEAP32[$17 >> 2];
|
|
$18 = HEAP32[$0 + 60 >> 2] + $1 | 0;
|
|
$9 = HEAP32[$18 >> 2];
|
|
$19 = HEAP32[$3 >> 2];
|
|
label$1 : {
|
|
if (($9 | 0) >= ($19 | 0)) {
|
|
break label$1;
|
|
}
|
|
$23 = HEAP32[$0 + 40 >> 2];
|
|
$24 = HEAP32[$0 + 36 >> 2];
|
|
$25 = HEAP32[$0 + 92 >> 2];
|
|
$3 = HEAP32[$5 >> 2];
|
|
$20 = ($3 | 0) > 0 ? $3 : 0;
|
|
$10 = HEAP32[$0 + 12 >> 2];
|
|
$26 = Math_fround($10 >>> 0);
|
|
$21 = HEAP32[$0 + 24 >> 2];
|
|
$27 = ($21 | 0) < 1;
|
|
while (1) {
|
|
if (($12 | 0) == ($20 | 0)) {
|
|
$12 = $20;
|
|
break label$1;
|
|
}
|
|
$5 = HEAP32[$0 + 48 >> 2];
|
|
$3 = Math_imul($13, $5);
|
|
$1 = $3;
|
|
$3 = ($3 >>> 0) / ($10 >>> 0) | 0;
|
|
$8 = Math_fround(Math_fround($1 - Math_imul($10, $3) >>> 0) / $26);
|
|
label$4 : {
|
|
if ($27) {
|
|
$7 = 0;
|
|
$11 = 0;
|
|
$14 = 0;
|
|
$15 = 0;
|
|
break label$4;
|
|
}
|
|
$28 = ($9 << 2) + $2 | 0;
|
|
$29 = 4 - $3 | 0;
|
|
$30 = HEAP32[$0 + 76 >> 2];
|
|
$3 = 0;
|
|
$15 = 0;
|
|
$14 = 0;
|
|
$11 = 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$6 = HEAPF32[($3 << 2) + $28 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
$1 = (Math_imul($5, $3) + $29 << 2) + $30 | 0;
|
|
$14 = $14 + +Math_fround($6 * HEAPF32[$1 >> 2]);
|
|
$15 = $15 + +Math_fround($6 * HEAPF32[$1 + 4 >> 2]);
|
|
$11 = $11 + +Math_fround($6 * HEAPF32[$1 - 4 >> 2]);
|
|
$7 = $7 + +Math_fround($6 * HEAPF32[$1 - 8 >> 2]);
|
|
if (($3 | 0) != ($21 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = Math_fround($8 * Math_fround(.16666999459266663));
|
|
$22 = Math_fround($8 * Math_fround($8 * $6));
|
|
$16 = +Math_fround($22 - $6);
|
|
$31 = $7 * $16;
|
|
$6 = Math_fround($8 * Math_fround($8 * Math_fround(.5)));
|
|
$7 = +Math_fround(Math_fround($8 + $6) - Math_fround($8 * $6));
|
|
$11 = $31 + $11 * $7;
|
|
$16 = 1 - $16 - $7;
|
|
$7 = +Math_fround(Math_fround($6 + Math_fround($8 * Math_fround(-.3333300054073334))) - $22);
|
|
HEAPF32[(Math_imul($12, $25) << 2) + $4 >> 2] = $11 + $14 * +Math_fround($16 - $7) + $15 * $7;
|
|
$3 = $13 + $23 | 0;
|
|
$13 = $3 - ($3 >>> 0 < $10 >>> 0 ? 0 : $10) | 0;
|
|
$12 = $12 + 1 | 0;
|
|
$9 = ($9 + $24 | 0) + ($3 >>> 0 >= $10 >>> 0) | 0;
|
|
if (($19 | 0) > ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$18 >> 2] = $9;
|
|
HEAP32[$17 >> 2] = $13;
|
|
return $12 | 0;
|
|
}
|
|
function silk_find_pitch_lags_FLP($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = 0, $11 = 0, $12 = 0;
|
|
$5 = __stack_pointer - 1744 | 0;
|
|
__stack_pointer = $5;
|
|
$7 = HEAP32[$0 + 4548 >> 2];
|
|
$8 = HEAP32[$0 + 4596 >> 2];
|
|
$6 = $8 + HEAP32[$0 + 4584 >> 2] | 0;
|
|
$10 = HEAP32[$0 + 4592 >> 2];
|
|
$11 = $6 + $10 | 0;
|
|
if (($7 | 0) <= ($11 | 0)) {
|
|
$6 = (($6 << 2) + $3 | 0) - ($7 << 2) | 0;
|
|
silk_apply_sine_window_FLP($5, $6, 1, $8);
|
|
$8 = HEAP32[$0 + 4596 >> 2];
|
|
$7 = $8 << 2;
|
|
$12 = $7 + $5 | 0;
|
|
$7 = $7 + $6 | 0;
|
|
$6 = HEAP32[$0 + 4548 >> 2] - ($8 << 1) << 2;
|
|
silk_apply_sine_window_FLP($6 + memcpy($12, $7, $6) | 0, $7 + $6 | 0, 2, $8);
|
|
silk_autocorrelation_FLP($5 + 1664 | 0, $5, HEAP32[$0 + 4548 >> 2], HEAP32[$0 + 4648 >> 2] + 1 | 0);
|
|
$9 = HEAPF32[$5 + 1664 >> 2];
|
|
HEAPF32[$5 + 1664 >> 2] = $9 + Math_fround(Math_fround($9 * Math_fround(.0010000000474974513)) + Math_fround(1));
|
|
$9 = silk_schur_FLP($5 + 1536 | 0, $5 + 1664 | 0, HEAP32[$0 + 4648 >> 2]);
|
|
HEAPF32[$1 + 704 >> 2] = HEAPF32[$5 + 1664 >> 2] / ($9 > Math_fround(1) ? $9 : Math_fround(1));
|
|
silk_k2a_FLP($5 + 1600 | 0, $5 + 1536 | 0, HEAP32[$0 + 4648 >> 2]);
|
|
silk_bwexpander_FLP($5 + 1600 | 0, HEAP32[$0 + 4648 >> 2], Math_fround(.9900000095367432));
|
|
silk_LPC_analysis_filter_FLP($2, $5 + 1600 | 0, $3 - ($10 << 2) | 0, $11, HEAP32[$0 + 4648 >> 2]);
|
|
label$2 : {
|
|
if (!(HEAP32[$0 + 4664 >> 2] | !HEAPU8[$0 + 4765 | 0])) {
|
|
if (!silk_pitch_analysis_core_FLP($2, $1 + 228 | 0, $0 + 4762 | 0, $0 + 4764 | 0, $0 + 10060 | 0, HEAP32[$0 + 4544 >> 2], Math_fround(Math_fround(HEAP32[$0 + 4652 >> 2]) * Math_fround(152587890625e-16)), Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4648 >> 2]) * Math_fround(-.004000000189989805)) + Math_fround(.6000000238418579)) + Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4532 >> 2]) * Math_fround(.10000000149011612)) * Math_fround(-.00390625))) + Math_fround(Math_fround(HEAP8[$0 + 4541 | 0] >> 1) * Math_fround(-.15000000596046448))) + Math_fround(Math_fround(Math_fround(HEAP32[$0 + 4712 >> 2]) * Math_fround(.10000000149011612)) * Math_fround(-30517578125e-15))), HEAP32[$0 + 4576 >> 2], HEAP32[$0 + 4644 >> 2], HEAP32[$0 + 4580 >> 2], $4)) {
|
|
HEAP8[$0 + 4765 | 0] = 2;
|
|
break label$2;
|
|
}
|
|
HEAP8[$0 + 4765 | 0] = 1;
|
|
break label$2;
|
|
}
|
|
HEAP32[$1 + 228 >> 2] = 0;
|
|
HEAP32[$1 + 232 >> 2] = 0;
|
|
HEAP32[$1 + 236 >> 2] = 0;
|
|
HEAP32[$1 + 240 >> 2] = 0;
|
|
HEAP32[$0 + 10060 >> 2] = 0;
|
|
HEAP8[$0 + 4764 | 0] = 0;
|
|
HEAP16[$0 + 4762 >> 1] = 0;
|
|
}
|
|
__stack_pointer = $5 + 1744 | 0;
|
|
return;
|
|
}
|
|
celt_fatal(10821, 10883, 59);
|
|
abort();
|
|
}
|
|
function stereo_itheta($0, $1, $2, $3, $4) {
|
|
var $5 = Math_fround(0), $6 = Math_fround(0), $7 = Math_fround(0), $8 = Math_fround(0), $9 = Math_fround(0);
|
|
label$1 : {
|
|
if ($2) {
|
|
$6 = Math_fround(1.0000000036274937e-15);
|
|
if (($3 | 0) < 1) {
|
|
$5 = Math_fround(1.0000000036274937e-15);
|
|
break label$1;
|
|
}
|
|
$2 = 0;
|
|
$5 = Math_fround(1.0000000036274937e-15);
|
|
while (1) {
|
|
$4 = $2 << 2;
|
|
$7 = HEAPF32[$4 + $0 >> 2];
|
|
$8 = HEAPF32[$1 + $4 >> 2];
|
|
$9 = Math_fround($7 - $8);
|
|
$5 = Math_fround($5 + Math_fround($9 * $9));
|
|
$7 = Math_fround($7 + $8);
|
|
$6 = Math_fround($6 + Math_fround($7 * $7));
|
|
$2 = $2 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($3 | 0) < 1) {
|
|
$5 = Math_fround(1.0000000036274937e-15);
|
|
$6 = Math_fround(1.0000000036274937e-15);
|
|
break label$1;
|
|
}
|
|
$2 = 0;
|
|
while (1) {
|
|
$5 = HEAPF32[($2 << 2) + $0 >> 2];
|
|
$6 = Math_fround($6 + Math_fround($5 * $5));
|
|
$2 = $2 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = Math_fround($6 + Math_fround(1.0000000036274937e-15));
|
|
$2 = 0;
|
|
$5 = Math_fround(0);
|
|
while (1) {
|
|
$7 = HEAPF32[($2 << 2) + $1 >> 2];
|
|
$5 = Math_fround($5 + Math_fround($7 * $7));
|
|
$2 = $2 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = Math_fround($5 + Math_fround(1.0000000036274937e-15));
|
|
}
|
|
$8 = Math_fround(Math_sqrt($5));
|
|
$5 = Math_fround($8 * $8);
|
|
$9 = Math_fround(Math_sqrt($6));
|
|
$6 = Math_fround($9 * $9);
|
|
$7 = Math_fround(0);
|
|
label$8 : {
|
|
if (Math_fround($5 + $6) < Math_fround(1.000000045813705e-18)) {
|
|
break label$8;
|
|
}
|
|
$7 = Math_fround(Math_fround(1.5707963705062866) - Math_fround(Math_fround(Math_fround($8 * $9) * Math_fround($5 + Math_fround($6 * Math_fround(.43157973885536194)))) / Math_fround(Math_fround($5 + Math_fround($6 * Math_fround(.6784840226173401))) * Math_fround($5 + Math_fround($6 * Math_fround(.0859554186463356))))));
|
|
if (!($5 > $6 ^ 1)) {
|
|
break label$8;
|
|
}
|
|
$7 = Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($8 * $9) * Math_fround($6 + Math_fround($5 * Math_fround(.43157973885536194)))) / Math_fround(Math_fround($6 + Math_fround($5 * Math_fround(.6784840226173401))) * Math_fround($6 + Math_fround($5 * Math_fround(.0859554186463356))))) + Math_fround(1.5707963705062866)) + Math_fround(-1.5707963705062866));
|
|
}
|
|
$6 = Math_fround(Math_floor(Math_fround(Math_fround($7 * Math_fround(10430.3818359375)) + Math_fround(.5))));
|
|
if (Math_fround(Math_abs($6)) < Math_fround(2147483648)) {
|
|
return ~~$6;
|
|
}
|
|
return -2147483648;
|
|
}
|
|
function silk_resampler_down2_3($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0;
|
|
$6 = __stack_pointer - 1936 | 0;
|
|
__stack_pointer = $6;
|
|
$5 = $0;
|
|
$7 = HEAP32[$5 >> 2];
|
|
$4 = HEAP32[$5 + 4 >> 2];
|
|
HEAP32[$6 >> 2] = $7;
|
|
HEAP32[$6 + 4 >> 2] = $4;
|
|
$7 = HEAP32[$5 + 12 >> 2];
|
|
$4 = HEAP32[$5 + 8 >> 2];
|
|
HEAP32[$6 + 8 >> 2] = $4;
|
|
HEAP32[$6 + 12 >> 2] = $7;
|
|
$20 = $5 + 16 | 0;
|
|
$11 = HEAP16[3144];
|
|
$15 = HEAP16[3145];
|
|
$12 = HEAP16[3143];
|
|
$13 = HEAP16[3142];
|
|
$21 = $6 + 16 | 0;
|
|
while (1) {
|
|
$9 = ($3 | 0) < 480 ? $3 : 480;
|
|
silk_resampler_private_AR2($20, $21, $2, 6280, $9);
|
|
if (($9 | 0) >= 3) {
|
|
$4 = HEAP32[$6 >> 2];
|
|
$5 = $6;
|
|
$7 = $9;
|
|
while (1) {
|
|
$14 = Math_imul($4 >> 16, $13) + (Math_imul($4 & 65535, $13) >> 16) | 0;
|
|
$4 = HEAP32[$5 + 4 >> 2];
|
|
$8 = $4 >> 16;
|
|
$10 = $4 & 65535;
|
|
$4 = HEAP32[$5 + 8 >> 2];
|
|
$16 = (Math_imul($4 & 65535, $15) >> 16) + Math_imul($4 >> 16, $15) | 0;
|
|
$4 = HEAP32[$5 + 12 >> 2];
|
|
$17 = $4 >> 16;
|
|
$18 = $4 & 65535;
|
|
$14 = (($16 + ((Math_imul($8, $12) + $14 | 0) + (Math_imul($12, $10) >> 16) | 0) | 0) + Math_imul($17, $11) | 0) + (Math_imul($18, $11) >> 16) | 0;
|
|
$19 = ($14 >> 5) + 1 >> 1;
|
|
HEAP16[$1 >> 1] = ($14 | 0) > 2097119 ? 32767 : ($19 | 0) > -32768 ? $19 : -32768;
|
|
$10 = (((Math_imul($12, $17) + (Math_imul($12, $18) >> 16) | 0) + Math_imul($8, $11) | 0) + $16 | 0) + (Math_imul($11, $10) >> 16) | 0;
|
|
$8 = HEAP32[$5 + 16 >> 2];
|
|
$8 = ($10 + Math_imul($8 >> 16, $13) | 0) + (Math_imul($8 & 65535, $13) >> 16) | 0;
|
|
$10 = ($8 >> 5) + 1 >> 1;
|
|
HEAP16[$1 + 2 >> 1] = ($8 | 0) > 2097119 ? 32767 : ($10 | 0) > -32768 ? $10 : -32768;
|
|
$1 = $1 + 4 | 0;
|
|
$5 = $5 + 12 | 0;
|
|
$8 = ($7 | 0) > 5;
|
|
$7 = $7 - 3 | 0;
|
|
if ($8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $3 - $9 | 0;
|
|
if (($3 | 0) >= 1) {
|
|
$5 = ($9 << 2) + $6 | 0;
|
|
$7 = HEAP32[$5 >> 2];
|
|
$4 = HEAP32[$5 + 4 >> 2];
|
|
HEAP32[$6 >> 2] = $7;
|
|
HEAP32[$6 + 4 >> 2] = $4;
|
|
$7 = HEAP32[$5 + 12 >> 2];
|
|
$4 = HEAP32[$5 + 8 >> 2];
|
|
HEAP32[$6 + 8 >> 2] = $4;
|
|
HEAP32[$6 + 12 >> 2] = $7;
|
|
$2 = ($9 << 1) + $2 | 0;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = ($9 << 2) + $6 | 0;
|
|
$7 = HEAP32[$5 >> 2];
|
|
$4 = HEAP32[$5 + 4 >> 2];
|
|
$1 = $7;
|
|
$7 = $0;
|
|
HEAP32[$7 >> 2] = $1;
|
|
HEAP32[$7 + 4 >> 2] = $4;
|
|
$7 = HEAP32[$5 + 12 >> 2];
|
|
$4 = HEAP32[$5 + 8 >> 2];
|
|
$1 = $4;
|
|
$4 = $0;
|
|
HEAP32[$4 + 8 >> 2] = $1;
|
|
HEAP32[$4 + 12 >> 2] = $7;
|
|
__stack_pointer = $6 + 1936 | 0;
|
|
}
|
|
function memcpy($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0;
|
|
if ($2 >>> 0 >= 512) {
|
|
emscripten_memcpy_big($0 | 0, $1 | 0, $2 | 0) | 0;
|
|
return $0;
|
|
}
|
|
$4 = $0 + $2 | 0;
|
|
label$2 : {
|
|
if (!(($0 ^ $1) & 3)) {
|
|
label$4 : {
|
|
if (($2 | 0) < 1) {
|
|
$2 = $0;
|
|
break label$4;
|
|
}
|
|
if (!($0 & 3)) {
|
|
$2 = $0;
|
|
break label$4;
|
|
}
|
|
$2 = $0;
|
|
while (1) {
|
|
HEAP8[$2 | 0] = HEAPU8[$1 | 0];
|
|
$1 = $1 + 1 | 0;
|
|
$2 = $2 + 1 | 0;
|
|
if ($4 >>> 0 <= $2 >>> 0) {
|
|
break label$4;
|
|
}
|
|
if ($2 & 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $4 & -4;
|
|
label$8 : {
|
|
if ($3 >>> 0 < 64) {
|
|
break label$8;
|
|
}
|
|
$5 = $3 + -64 | 0;
|
|
if ($5 >>> 0 < $2 >>> 0) {
|
|
break label$8;
|
|
}
|
|
while (1) {
|
|
HEAP32[$2 >> 2] = HEAP32[$1 >> 2];
|
|
HEAP32[$2 + 4 >> 2] = HEAP32[$1 + 4 >> 2];
|
|
HEAP32[$2 + 8 >> 2] = HEAP32[$1 + 8 >> 2];
|
|
HEAP32[$2 + 12 >> 2] = HEAP32[$1 + 12 >> 2];
|
|
HEAP32[$2 + 16 >> 2] = HEAP32[$1 + 16 >> 2];
|
|
HEAP32[$2 + 20 >> 2] = HEAP32[$1 + 20 >> 2];
|
|
HEAP32[$2 + 24 >> 2] = HEAP32[$1 + 24 >> 2];
|
|
HEAP32[$2 + 28 >> 2] = HEAP32[$1 + 28 >> 2];
|
|
HEAP32[$2 + 32 >> 2] = HEAP32[$1 + 32 >> 2];
|
|
HEAP32[$2 + 36 >> 2] = HEAP32[$1 + 36 >> 2];
|
|
HEAP32[$2 + 40 >> 2] = HEAP32[$1 + 40 >> 2];
|
|
HEAP32[$2 + 44 >> 2] = HEAP32[$1 + 44 >> 2];
|
|
HEAP32[$2 + 48 >> 2] = HEAP32[$1 + 48 >> 2];
|
|
HEAP32[$2 + 52 >> 2] = HEAP32[$1 + 52 >> 2];
|
|
HEAP32[$2 + 56 >> 2] = HEAP32[$1 + 56 >> 2];
|
|
HEAP32[$2 + 60 >> 2] = HEAP32[$1 + 60 >> 2];
|
|
$1 = $1 - -64 | 0;
|
|
$2 = $2 - -64 | 0;
|
|
if ($5 >>> 0 >= $2 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($2 >>> 0 >= $3 >>> 0) {
|
|
break label$2;
|
|
}
|
|
while (1) {
|
|
HEAP32[$2 >> 2] = HEAP32[$1 >> 2];
|
|
$1 = $1 + 4 | 0;
|
|
$2 = $2 + 4 | 0;
|
|
if ($3 >>> 0 > $2 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$2;
|
|
}
|
|
if ($4 >>> 0 < 4) {
|
|
$2 = $0;
|
|
break label$2;
|
|
}
|
|
$3 = $4 - 4 | 0;
|
|
if ($3 >>> 0 < $0 >>> 0) {
|
|
$2 = $0;
|
|
break label$2;
|
|
}
|
|
$2 = $0;
|
|
while (1) {
|
|
HEAP8[$2 | 0] = HEAPU8[$1 | 0];
|
|
HEAP8[$2 + 1 | 0] = HEAPU8[$1 + 1 | 0];
|
|
HEAP8[$2 + 2 | 0] = HEAPU8[$1 + 2 | 0];
|
|
HEAP8[$2 + 3 | 0] = HEAPU8[$1 + 3 | 0];
|
|
$1 = $1 + 4 | 0;
|
|
$2 = $2 + 4 | 0;
|
|
if ($3 >>> 0 >= $2 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($2 >>> 0 < $4 >>> 0) {
|
|
while (1) {
|
|
HEAP8[$2 | 0] = HEAPU8[$1 | 0];
|
|
$1 = $1 + 1 | 0;
|
|
$2 = $2 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $0;
|
|
}
|
|
function silk_VQ_WMat_EC_c($0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) {
|
|
var $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0;
|
|
$12 = HEAP32[$5 + 8 >> 2];
|
|
$13 = HEAP32[$5 + 4 >> 2];
|
|
$15 = HEAP32[$5 >> 2];
|
|
$14 = HEAP32[$5 + 12 >> 2];
|
|
$5 = HEAP32[$5 + 16 >> 2];
|
|
HEAP32[$2 >> 2] = 2147483647;
|
|
HEAP32[$1 >> 2] = 2147483647;
|
|
HEAP8[$0 | 0] = 0;
|
|
if (($11 | 0) >= 1) {
|
|
$17 = $5 << 8;
|
|
$18 = $14 << 7;
|
|
$19 = $15 << 7;
|
|
$20 = $13 << 7;
|
|
$21 = $12 << 7;
|
|
$22 = $9 << 16 >> 16;
|
|
$15 = 0;
|
|
while (1) {
|
|
$14 = HEAP8[$6 | 0];
|
|
$13 = HEAP8[$6 + 1 | 0];
|
|
$12 = HEAP8[$6 + 2 | 0];
|
|
$9 = HEAP8[$6 + 3 | 0];
|
|
$5 = HEAP8[$6 + 4 | 0];
|
|
$16 = Math_imul($14, HEAP32[$4 >> 2]) + ((((Math_imul($13, HEAP32[$4 + 4 >> 2]) - $19 | 0) + Math_imul($12, HEAP32[$4 + 8 >> 2]) | 0) + Math_imul($9, HEAP32[$4 + 12 >> 2]) | 0) + Math_imul($5, HEAP32[$4 + 16 >> 2]) << 1) | 0;
|
|
$16 = Math_imul($16 >> 16, $14) + (Math_imul($16 & 65535, $14) >> 16) | 0;
|
|
$14 = Math_imul(HEAP32[$4 + 24 >> 2], $13) + (((Math_imul(HEAP32[$4 + 28 >> 2], $12) - $20 | 0) + Math_imul(HEAP32[$4 + 32 >> 2], $9) | 0) + Math_imul(HEAP32[$4 + 36 >> 2], $5) << 1) | 0;
|
|
$14 = ($16 + Math_imul($14 >> 16, $13) | 0) + (Math_imul($14 & 65535, $13) >> 16) | 0;
|
|
$13 = Math_imul(HEAP32[$4 + 48 >> 2], $12) + ((Math_imul(HEAP32[$4 + 52 >> 2], $9) - $21 | 0) + Math_imul(HEAP32[$4 + 56 >> 2], $5) << 1) | 0;
|
|
$14 = ($14 + Math_imul($13 >> 16, $12) | 0) + (Math_imul($13 & 65535, $12) >> 16) | 0;
|
|
$12 = Math_imul(HEAP32[$4 + 96 >> 2], $5) - $17 | 0;
|
|
$13 = Math_imul(HEAP32[$4 + 72 >> 2], $9) + (Math_imul(HEAP32[$4 + 76 >> 2], $5) - $18 << 1) | 0;
|
|
$5 = (((($14 + Math_imul($12 >> 16, $5) | 0) + Math_imul($13 >> 16, $9) | 0) + (Math_imul($12 & 65535, $5) >> 16) | 0) + (Math_imul($13 & 65535, $9) >> 16) | 0) + 32801 | 0;
|
|
label$3 : {
|
|
if (($5 | 0) < 0) {
|
|
break label$3;
|
|
}
|
|
$12 = HEAPU8[$7 + $15 | 0];
|
|
$9 = $12 - $10 | 0;
|
|
$5 = ((($9 | 0) > 0 ? $9 : 0) << 11) + $5 | 0;
|
|
$9 = Math_imul((silk_lin2log($5) << 16) - 125829120 >> 16, $22) + (HEAPU8[$8 + $15 | 0] << 2) | 0;
|
|
if (($9 | 0) > HEAP32[$2 >> 2]) {
|
|
break label$3;
|
|
}
|
|
HEAP32[$2 >> 2] = $9;
|
|
HEAP32[$1 >> 2] = $5;
|
|
HEAP8[$0 | 0] = $15;
|
|
HEAP32[$3 >> 2] = $12;
|
|
}
|
|
$6 = $6 + 5 | 0;
|
|
$15 = $15 + 1 | 0;
|
|
if (($15 | 0) != ($11 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_quant_LTP_gains($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
var $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0;
|
|
$11 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $11;
|
|
$19 = ($8 | 0) < 1;
|
|
$18 = 2147483647;
|
|
while (1) {
|
|
$12 = HEAP32[$3 >> 2];
|
|
label$2 : {
|
|
if ($19) {
|
|
$16 = 0;
|
|
$15 = 0;
|
|
$9 = $12;
|
|
break label$2;
|
|
}
|
|
$20 = HEAP8[$17 + 7916 | 0];
|
|
$10 = $17 << 2;
|
|
$21 = HEAP32[$10 + 7904 >> 2];
|
|
$22 = HEAP32[$10 + 7824 >> 2];
|
|
$23 = HEAP32[$10 + 7520 >> 2];
|
|
$10 = 0;
|
|
$15 = 0;
|
|
$16 = 0;
|
|
$13 = $6;
|
|
$14 = $5;
|
|
while (1) {
|
|
silk_VQ_WMat_EC_c(($11 + 12 | 0) + $10 | 0, $11 + 8 | 0, $11 + 4 | 0, $11, $14, $13, $22, $21, $23, $7, silk_log2lin(6229 - $12 | 0) - 51 | 0, $20);
|
|
$15 = HEAP32[$11 + 4 >> 2] + $15 | 0;
|
|
$24 = ($15 | 0) > -1;
|
|
$16 = HEAP32[$11 + 8 >> 2] + $16 | 0;
|
|
$25 = ($16 | 0) > -1;
|
|
$9 = 0;
|
|
if ((silk_lin2log(HEAP32[$11 >> 2] + 51 | 0) + $12 | 0) >= 896) {
|
|
$9 = (silk_lin2log(HEAP32[$11 >> 2] + 51 | 0) + $12 | 0) - 896 | 0;
|
|
}
|
|
$15 = $24 ? $15 : 2147483647;
|
|
$16 = $25 ? $16 : 2147483647;
|
|
$13 = $13 + 20 | 0;
|
|
$14 = $14 + 100 | 0;
|
|
$12 = $9;
|
|
$10 = $10 + 1 | 0;
|
|
if (($10 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($15 | 0) <= ($18 | 0)) {
|
|
HEAP8[$2 | 0] = $17;
|
|
memcpy($1, $11 + 12 | 0, $8);
|
|
$26 = $9;
|
|
$18 = $15;
|
|
}
|
|
$17 = $17 + 1 | 0;
|
|
if (($17 | 0) != 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($8 | 0) >= 1) {
|
|
$12 = HEAP32[(HEAP8[$2 | 0] << 2) + 7824 >> 2];
|
|
$14 = 0;
|
|
while (1) {
|
|
$10 = Math_imul($14, 10) + $0 | 0;
|
|
$13 = $1 + $14 | 0;
|
|
HEAP16[$10 >> 1] = HEAP8[Math_imul(HEAP8[$13 | 0], 5) + $12 | 0] << 7;
|
|
HEAP16[$10 + 2 >> 1] = HEAP8[(Math_imul(HEAP8[$13 | 0], 5) + $12 | 0) + 1 | 0] << 7;
|
|
HEAP16[$10 + 4 >> 1] = HEAP8[(Math_imul(HEAP8[$13 | 0], 5) + $12 | 0) + 2 | 0] << 7;
|
|
HEAP16[$10 + 6 >> 1] = HEAP8[(Math_imul(HEAP8[$13 | 0], 5) + $12 | 0) + 3 | 0] << 7;
|
|
HEAP16[$10 + 8 >> 1] = HEAP8[(Math_imul(HEAP8[$13 | 0], 5) + $12 | 0) + 4 | 0] << 7;
|
|
$14 = $14 + 1 | 0;
|
|
if (($14 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$3 >> 2] = $26;
|
|
HEAP32[$4 >> 2] = Math_imul((silk_lin2log($16 >> (($8 | 0) == 2 ? 1 : 2)) << 16) - 125829120 >> 16, -3);
|
|
__stack_pointer = $11 + 16 | 0;
|
|
}
|
|
function silk_insertion_sort_decreasing_FLP($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($3 | 0) > 0) {
|
|
if (($2 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
if (($2 | 0) < ($3 | 0)) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
HEAP32[($4 << 2) + $1 >> 2] = $4;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = 1;
|
|
if (($3 | 0) > 1) {
|
|
while (1) {
|
|
$9 = HEAPF32[($6 << 2) + $0 >> 2];
|
|
$4 = $6;
|
|
label$7 : {
|
|
while (1) {
|
|
$7 = $4 - 1 | 0;
|
|
$5 = $7 << 2;
|
|
$10 = HEAPF32[$5 + $0 >> 2];
|
|
if ($10 < $9 ^ 1) {
|
|
break label$7;
|
|
}
|
|
$8 = $4 << 2;
|
|
HEAPF32[$8 + $0 >> 2] = $10;
|
|
HEAP32[$1 + $8 >> 2] = HEAP32[$1 + $5 >> 2];
|
|
$5 = ($4 | 0) > 1;
|
|
$4 = $7;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
}
|
|
$4 = $4 << 2;
|
|
HEAPF32[$4 + $0 >> 2] = $9;
|
|
HEAP32[$1 + $4 >> 2] = $6;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($2 | 0) > ($3 | 0)) {
|
|
$6 = $3 - 2 | 0;
|
|
$11 = (($3 << 2) + $0 | 0) - 4 | 0;
|
|
$8 = $3;
|
|
while (1) {
|
|
$9 = HEAPF32[($8 << 2) + $0 >> 2];
|
|
if (!($9 > HEAPF32[$11 >> 2] ^ 1)) {
|
|
$4 = $6;
|
|
$5 = $4;
|
|
label$12 : {
|
|
if (($3 | 0) < 2) {
|
|
break label$12;
|
|
}
|
|
while (1) {
|
|
$7 = $4 << 2;
|
|
$10 = HEAPF32[$7 + $0 >> 2];
|
|
if ($10 < $9 ^ 1) {
|
|
$5 = $4;
|
|
break label$12;
|
|
}
|
|
$5 = $7 + 4 | 0;
|
|
HEAPF32[$5 + $0 >> 2] = $10;
|
|
HEAP32[$1 + $5 >> 2] = HEAP32[$1 + $7 >> 2];
|
|
$5 = -1;
|
|
$7 = ($4 | 0) > 0;
|
|
$4 = $4 - 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = ($5 << 2) + 4 | 0;
|
|
HEAPF32[$4 + $0 >> 2] = $9;
|
|
HEAP32[$1 + $4 >> 2] = $8;
|
|
}
|
|
$8 = $8 + 1 | 0;
|
|
if (($8 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(9912, 9936, 50);
|
|
abort();
|
|
}
|
|
celt_fatal(9958, 9936, 51);
|
|
abort();
|
|
}
|
|
celt_fatal(9982, 9936, 52);
|
|
abort();
|
|
}
|
|
function silk_insertion_sort_increasing($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($3 | 0) > 0) {
|
|
if (($2 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
if (($2 | 0) < ($3 | 0)) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
HEAP32[($4 << 2) + $1 >> 2] = $4;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$6 = 1;
|
|
if (($3 | 0) > 1) {
|
|
while (1) {
|
|
$7 = HEAP32[($6 << 2) + $0 >> 2];
|
|
$4 = $6;
|
|
label$7 : {
|
|
while (1) {
|
|
$8 = $4 - 1 | 0;
|
|
$5 = $8 << 2;
|
|
$10 = HEAP32[$5 + $0 >> 2];
|
|
if (($10 | 0) <= ($7 | 0)) {
|
|
break label$7;
|
|
}
|
|
$9 = $4 << 2;
|
|
HEAP32[$9 + $0 >> 2] = $10;
|
|
HEAP32[$1 + $9 >> 2] = HEAP32[$1 + $5 >> 2];
|
|
$5 = ($4 | 0) > 1;
|
|
$4 = $8;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 0;
|
|
}
|
|
$4 = $4 << 2;
|
|
HEAP32[$4 + $0 >> 2] = $7;
|
|
HEAP32[$1 + $4 >> 2] = $6;
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($2 | 0) > ($3 | 0)) {
|
|
$6 = $3 - 2 | 0;
|
|
$11 = (($3 << 2) + $0 | 0) - 4 | 0;
|
|
$7 = $3;
|
|
while (1) {
|
|
$9 = HEAP32[($7 << 2) + $0 >> 2];
|
|
if (($9 | 0) < HEAP32[$11 >> 2]) {
|
|
$4 = $6;
|
|
$5 = $4;
|
|
label$12 : {
|
|
if (($3 | 0) < 2) {
|
|
break label$12;
|
|
}
|
|
while (1) {
|
|
$8 = $4 << 2;
|
|
$5 = HEAP32[$8 + $0 >> 2];
|
|
if (($9 | 0) >= ($5 | 0)) {
|
|
$5 = $4;
|
|
break label$12;
|
|
}
|
|
$10 = $8 + 4 | 0;
|
|
HEAP32[$10 + $0 >> 2] = $5;
|
|
HEAP32[$1 + $10 >> 2] = HEAP32[$1 + $8 >> 2];
|
|
$5 = -1;
|
|
$8 = ($4 | 0) > 0;
|
|
$4 = $4 - 1 | 0;
|
|
if ($8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = ($5 << 2) + 4 | 0;
|
|
HEAP32[$4 + $0 >> 2] = $9;
|
|
HEAP32[$1 + $4 >> 2] = $7;
|
|
}
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(15635, 15659, 51);
|
|
abort();
|
|
}
|
|
celt_fatal(15671, 15659, 52);
|
|
abort();
|
|
}
|
|
celt_fatal(15695, 15659, 53);
|
|
abort();
|
|
}
|
|
function silk_stereo_quant_pred($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0;
|
|
$13 = 1;
|
|
while (1) {
|
|
$10 = ($4 << 2) + $0 | 0;
|
|
$7 = Math_imul($4, 3) + $1 | 0;
|
|
$11 = $7;
|
|
$3 = 2147483647;
|
|
$4 = 0;
|
|
label$2 : {
|
|
label$3 : {
|
|
while (1) {
|
|
$14 = $4 + 1 | 0;
|
|
$6 = HEAP16[($4 << 1) + 5744 >> 1];
|
|
$5 = HEAP16[($14 << 1) + 5744 >> 1] - $6 | 0;
|
|
$15 = Math_imul($5 & 65535, 6554) >>> 16 | 0;
|
|
$16 = $5 >> 16;
|
|
$5 = Math_imul($16, 6554) + $15 | 0;
|
|
$12 = $5 + $6 | 0;
|
|
$2 = HEAP32[$10 >> 2] - $12 | 0;
|
|
$8 = $2;
|
|
$2 = $2 >> 31;
|
|
$2 = $2 ^ $2 + $8;
|
|
if (($2 | 0) >= ($3 | 0)) {
|
|
$4 = HEAPU8[$7 | 0];
|
|
break label$2;
|
|
}
|
|
HEAP8[$7 | 0] = $4;
|
|
HEAP8[$11 + 1 | 0] = 0;
|
|
$9 = Math_imul($5, 3) + $6 | 0;
|
|
$3 = HEAP32[$10 >> 2] - $9 | 0;
|
|
$8 = $3;
|
|
$3 = $3 >> 31;
|
|
$3 = $3 ^ $3 + $8;
|
|
if (($2 | 0) <= ($3 | 0)) {
|
|
$9 = $12;
|
|
break label$2;
|
|
}
|
|
HEAP8[$7 | 0] = $4;
|
|
HEAP8[$11 + 1 | 0] = 1;
|
|
$17 = Math_imul($5, 5) + $6 | 0;
|
|
$2 = HEAP32[$10 >> 2] - $17 | 0;
|
|
$8 = $2;
|
|
$2 = $2 >> 31;
|
|
$2 = $2 ^ $2 + $8;
|
|
if (($2 | 0) >= ($3 | 0)) {
|
|
break label$2;
|
|
}
|
|
HEAP8[$7 | 0] = $4;
|
|
HEAP8[$11 + 1 | 0] = 2;
|
|
$9 = Math_imul($5, 7) + $6 | 0;
|
|
$3 = HEAP32[$10 >> 2] - $9 | 0;
|
|
$8 = $3;
|
|
$3 = $3 >> 31;
|
|
$12 = $3 ^ $3 + $8;
|
|
if (($12 | 0) >= ($2 | 0)) {
|
|
break label$3;
|
|
}
|
|
HEAP8[$7 | 0] = $4;
|
|
HEAP8[$11 + 1 | 0] = 3;
|
|
$5 = HEAP32[$10 >> 2] - (Math_imul($5, 9) + $6 | 0) | 0;
|
|
$2 = $5;
|
|
$5 = $5 >> 31;
|
|
$3 = $5 ^ $5 + $2;
|
|
if (($12 | 0) <= ($3 | 0)) {
|
|
break label$2;
|
|
}
|
|
$9 = (Math_imul($16, 58986) + Math_imul($15, 9) | 0) + $6 | 0;
|
|
HEAP8[$7 | 0] = $4;
|
|
HEAP8[$11 + 1 | 0] = 4;
|
|
$4 = $14;
|
|
if (($4 | 0) != 15) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = 14;
|
|
break label$2;
|
|
}
|
|
$9 = $17;
|
|
}
|
|
$6 = ($4 << 24 >> 24) / 3 | 0;
|
|
HEAP8[$7 + 2 | 0] = $6;
|
|
HEAP8[$7 | 0] = Math_imul($6, -3) + $4;
|
|
HEAP32[$10 >> 2] = $9;
|
|
$4 = 1;
|
|
$6 = $13;
|
|
$13 = 0;
|
|
if ($6) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - HEAP32[$0 + 4 >> 2];
|
|
}
|
|
function quant_energy_finalise($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
var $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0), $17 = 0, $18 = 0, $19 = 0;
|
|
$17 = ($9 | 0) > 1 ? $9 : 1;
|
|
$18 = ($1 | 0) >= ($2 | 0);
|
|
label$1 : {
|
|
if ($18 | ($7 | 0) < ($9 | 0)) {
|
|
break label$1;
|
|
}
|
|
$11 = $1;
|
|
while (1) {
|
|
$10 = $11 << 2;
|
|
$19 = $10 + $5 | 0;
|
|
if (!(HEAP32[$19 >> 2] > 7 | HEAP32[$6 + $10 >> 2])) {
|
|
$12 = HEAP32[$0 + 8 >> 2];
|
|
$10 = 0;
|
|
while (1) {
|
|
$13 = HEAPF32[(Math_imul($10, $12) + $11 << 2) + $4 >> 2] < Math_fround(0);
|
|
ec_enc_bits($8, $13 ^ 1, 1);
|
|
$12 = HEAP32[$0 + 8 >> 2];
|
|
$14 = Math_imul($12, $10) + $11 << 2;
|
|
$15 = $14 + $3 | 0;
|
|
$16 = Math_fround(Math_fround(($13 ? Math_fround(-.5) : Math_fround(.5)) * Math_fround(1 << 13 - HEAP32[$19 >> 2])) * Math_fround(6103515625e-14));
|
|
HEAPF32[$15 >> 2] = HEAPF32[$15 >> 2] + $16;
|
|
$13 = $4 + $14 | 0;
|
|
HEAPF32[$13 >> 2] = HEAPF32[$13 >> 2] - $16;
|
|
$10 = $10 + 1 | 0;
|
|
if (($17 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = $7 - $17 | 0;
|
|
}
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) >= ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
if (($7 | 0) >= ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$5 : {
|
|
if (($7 | 0) < ($9 | 0) | $18) {
|
|
break label$5;
|
|
}
|
|
while (1) {
|
|
$10 = $1 << 2;
|
|
$15 = $10 + $5 | 0;
|
|
if (!(HEAP32[$15 >> 2] > 7 | HEAP32[$6 + $10 >> 2] != 1)) {
|
|
$11 = HEAP32[$0 + 8 >> 2];
|
|
$10 = 0;
|
|
while (1) {
|
|
$12 = HEAPF32[(Math_imul($10, $11) + $1 << 2) + $4 >> 2] < Math_fround(0);
|
|
ec_enc_bits($8, $12 ^ 1, 1);
|
|
$11 = HEAP32[$0 + 8 >> 2];
|
|
$13 = Math_imul($11, $10) + $1 << 2;
|
|
$14 = $13 + $3 | 0;
|
|
$16 = Math_fround(Math_fround(($12 ? Math_fround(-.5) : Math_fround(.5)) * Math_fround(1 << 13 - HEAP32[$15 >> 2])) * Math_fround(6103515625e-14));
|
|
HEAPF32[$14 >> 2] = HEAPF32[$14 >> 2] + $16;
|
|
$12 = $4 + $13 | 0;
|
|
HEAPF32[$12 >> 2] = HEAPF32[$12 >> 2] - $16;
|
|
$10 = $10 + 1 | 0;
|
|
if (($17 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = $7 - $17 | 0;
|
|
}
|
|
$1 = $1 + 1 | 0;
|
|
if (($2 | 0) <= ($1 | 0)) {
|
|
break label$5;
|
|
}
|
|
if (($7 | 0) >= ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function silk_resampler_private_IIR_FIR($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0;
|
|
$6 = __stack_pointer;
|
|
$11 = $6;
|
|
$4 = HEAP32[$0 + 268 >> 2];
|
|
$7 = $6 - (($4 << 2) + 31 & -16) | 0;
|
|
__stack_pointer = $7;
|
|
$6 = HEAP32[$0 + 36 >> 2];
|
|
$5 = HEAP32[$0 + 32 >> 2];
|
|
HEAP32[$7 + 8 >> 2] = $5;
|
|
HEAP32[$7 + 12 >> 2] = $6;
|
|
$5 = HEAP32[$0 + 28 >> 2];
|
|
$6 = HEAP32[$0 + 24 >> 2];
|
|
HEAP32[$7 >> 2] = $6;
|
|
HEAP32[$7 + 4 >> 2] = $5;
|
|
$12 = $7 + 16 | 0;
|
|
$13 = HEAP32[$0 + 272 >> 2];
|
|
while (1) {
|
|
$8 = ($3 | 0) < ($4 | 0) ? $3 : $4;
|
|
silk_resampler_private_up2_HQ($0, $12, $2, $8);
|
|
$6 = 0;
|
|
$9 = $8 << 17;
|
|
if (($9 | 0) >= 1) {
|
|
while (1) {
|
|
$10 = Math_imul($6 & 65535, 12) >>> 16 | 0;
|
|
$5 = $10 << 3;
|
|
$4 = ($6 >> 16 << 1) + $7 | 0;
|
|
$14 = ((Math_imul(HEAP16[$5 + 6306 >> 1], HEAP16[$4 + 2 >> 1]) + Math_imul(HEAP16[$5 + 6304 >> 1], HEAP16[$4 >> 1]) | 0) + Math_imul(HEAP16[$5 + 6308 >> 1], HEAP16[$4 + 4 >> 1]) | 0) + Math_imul(HEAP16[$5 + 6310 >> 1], HEAP16[$4 + 6 >> 1]) | 0;
|
|
$5 = 11 - $10 << 3;
|
|
$4 = ((($14 + Math_imul(HEAP16[$5 + 6310 >> 1], HEAP16[$4 + 8 >> 1]) | 0) + Math_imul(HEAP16[$5 + 6308 >> 1], HEAP16[$4 + 10 >> 1]) | 0) + Math_imul(HEAP16[$5 + 6306 >> 1], HEAP16[$4 + 12 >> 1]) | 0) + Math_imul(HEAP16[$5 + 6304 >> 1], HEAP16[$4 + 14 >> 1]) | 0;
|
|
$5 = ($4 >> 14) + 1 >> 1;
|
|
HEAP16[$1 >> 1] = ($4 | 0) > 1073725439 ? 32767 : ($5 | 0) > -32768 ? $5 : -32768;
|
|
$1 = $1 + 2 | 0;
|
|
$6 = $6 + $13 | 0;
|
|
if (($9 | 0) > ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $3 - $8 | 0;
|
|
if (($3 | 0) >= 1) {
|
|
$4 = ($8 << 2) + $7 | 0;
|
|
$6 = HEAP32[$4 + 4 >> 2];
|
|
$5 = HEAP32[$4 >> 2];
|
|
HEAP32[$7 >> 2] = $5;
|
|
HEAP32[$7 + 4 >> 2] = $6;
|
|
$5 = HEAP32[$4 + 12 >> 2];
|
|
$6 = HEAP32[$4 + 8 >> 2];
|
|
HEAP32[$7 + 8 >> 2] = $6;
|
|
HEAP32[$7 + 12 >> 2] = $5;
|
|
$2 = ($8 << 1) + $2 | 0;
|
|
$4 = HEAP32[$0 + 268 >> 2];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = ($8 << 2) + $7 | 0;
|
|
$6 = HEAP32[$4 + 4 >> 2];
|
|
$5 = HEAP32[$4 >> 2];
|
|
HEAP32[$0 + 24 >> 2] = $5;
|
|
HEAP32[$0 + 28 >> 2] = $6;
|
|
$5 = HEAP32[$4 + 12 >> 2];
|
|
$6 = HEAP32[$4 + 8 >> 2];
|
|
HEAP32[$0 + 32 >> 2] = $6;
|
|
HEAP32[$0 + 36 >> 2] = $5;
|
|
__stack_pointer = $11;
|
|
}
|
|
function silk_shell_encoder($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
|
|
$2 = HEAP32[$1 + 4 >> 2] + HEAP32[$1 >> 2] | 0;
|
|
$9 = HEAP32[$1 + 12 >> 2] + HEAP32[$1 + 8 >> 2] | 0;
|
|
$3 = $2 + $9 | 0;
|
|
$4 = HEAP32[$1 + 20 >> 2] + HEAP32[$1 + 16 >> 2] | 0;
|
|
$10 = HEAP32[$1 + 28 >> 2] + HEAP32[$1 + 24 >> 2] | 0;
|
|
$11 = $4 + $10 | 0;
|
|
$5 = $3 + $11 | 0;
|
|
$6 = HEAP32[$1 + 36 >> 2] + HEAP32[$1 + 32 >> 2] | 0;
|
|
$12 = HEAP32[$1 + 44 >> 2] + HEAP32[$1 + 40 >> 2] | 0;
|
|
$7 = $6 + $12 | 0;
|
|
$8 = HEAP32[$1 + 52 >> 2] + HEAP32[$1 + 48 >> 2] | 0;
|
|
$13 = HEAP32[$1 + 60 >> 2] + HEAP32[$1 + 56 >> 2] | 0;
|
|
$14 = $8 + $13 | 0;
|
|
$15 = $7 + $14 | 0;
|
|
$16 = $5 + $15 | 0;
|
|
if (($16 | 0) >= 1) {
|
|
ec_enc_icdf($0, $5, HEAPU8[$16 + 9200 | 0] + 9040 | 0, 8);
|
|
}
|
|
if (($5 | 0) >= 1) {
|
|
ec_enc_icdf($0, $3, HEAPU8[$5 + 9200 | 0] + 8880 | 0, 8);
|
|
}
|
|
if (($3 | 0) >= 1) {
|
|
ec_enc_icdf($0, $2, HEAPU8[$3 + 9200 | 0] + 8720 | 0, 8);
|
|
}
|
|
if (($2 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 >> 2], HEAPU8[$2 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($9 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 8 >> 2], HEAPU8[$9 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($11 | 0) >= 1) {
|
|
ec_enc_icdf($0, $4, HEAPU8[$11 + 9200 | 0] + 8720 | 0, 8);
|
|
}
|
|
if (($4 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 16 >> 2], HEAPU8[$4 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($10 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 24 >> 2], HEAPU8[$10 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($15 | 0) >= 1) {
|
|
ec_enc_icdf($0, $7, HEAPU8[$15 + 9200 | 0] + 8880 | 0, 8);
|
|
}
|
|
if (($7 | 0) >= 1) {
|
|
ec_enc_icdf($0, $6, HEAPU8[$7 + 9200 | 0] + 8720 | 0, 8);
|
|
}
|
|
if (($6 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 32 >> 2], HEAPU8[$6 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($12 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 40 >> 2], HEAPU8[$12 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($14 | 0) >= 1) {
|
|
ec_enc_icdf($0, $8, HEAPU8[$14 + 9200 | 0] + 8720 | 0, 8);
|
|
}
|
|
if (($8 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 48 >> 2], HEAPU8[$8 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
if (($13 | 0) >= 1) {
|
|
ec_enc_icdf($0, HEAP32[$1 + 56 >> 2], HEAPU8[$13 + 9200 | 0] + 8560 | 0, 8);
|
|
}
|
|
}
|
|
function silk_process_NLSFs($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
$5 = __stack_pointer - 96 | 0;
|
|
__stack_pointer = $5;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (!(HEAPU8[$0 + 4767 | 0] != 4 ? HEAP32[$0 + 4632 >> 2] != 1 : 0)) {
|
|
$4 = HEAP16[$0 + 4532 >> 1];
|
|
$4 = (Math_imul($4, -5) + (Math_imul($4, 59246) >> 16) | 0) + 3146 | 0;
|
|
$6 = $4 + (HEAP32[$0 + 4580 >> 2] == 2 ? $4 >> 1 : 0) | 0;
|
|
if (($6 | 0) <= 0) {
|
|
break label$2;
|
|
}
|
|
silk_NLSF_VQ_weights_laroia($5 + 32 | 0, $2, HEAP32[$0 + 4640 >> 2]);
|
|
label$5 : {
|
|
if (HEAP32[$0 + 4632 >> 2] != 1) {
|
|
break label$5;
|
|
}
|
|
$4 = HEAP8[$0 + 4767 | 0];
|
|
if (($4 | 0) > 3) {
|
|
break label$5;
|
|
}
|
|
silk_interpolate($5 - -64 | 0, $3, $2, $4, HEAP32[$0 + 4640 >> 2]);
|
|
silk_NLSF_VQ_weights_laroia($5, $5 - -64 | 0, HEAP32[$0 + 4640 >> 2]);
|
|
$10 = 1;
|
|
$7 = HEAP32[$0 + 4640 >> 2];
|
|
if (($7 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$4 = HEAP8[$0 + 4767 | 0];
|
|
$11 = Math_imul($4, $4) << 27 >> 16;
|
|
$4 = 0;
|
|
while (1) {
|
|
$8 = $4 << 1;
|
|
$9 = $8 + ($5 + 32 | 0) | 0;
|
|
HEAP16[$9 >> 1] = (HEAP16[$9 >> 1] >>> 1) + (Math_imul(HEAP16[$5 + $8 >> 1], $11) >>> 16);
|
|
$4 = $4 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_NLSF_encode($0 + 4744 | 0, $2, HEAP32[$0 + 4692 >> 2], $5 + 32 | 0, $6, HEAP32[$0 + 4660 >> 2], HEAP8[$0 + 4765 | 0]);
|
|
$4 = $1 + 32 | 0;
|
|
silk_NLSF2A($4, $2, HEAP32[$0 + 4640 >> 2], HEAP32[$0 + 5092 >> 2]);
|
|
label$7 : {
|
|
if ($10) {
|
|
silk_interpolate($5 - -64 | 0, $3, $2, HEAP8[$0 + 4767 | 0], HEAP32[$0 + 4640 >> 2]);
|
|
silk_NLSF2A($1, $5 - -64 | 0, HEAP32[$0 + 4640 >> 2], HEAP32[$0 + 5092 >> 2]);
|
|
break label$7;
|
|
}
|
|
$0 = HEAP32[$0 + 4640 >> 2];
|
|
if (($0 | 0) >= 17) {
|
|
break label$1;
|
|
}
|
|
memcpy($1, $4, $0 << 1);
|
|
}
|
|
__stack_pointer = $5 + 96 | 0;
|
|
return;
|
|
}
|
|
celt_fatal(15848, 15951, 51);
|
|
abort();
|
|
}
|
|
celt_fatal(15972, 15951, 63);
|
|
abort();
|
|
}
|
|
celt_fatal(16006, 15951, 104);
|
|
abort();
|
|
}
|
|
function encode_multiframe_packet($0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0;
|
|
$9 = __stack_pointer - 304 | 0;
|
|
$12 = $9;
|
|
__stack_pointer = $9;
|
|
$14 = $2 - 1 | 0;
|
|
$10 = ($2 | 0) == 2 ? 3 : ($14 << 1) + 2 | 0;
|
|
if (!(HEAP32[$0 + 148 >> 2] | HEAP32[$0 + 164 >> 2] == -1)) {
|
|
$11 = (Math_imul(HEAP32[$0 + 160 >> 2], 3) | 0) / ((Math_imul(HEAP32[$0 + 144 >> 2], 24) | 0) / (Math_imul($2, $3) | 0) | 0) | 0;
|
|
$5 = ($5 | 0) > ($11 | 0) ? $11 : $5;
|
|
}
|
|
$10 = ($5 - $10 | 0) / ($2 | 0) | 0;
|
|
$10 = ($10 | 0) < 1276 ? $10 + 1 | 0 : 1276;
|
|
$15 = $9 - (Math_imul($10, $2) + 15 & -16) | 0;
|
|
__stack_pointer = $15;
|
|
opus_repacketizer_init($12);
|
|
$18 = HEAP32[$0 + 136 >> 2];
|
|
HEAP32[$0 + 136 >> 2] = HEAP32[$0 + 14224 >> 2];
|
|
$19 = HEAP32[$0 + 128 >> 2];
|
|
HEAP32[$0 + 128 >> 2] = HEAP32[$0 + 14240 >> 2];
|
|
$20 = HEAP32[$0 + 120 >> 2];
|
|
$9 = HEAP32[$0 + 14192 >> 2];
|
|
HEAP32[$0 + 120 >> 2] = $9;
|
|
$16 = HEAP32[$0 + 68 >> 2];
|
|
label$2 : {
|
|
if ($16) {
|
|
HEAP32[$0 + 120 >> 2] = 1;
|
|
break label$2;
|
|
}
|
|
HEAP32[$0 + 14232 >> 2] = $9;
|
|
}
|
|
label$4 : {
|
|
if (($2 | 0) >= 1) {
|
|
$9 = 0;
|
|
while (1) {
|
|
HEAP32[$0 + 68 >> 2] = 0;
|
|
HEAP32[$0 + 18132 >> 2] = ($9 | 0) < ($14 | 0);
|
|
if (!(!$6 | ($9 | 0) != ($14 | 0))) {
|
|
HEAP32[$0 + 136 >> 2] = 1002;
|
|
}
|
|
$13 = -3;
|
|
$11 = Math_imul($9, $10) + $15 | 0;
|
|
$17 = opus_encode_native($0, (Math_imul(HEAP32[$0 + 112 >> 2], Math_imul($3, $9)) << 2) + $1 | 0, $3, $11, $10, $7, 0, 0, 0, 0, 0, 0, $8);
|
|
if (($17 | 0) < 0) {
|
|
break label$4;
|
|
}
|
|
if ((opus_repacketizer_cat($12, $11, $17) | 0) < 0) {
|
|
break label$4;
|
|
}
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = opus_repacketizer_out_range_impl($12, 0, $2, $4, $5, 0, !HEAP32[$0 + 148 >> 2]);
|
|
if (($13 | 0) < 0) {
|
|
$13 = -3;
|
|
break label$4;
|
|
}
|
|
HEAP32[$0 + 128 >> 2] = $19;
|
|
HEAP32[$0 + 136 >> 2] = $18;
|
|
HEAP32[$0 + 120 >> 2] = $20;
|
|
HEAP32[$0 + 68 >> 2] = $16;
|
|
}
|
|
__stack_pointer = $12 + 304 | 0;
|
|
return $13;
|
|
}
|
|
function log10($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$2 = wasm2js_scratch_load_i32(1) | 0;
|
|
$3 = wasm2js_scratch_load_i32(0) | 0;
|
|
$5 = $2;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
if (($2 | 0) > 0 ? 1 : ($2 | 0) >= 0) {
|
|
$1 = $5;
|
|
if ($1 >>> 0 > 1048575) {
|
|
break label$4;
|
|
}
|
|
}
|
|
$2 = $5;
|
|
$1 = $2 & 2147483647;
|
|
if (!($1 | $3)) {
|
|
return -1 / ($0 * $0);
|
|
}
|
|
$1 = $5;
|
|
if (($1 | 0) > -1) {
|
|
break label$3;
|
|
}
|
|
return ($0 - $0) / 0;
|
|
}
|
|
if ($1 >>> 0 > 2146435071) {
|
|
break label$1;
|
|
}
|
|
$2 = 1072693248;
|
|
$9 = -1023;
|
|
if (($1 | 0) != 1072693248) {
|
|
$2 = $1;
|
|
break label$2;
|
|
}
|
|
if ($3) {
|
|
break label$2;
|
|
}
|
|
return 0;
|
|
}
|
|
wasm2js_scratch_store_f64(+($0 * 0x40000000000000));
|
|
$2 = wasm2js_scratch_load_i32(1) | 0;
|
|
$3 = wasm2js_scratch_load_i32(0) | 0;
|
|
$9 = -1077;
|
|
}
|
|
$1 = $2 + 614242 | 0;
|
|
$10 = +(($1 >>> 20 | 0) + $9 | 0);
|
|
$4 = $10 * .30102999566361177;
|
|
$1 = ($1 & 1048575) + 1072079006 | 0;
|
|
$2 = 0;
|
|
$1 = $2 | $1;
|
|
wasm2js_scratch_store_i32(0, $3 | 0);
|
|
wasm2js_scratch_store_i32(1, $1 | 0);
|
|
$0 = +wasm2js_scratch_load_f64() + -1;
|
|
$7 = $0 * ($0 * .5);
|
|
wasm2js_scratch_store_f64(+($0 - $7));
|
|
$1 = wasm2js_scratch_load_i32(1) | 0;
|
|
wasm2js_scratch_load_i32(0) | 0;
|
|
wasm2js_scratch_store_i32(0, 0);
|
|
wasm2js_scratch_store_i32(1, $1 | 0);
|
|
$8 = +wasm2js_scratch_load_f64();
|
|
$6 = $8 * .4342944818781689;
|
|
$11 = $4 + $6;
|
|
$12 = $6 + ($4 - $11);
|
|
$13 = $0 - $8 - $7;
|
|
$0 = $0 / ($0 + 2);
|
|
$6 = $0;
|
|
$4 = $0 * $0;
|
|
$0 = $4 * $4;
|
|
$0 = $13 + $6 * ($7 + ($0 * ($0 * ($0 * .15313837699209373 + .22222198432149784) + .3999999999940942) + $4 * ($0 * ($0 * ($0 * .14798198605116586 + .1818357216161805) + .2857142874366239) + .6666666666666735)));
|
|
$0 = $11 + ($12 + ($0 * .4342944818781689 + ($10 * 3.694239077158931e-13 + ($0 + $8) * 2.5082946711645275e-11)));
|
|
}
|
|
return $0;
|
|
}
|
|
function silk_LPC_fit($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
$7 = $3 - $2 | 0;
|
|
$10 = $7 - 1 | 0;
|
|
$11 = ($4 | 0) < 1;
|
|
label$1 : {
|
|
label$2 : {
|
|
while (1) {
|
|
$3 = 0;
|
|
$2 = 0;
|
|
if (!$11) {
|
|
while (1) {
|
|
$6 = HEAP32[($3 << 2) + $1 >> 2];
|
|
$8 = $6;
|
|
$6 = $6 >> 31;
|
|
$6 = $6 ^ $6 + $8;
|
|
$8 = $6;
|
|
$6 = ($2 | 0) < ($6 | 0);
|
|
$2 = $6 ? $8 : $2;
|
|
$5 = $6 ? $3 : $5;
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = ($7 | 0) == 1 ? ($2 & 1) + ($2 >> 1) | 0 : ($2 >> $10) + 1 >> 1;
|
|
if (($3 | 0) >= 32768) {
|
|
$3 = ($3 | 0) < 163838 ? $3 : 163838;
|
|
silk_bwexpander_32($1, $4, 65470 - ((($3 << 14) - 536854528 | 0) / (Math_imul($5 + 1 | 0, $3) >> 2) | 0) | 0);
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != 10) {
|
|
continue;
|
|
}
|
|
break label$2;
|
|
}
|
|
break;
|
|
}
|
|
if (($9 | 0) == 10) {
|
|
break label$2;
|
|
}
|
|
$3 = 0;
|
|
if (($4 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
$5 = ($7 | 0) != 1;
|
|
while (1) {
|
|
$2 = HEAP32[($3 << 2) + $1 >> 2];
|
|
$2 = $5 ? ($2 >> $10) + 1 >> 1 : ($2 & 1) + ($2 >> 1) | 0;
|
|
HEAP16[($3 << 1) + $0 >> 1] = $2;
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($4 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$3 = 0;
|
|
$9 = ($7 | 0) != 1;
|
|
while (1) {
|
|
$6 = ($3 << 2) + $1 | 0;
|
|
$5 = HEAP32[$6 >> 2];
|
|
$8 = ($3 << 1) + $0 | 0;
|
|
label$13 : {
|
|
if (!$9) {
|
|
$5 = ($5 & 1) + ($5 >> 1) | 0;
|
|
$2 = 32767;
|
|
if (($5 | 0) > 32767) {
|
|
break label$13;
|
|
}
|
|
$2 = ($5 | 0) > -32768 ? $5 : -32768;
|
|
break label$13;
|
|
}
|
|
$5 = $5 >> $10;
|
|
$2 = 32767;
|
|
if (($5 | 0) > 65534) {
|
|
break label$13;
|
|
}
|
|
$2 = $5 + 1 >> 1;
|
|
$2 = ($2 | 0) > -32768 ? $2 : -32768;
|
|
}
|
|
HEAP16[$8 >> 1] = $2;
|
|
HEAP32[$6 >> 2] = $2 << 16 >> 16 << $7;
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_control_audio_bandwidth($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0;
|
|
$2 = HEAP32[$0 + 4576 >> 2];
|
|
if (!$2) {
|
|
$2 = HEAP32[$0 + 32 >> 2];
|
|
}
|
|
$3 = $2 << 16;
|
|
if (!$3) {
|
|
$2 = HEAP32[$0 + 4572 >> 2];
|
|
$0 = HEAP32[$0 + 4556 >> 2];
|
|
return ((($0 | 0) > ($2 | 0) ? $2 : $0) | 0) / 1e3 | 0;
|
|
}
|
|
$3 = Math_imul($3 >> 16, 1e3);
|
|
$4 = HEAP32[$0 + 4556 >> 2];
|
|
$5 = HEAP32[$0 + 4564 >> 2];
|
|
if (!(HEAP32[$0 + 4568 >> 2] <= ($3 | 0) ? !(($3 | 0) > ($4 | 0) | ($5 | 0) < ($3 | 0)) : 0)) {
|
|
$2 = ($4 | 0) < ($5 | 0) ? $4 : $5;
|
|
$0 = HEAP32[$0 + 4568 >> 2];
|
|
return ((($0 | 0) < ($2 | 0) ? $2 : $0) | 0) / 1e3 | 0;
|
|
}
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
if (($4 | 0) >= 256) {
|
|
HEAP32[$0 + 28 >> 2] = 0;
|
|
}
|
|
label$7 : {
|
|
label$8 : {
|
|
if (HEAP32[$1 + 64 >> 2] ? 0 : !HEAP32[$0 + 4536 >> 2]) {
|
|
break label$8;
|
|
}
|
|
$5 = HEAP32[$0 + 4572 >> 2];
|
|
if (($5 | 0) < ($3 | 0)) {
|
|
label$11 : {
|
|
label$12 : {
|
|
if (HEAP32[$0 + 28 >> 2]) {
|
|
if (HEAP32[$1 + 64 >> 2]) {
|
|
break label$12;
|
|
}
|
|
if (($4 | 0) > 0) {
|
|
break label$11;
|
|
}
|
|
break label$7;
|
|
}
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
HEAP32[$0 + 20 >> 2] = 0;
|
|
HEAP32[$0 + 24 >> 2] = 256;
|
|
if (!HEAP32[$1 + 64 >> 2]) {
|
|
break label$11;
|
|
}
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = 0;
|
|
return ($2 | 0) == 16 ? 12 : 8;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = -2;
|
|
return $2;
|
|
}
|
|
if (($3 | 0) < ($5 | 0)) {
|
|
if (HEAP32[$1 + 64 >> 2]) {
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
HEAP32[$0 + 20 >> 2] = 0;
|
|
HEAP32[$0 + 24 >> 2] = 0;
|
|
HEAP32[$0 + 28 >> 2] = 1;
|
|
return ($2 | 0) == 8 ? 12 : 16;
|
|
}
|
|
if (!HEAP32[$0 + 28 >> 2]) {
|
|
break label$7;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = 1;
|
|
return $2;
|
|
}
|
|
if (HEAP32[$0 + 28 >> 2] > -1) {
|
|
break label$8;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = 1;
|
|
}
|
|
return $2;
|
|
}
|
|
HEAP32[$1 + 88 >> 2] = 1;
|
|
$0 = HEAP32[$1 + 56 >> 2];
|
|
HEAP32[$1 + 56 >> 2] = $0 - ((Math_imul($0, 5) | 0) / (HEAP32[$1 + 24 >> 2] + 5 | 0) | 0);
|
|
return $2;
|
|
}
|
|
function silk_A2NLSF_init($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
|
|
$4 = $3 << 2;
|
|
HEAP32[$4 + $1 >> 2] = 65536;
|
|
HEAP32[$2 + $4 >> 2] = 65536;
|
|
$4 = 0;
|
|
label$1 : {
|
|
if (($3 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$5 = $4 << 2;
|
|
$6 = ($3 + $4 << 2) + $0 | 0;
|
|
$7 = (($4 ^ -1) + $3 << 2) + $0 | 0;
|
|
HEAP32[$5 + $1 >> 2] = 0 - (HEAP32[$6 >> 2] + HEAP32[$7 >> 2] | 0);
|
|
HEAP32[$2 + $5 >> 2] = HEAP32[$6 >> 2] - HEAP32[$7 >> 2];
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($3 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
$4 = $3;
|
|
while (1) {
|
|
$0 = $4 - 1 | 0;
|
|
$5 = $0 << 2;
|
|
$6 = $5 + $1 | 0;
|
|
$7 = $6;
|
|
$8 = HEAP32[$6 >> 2];
|
|
$6 = $4 << 2;
|
|
HEAP32[$7 >> 2] = $8 - HEAP32[$6 + $1 >> 2];
|
|
$5 = $2 + $5 | 0;
|
|
HEAP32[$5 >> 2] = HEAP32[$5 >> 2] + HEAP32[$2 + $6 >> 2];
|
|
$5 = ($4 | 0) > 1;
|
|
$4 = $0;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$7 = 2;
|
|
if (($3 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$4 = $3;
|
|
if (($7 | 0) < ($4 | 0)) {
|
|
while (1) {
|
|
$0 = ($4 << 2) + $1 | 0;
|
|
$5 = $0 - 8 | 0;
|
|
HEAP32[$5 >> 2] = HEAP32[$5 >> 2] - HEAP32[$0 >> 2];
|
|
$4 = $4 - 1 | 0;
|
|
if (($7 | 0) < ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = 2;
|
|
$4 = ($7 << 2) + $1 | 0;
|
|
$0 = $4 - 8 | 0;
|
|
HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - (HEAP32[$4 >> 2] << 1);
|
|
$4 = ($3 | 0) != ($7 | 0);
|
|
$7 = $7 + 1 | 0;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
while (1) {
|
|
$4 = $3;
|
|
if (($6 | 0) < ($4 | 0)) {
|
|
while (1) {
|
|
$0 = ($4 << 2) + $2 | 0;
|
|
$5 = $0 - 8 | 0;
|
|
HEAP32[$5 >> 2] = HEAP32[$5 >> 2] - HEAP32[$0 >> 2];
|
|
$4 = $4 - 1 | 0;
|
|
if (($6 | 0) < ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = ($6 << 2) + $2 | 0;
|
|
$0 = $4 - 8 | 0;
|
|
HEAP32[$0 >> 2] = HEAP32[$0 >> 2] - (HEAP32[$4 >> 2] << 1);
|
|
$4 = ($3 | 0) != ($6 | 0);
|
|
$6 = $6 + 1 | 0;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function resampler_basic_direct_double($0, $1, $2, $3, $4, $5) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$5 = $5 | 0;
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $23 = 0, $24 = 0;
|
|
$1 = $1 << 2;
|
|
$16 = $1 + HEAP32[$0 + 64 >> 2] | 0;
|
|
$9 = HEAP32[$16 >> 2];
|
|
$17 = HEAP32[$0 + 60 >> 2] + $1 | 0;
|
|
$6 = HEAP32[$17 >> 2];
|
|
$18 = HEAP32[$3 >> 2];
|
|
label$1 : {
|
|
if (($6 | 0) >= ($18 | 0)) {
|
|
break label$1;
|
|
}
|
|
$13 = HEAP32[$0 + 12 >> 2];
|
|
$20 = HEAP32[$0 + 40 >> 2];
|
|
$21 = HEAP32[$0 + 36 >> 2];
|
|
$22 = HEAP32[$0 + 92 >> 2];
|
|
$23 = HEAP32[$0 + 76 >> 2];
|
|
$3 = HEAP32[$5 >> 2];
|
|
$19 = ($3 | 0) > 0 ? $3 : 0;
|
|
$14 = HEAP32[$0 + 24 >> 2];
|
|
$24 = ($14 | 0) < 1;
|
|
while (1) {
|
|
if (($7 | 0) == ($19 | 0)) {
|
|
$7 = $19;
|
|
break label$1;
|
|
}
|
|
$15 = 0;
|
|
label$4 : {
|
|
if ($24) {
|
|
$10 = 0;
|
|
$11 = 0;
|
|
$12 = 0;
|
|
break label$4;
|
|
}
|
|
$3 = ($6 << 2) + $2 | 0;
|
|
$1 = (Math_imul($9, $14) << 2) + $23 | 0;
|
|
$5 = 0;
|
|
$12 = 0;
|
|
$11 = 0;
|
|
$10 = 0;
|
|
while (1) {
|
|
$0 = $5 << 2;
|
|
$10 = $10 + +Math_fround(HEAPF32[$1 + $0 >> 2] * HEAPF32[$0 + $3 >> 2]);
|
|
$8 = $0 | 12;
|
|
$15 = $15 + +Math_fround(HEAPF32[$8 + $1 >> 2] * HEAPF32[$3 + $8 >> 2]);
|
|
$8 = $0 | 8;
|
|
$12 = $12 + +Math_fround(HEAPF32[$8 + $1 >> 2] * HEAPF32[$3 + $8 >> 2]);
|
|
$0 = $0 | 4;
|
|
$11 = $11 + +Math_fround(HEAPF32[$1 + $0 >> 2] * HEAPF32[$0 + $3 >> 2]);
|
|
$5 = $5 + 4 | 0;
|
|
if (($14 | 0) > ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[(Math_imul($7, $22) << 2) + $4 >> 2] = $10 + $11 + $12 + $15;
|
|
$0 = $9 + $20 | 0;
|
|
$9 = $0 - ($0 >>> 0 < $13 >>> 0 ? 0 : $13) | 0;
|
|
$7 = $7 + 1 | 0;
|
|
$6 = ($6 + $21 | 0) + ($0 >>> 0 >= $13 >>> 0) | 0;
|
|
if (($18 | 0) > ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$17 >> 2] = $6;
|
|
HEAP32[$16 >> 2] = $9;
|
|
return $7 | 0;
|
|
}
|
|
function silk_find_LPC_FLP($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = Math_fround(0), $9 = Math_fround(0), $10 = 0, $11 = 0, $12 = 0;
|
|
$4 = __stack_pointer - 1696 | 0;
|
|
__stack_pointer = $4;
|
|
HEAP8[$0 + 4767 | 0] = 4;
|
|
$6 = HEAP32[$0 + 4640 >> 2];
|
|
$7 = $6 + HEAP32[$0 + 4588 >> 2] | 0;
|
|
$8 = silk_burg_modified_FLP($4 + 1632 | 0, $2, $3, $7, HEAP32[$0 + 4580 >> 2], $6);
|
|
label$1 : {
|
|
if (HEAP32[$0 + 4664 >> 2] | !HEAP32[$0 + 4632 >> 2] | HEAP32[$0 + 4580 >> 2] != 4) {
|
|
break label$1;
|
|
}
|
|
$5 = 3;
|
|
$3 = silk_burg_modified_FLP($4 + 1536 | 0, ($7 << 3) + $2 | 0, $3, $7, 2, HEAP32[$0 + 4640 >> 2]);
|
|
silk_A2NLSF_FLP($1, $4 + 1536 | 0, HEAP32[$0 + 4640 >> 2]);
|
|
$10 = $0 + 4500 | 0;
|
|
$11 = $7 << 1;
|
|
$8 = Math_fround($8 - $3);
|
|
$9 = Math_fround(3.4028234663852886e+38);
|
|
while (1) {
|
|
$6 = $5;
|
|
silk_interpolate($4 + 1600 | 0, $10, $1, $6, HEAP32[$0 + 4640 >> 2]);
|
|
silk_NLSF2A_FLP($4 + 1536 | 0, $4 + 1600 | 0, HEAP32[$0 + 4640 >> 2], HEAP32[$0 + 5092 >> 2]);
|
|
silk_LPC_analysis_filter_FLP($4, $4 + 1536 | 0, $2, $11, HEAP32[$0 + 4640 >> 2]);
|
|
$5 = HEAP32[$0 + 4640 >> 2];
|
|
$12 = silk_energy_FLP(($5 << 2) + $4 | 0, $7 - $5 | 0);
|
|
$5 = HEAP32[$0 + 4640 >> 2];
|
|
$3 = Math_fround($12 + silk_energy_FLP((($5 << 2) + $4 | 0) + ($7 << 2) | 0, $7 - $5 | 0));
|
|
label$3 : {
|
|
if (!($8 > $3 ^ 1)) {
|
|
HEAP8[$0 + 4767 | 0] = $6;
|
|
$8 = $3;
|
|
break label$3;
|
|
}
|
|
if ($3 > $9) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$5 = $6 - 1 | 0;
|
|
$9 = $3;
|
|
if ($6) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$5 : {
|
|
if (HEAPU8[$0 + 4767 | 0] == 4) {
|
|
silk_A2NLSF_FLP($1, $4 + 1632 | 0, HEAP32[$0 + 4640 >> 2]);
|
|
if (HEAPU8[$0 + 4767 | 0] == 4) {
|
|
break label$5;
|
|
}
|
|
}
|
|
if (HEAP32[$0 + 4580 >> 2] == 4 ? !(HEAP32[$0 + 4664 >> 2] | !HEAP32[$0 + 4632 >> 2]) : 0) {
|
|
break label$5;
|
|
}
|
|
celt_fatal(16554, 16719, 103);
|
|
abort();
|
|
}
|
|
__stack_pointer = $4 + 1696 | 0;
|
|
}
|
|
function ec_enc_icdf($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0;
|
|
$4 = HEAP32[$0 + 28 >> 2];
|
|
$3 = $4 >>> $3 | 0;
|
|
$5 = $0;
|
|
label$1 : {
|
|
if (($1 | 0) >= 1) {
|
|
$1 = $1 + $2 | 0;
|
|
$2 = $1 - 1 | 0;
|
|
HEAP32[$0 + 32 >> 2] = (HEAP32[$0 + 32 >> 2] + $4 | 0) - Math_imul(HEAPU8[$2 | 0], $3);
|
|
$3 = Math_imul(HEAPU8[$2 | 0] - HEAPU8[$1 | 0] | 0, $3);
|
|
break label$1;
|
|
}
|
|
$3 = $4 - Math_imul(HEAPU8[$1 + $2 | 0], $3) | 0;
|
|
}
|
|
HEAP32[$5 + 28 >> 2] = $3;
|
|
if ($3 >>> 0 <= 8388608) {
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
while (1) {
|
|
$5 = $1 >>> 23 | 0;
|
|
label$5 : {
|
|
if (($5 | 0) != 255) {
|
|
$3 = $1 >>> 31 | 0;
|
|
$2 = HEAP32[$0 + 40 >> 2];
|
|
if (($2 | 0) >= 0) {
|
|
$1 = -1;
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $4 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $4 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $4 | 0] = $2 + $3;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $1;
|
|
}
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if ($1) {
|
|
$4 = $3 - 1 | 0;
|
|
while (1) {
|
|
$3 = -1;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $2 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $2 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $2 | 0] = $4;
|
|
$3 = 0;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
}
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $5 & 255;
|
|
$3 = HEAP32[$0 + 28 >> 2];
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 36 >> 2] + 1;
|
|
}
|
|
$3 = $3 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $3;
|
|
$1 = $1 << 8 & 2147483392;
|
|
HEAP32[$0 + 32 >> 2] = $1;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + 8;
|
|
if ($3 >>> 0 < 8388609) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function exp($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$1 = wasm2js_scratch_load_i32(1) | 0;
|
|
$4 = wasm2js_scratch_load_i32(0) | 0;
|
|
$5 = $1 >>> 31 | 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
$3 = $0;
|
|
label$5 : {
|
|
label$6 : {
|
|
$6 = $1;
|
|
$1 = $6 & 2147483647;
|
|
label$7 : {
|
|
if ($1 >>> 0 >= 1082532651) {
|
|
$4 = __DOUBLE_BITS($0);
|
|
$6 = $4;
|
|
$1 = i64toi32_i32$HIGH_BITS;
|
|
$4 = $1 & 2147483647;
|
|
$1 = $6;
|
|
if (($4 | 0) == 2146435072 & ($1 | 0) != 0 | $4 >>> 0 > 2146435072) {
|
|
return $0;
|
|
}
|
|
if (!($0 > 709.782712893384 ^ 1)) {
|
|
return $0 * 8.98846567431158e+307;
|
|
}
|
|
if (!($0 < -745.1332191019411) | $0 < -708.3964185322641 ^ 1) {
|
|
break label$7;
|
|
}
|
|
break label$2;
|
|
}
|
|
if ($1 >>> 0 < 1071001155) {
|
|
break label$4;
|
|
}
|
|
if ($1 >>> 0 < 1072734898) {
|
|
break label$6;
|
|
}
|
|
}
|
|
$2 = $0 * 1.4426950408889634 + HEAPF64[($5 << 3) + 10928 >> 3];
|
|
if (Math_abs($2) < 2147483648) {
|
|
$1 = ~~$2;
|
|
break label$5;
|
|
}
|
|
$1 = -2147483648;
|
|
break label$5;
|
|
}
|
|
$1 = ($5 ^ 1) - $5 | 0;
|
|
}
|
|
$2 = +($1 | 0);
|
|
$0 = $3 + $2 * -.6931471803691238;
|
|
$7 = $2 * 1.9082149292705877e-10;
|
|
$3 = $0 - $7;
|
|
break label$3;
|
|
}
|
|
if ($1 >>> 0 <= 1043333120) {
|
|
break label$1;
|
|
}
|
|
$1 = 0;
|
|
$3 = $0;
|
|
}
|
|
$2 = $3 * $3;
|
|
$2 = $3 - $2 * ($2 * ($2 * ($2 * ($2 * 4.1381367970572385e-8 + -16533902205465252e-22) + 6613756321437934e-20) + -.0027777777777015593) + .16666666666666602);
|
|
$2 = $0 + ($3 * $2 / (2 - $2) - $7) + 1;
|
|
if (!$1) {
|
|
break label$2;
|
|
}
|
|
$2 = scalbn($2, $1);
|
|
}
|
|
return $2;
|
|
}
|
|
return $0 + 1;
|
|
}
|
|
function memmove($0, $1, $2) {
|
|
var $3 = 0;
|
|
label$1 : {
|
|
if (($0 | 0) == ($1 | 0)) {
|
|
break label$1;
|
|
}
|
|
if (($1 - $0 | 0) - $2 >>> 0 <= 0 - ($2 << 1) >>> 0) {
|
|
return memcpy($0, $1, $2);
|
|
}
|
|
$3 = ($0 ^ $1) & 3;
|
|
label$3 : {
|
|
label$4 : {
|
|
if ($0 >>> 0 < $1 >>> 0) {
|
|
if ($3) {
|
|
$3 = $0;
|
|
break label$3;
|
|
}
|
|
if (!($0 & 3)) {
|
|
$3 = $0;
|
|
break label$4;
|
|
}
|
|
$3 = $0;
|
|
while (1) {
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
HEAP8[$3 | 0] = HEAPU8[$1 | 0];
|
|
$1 = $1 + 1 | 0;
|
|
$2 = $2 - 1 | 0;
|
|
$3 = $3 + 1 | 0;
|
|
if ($3 & 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$4;
|
|
}
|
|
label$9 : {
|
|
if ($3) {
|
|
break label$9;
|
|
}
|
|
if ($0 + $2 & 3) {
|
|
while (1) {
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
$2 = $2 - 1 | 0;
|
|
$3 = $2 + $0 | 0;
|
|
HEAP8[$3 | 0] = HEAPU8[$1 + $2 | 0];
|
|
if ($3 & 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ($2 >>> 0 <= 3) {
|
|
break label$9;
|
|
}
|
|
while (1) {
|
|
$2 = $2 - 4 | 0;
|
|
HEAP32[$2 + $0 >> 2] = HEAP32[$1 + $2 >> 2];
|
|
if ($2 >>> 0 > 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$2 = $2 - 1 | 0;
|
|
HEAP8[$2 + $0 | 0] = HEAPU8[$1 + $2 | 0];
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if ($2 >>> 0 <= 3) {
|
|
break label$3;
|
|
}
|
|
while (1) {
|
|
HEAP32[$3 >> 2] = HEAP32[$1 >> 2];
|
|
$1 = $1 + 4 | 0;
|
|
$3 = $3 + 4 | 0;
|
|
$2 = $2 - 4 | 0;
|
|
if ($2 >>> 0 > 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
HEAP8[$3 | 0] = HEAPU8[$1 | 0];
|
|
$3 = $3 + 1 | 0;
|
|
$1 = $1 + 1 | 0;
|
|
$2 = $2 - 1 | 0;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $0;
|
|
}
|
|
function silk_resampler_private_up2_HQ($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0;
|
|
if (($3 | 0) >= 1) {
|
|
$9 = HEAP32[$0 + 20 >> 2];
|
|
$7 = HEAP32[$0 + 16 >> 2];
|
|
$4 = HEAP32[$0 + 12 >> 2];
|
|
$6 = HEAP32[$0 + 8 >> 2];
|
|
$8 = HEAP32[$0 + 4 >> 2];
|
|
$5 = HEAP32[$0 >> 2];
|
|
while (1) {
|
|
$13 = HEAP16[($12 << 1) + $2 >> 1] << 10;
|
|
$10 = $13 - $5 | 0;
|
|
$10 = (Math_imul($10 & 65535, 1746) >>> 16 | 0) + Math_imul($10 >> 16, 1746) | 0;
|
|
$14 = $10 + $5 | 0;
|
|
$5 = $14 - $8 | 0;
|
|
$15 = (Math_imul($5 & 65535, 14986) >>> 16 | 0) + Math_imul($5 >> 16, 14986) | 0;
|
|
$5 = $15 + $8 | 0;
|
|
$8 = $5 - $6 | 0;
|
|
$11 = $12 << 2;
|
|
$5 = (Math_imul($8 >> 16, -26453) + (Math_imul($8 & 65535, -26453) >> 16) | 0) + $5 | 0;
|
|
$6 = ($5 >> 9) + 1 >> 1;
|
|
HEAP16[$11 + $1 >> 1] = ($5 | 0) > 33553919 ? 32767 : ($6 | 0) > -32768 ? $6 : -32768;
|
|
$18 = ($11 | 2) + $1 | 0;
|
|
$6 = $13 - $4 | 0;
|
|
$11 = (Math_imul($6 & 65535, 6854) >>> 16 | 0) + Math_imul($6 >> 16, 6854) | 0;
|
|
$16 = $11 + $4 | 0;
|
|
$4 = $16 - $7 | 0;
|
|
$17 = (Math_imul($4 & 65535, 25769) >>> 16 | 0) + Math_imul($4 >> 16, 25769) | 0;
|
|
$4 = $17 + $7 | 0;
|
|
$7 = $4 - $9 | 0;
|
|
$4 = (Math_imul($7 >> 16, -9994) + (Math_imul($7 & 65535, -9994) >> 16) | 0) + $4 | 0;
|
|
$9 = ($4 >> 9) + 1 >> 1;
|
|
HEAP16[$18 >> 1] = ($4 | 0) > 33553919 ? 32767 : ($9 | 0) > -32768 ? $9 : -32768;
|
|
$9 = $4 + $7 | 0;
|
|
$6 = $5 + $8 | 0;
|
|
$7 = $16 + $17 | 0;
|
|
$8 = $14 + $15 | 0;
|
|
$4 = $13 + $11 | 0;
|
|
$5 = $13 + $10 | 0;
|
|
$12 = $12 + 1 | 0;
|
|
if (($12 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$0 + 20 >> 2] = $9;
|
|
HEAP32[$0 + 16 >> 2] = $7;
|
|
HEAP32[$0 + 12 >> 2] = $4;
|
|
HEAP32[$0 + 8 >> 2] = $6;
|
|
HEAP32[$0 + 4 >> 2] = $8;
|
|
HEAP32[$0 >> 2] = $5;
|
|
}
|
|
}
|
|
function ec_encode_bin($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
$4 = -1 << $3;
|
|
$5 = HEAP32[$0 + 28 >> 2];
|
|
$3 = $5 >>> $3 | 0;
|
|
$6 = $0;
|
|
label$1 : {
|
|
if ($1) {
|
|
HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] + (Math_imul($1 + $4 | 0, $3) + $5 | 0);
|
|
$3 = Math_imul($2 - $1 | 0, $3);
|
|
break label$1;
|
|
}
|
|
$3 = Math_imul($2 + $4 | 0, $3) + $5 | 0;
|
|
}
|
|
HEAP32[$6 + 28 >> 2] = $3;
|
|
if ($3 >>> 0 <= 8388608) {
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
while (1) {
|
|
$5 = $1 >>> 23 | 0;
|
|
label$5 : {
|
|
if (($5 | 0) != 255) {
|
|
$3 = $1 >>> 31 | 0;
|
|
$2 = HEAP32[$0 + 40 >> 2];
|
|
if (($2 | 0) >= 0) {
|
|
$1 = -1;
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $4 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $4 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $4 | 0] = $2 + $3;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $1;
|
|
}
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if ($1) {
|
|
$4 = $3 - 1 | 0;
|
|
while (1) {
|
|
$3 = -1;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $2 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $2 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $2 | 0] = $4;
|
|
$3 = 0;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
}
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $5 & 255;
|
|
$3 = HEAP32[$0 + 28 >> 2];
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 36 >> 2] + 1;
|
|
}
|
|
$3 = $3 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $3;
|
|
$1 = $1 << 8 & 2147483392;
|
|
HEAP32[$0 + 32 >> 2] = $1;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + 8;
|
|
if ($3 >>> 0 < 8388609) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function ec_encode($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
$5 = HEAP32[$0 + 28 >> 2];
|
|
$4 = ($5 >>> 0) / ($3 >>> 0) | 0;
|
|
$6 = $0;
|
|
label$1 : {
|
|
if ($1) {
|
|
HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] + (Math_imul($1 - $3 | 0, $4) + $5 | 0);
|
|
$3 = Math_imul($2 - $1 | 0, $4);
|
|
break label$1;
|
|
}
|
|
$3 = Math_imul($2 - $3 | 0, $4) + $5 | 0;
|
|
}
|
|
HEAP32[$6 + 28 >> 2] = $3;
|
|
if ($3 >>> 0 <= 8388608) {
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
while (1) {
|
|
$5 = $1 >>> 23 | 0;
|
|
label$5 : {
|
|
if (($5 | 0) != 255) {
|
|
$3 = $1 >>> 31 | 0;
|
|
$4 = HEAP32[$0 + 40 >> 2];
|
|
if (($4 | 0) >= 0) {
|
|
$1 = -1;
|
|
$2 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $2 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $2 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $2 | 0] = $3 + $4;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $1;
|
|
}
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if ($1) {
|
|
$2 = $3 - 1 | 0;
|
|
while (1) {
|
|
$3 = -1;
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $4 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $4 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $4 | 0] = $2;
|
|
$3 = 0;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
}
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $5 & 255;
|
|
$3 = HEAP32[$0 + 28 >> 2];
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 36 >> 2] + 1;
|
|
}
|
|
$3 = $3 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $3;
|
|
$1 = $1 << 8 & 2147483392;
|
|
HEAP32[$0 + 32 >> 2] = $1;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + 8;
|
|
if ($3 >>> 0 < 8388609) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_setup_resamplers($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
$2 = __stack_pointer - 304 | 0;
|
|
$8 = $2;
|
|
__stack_pointer = $2;
|
|
$3 = HEAP32[$0 + 4576 >> 2];
|
|
label$1 : {
|
|
if (($3 | 0) == ($1 | 0)) {
|
|
$5 = 0;
|
|
if (HEAP32[$0 + 4560 >> 2] == HEAP32[$0 + 4556 >> 2]) {
|
|
break label$1;
|
|
}
|
|
}
|
|
if (!$3) {
|
|
$5 = silk_resampler_init($0 + 5776 | 0, HEAP32[$0 + 4556 >> 2], Math_imul($1, 1e3), 1);
|
|
break label$1;
|
|
}
|
|
$9 = Math_imul(HEAP32[$0 + 4580 >> 2], 10) + 5 | 0;
|
|
$6 = Math_imul($9, $3);
|
|
$5 = Math_imul($1, $9);
|
|
$7 = $2 - (((($5 | 0) < ($6 | 0) ? $6 : $5) << 1) + 15 & -16) | 0;
|
|
$10 = $7;
|
|
__stack_pointer = $7;
|
|
if (($6 | 0) >= 1) {
|
|
$2 = $6;
|
|
while (1) {
|
|
$3 = $2 - 1 | 0;
|
|
$11 = ($3 << 1) + $7 | 0;
|
|
$4 = lrintf(HEAPF32[(($3 << 2) + $0 | 0) + 7180 >> 2]);
|
|
$4 = ($4 | 0) > -32768 ? $4 : -32768;
|
|
HEAP16[$11 >> 1] = ($4 | 0) < 32767 ? $4 : 32767;
|
|
$4 = ($2 | 0) > 1;
|
|
$2 = $3;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = silk_resampler_init($8, Math_imul(HEAP16[$0 + 4576 >> 1], 1e3), HEAP32[$0 + 4556 >> 2], 0);
|
|
$4 = Math_imul(HEAP32[$0 + 4556 >> 2] / 1e3 | 0, $9);
|
|
$2 = $10 - (($4 << 1) + 15 & -16) | 0;
|
|
__stack_pointer = $2;
|
|
$6 = silk_resampler($8, $2, $7, $6) + $3 | 0;
|
|
$3 = $0 + 5776 | 0;
|
|
$1 = $6 + silk_resampler_init($3, HEAP32[$0 + 4556 >> 2], Math_imul($1 << 16 >> 16, 1e3), 1) | 0;
|
|
$4 = silk_resampler($3, $7, $2, $4);
|
|
if (($5 | 0) >= 1) {
|
|
while (1) {
|
|
$2 = $5 - 1 | 0;
|
|
HEAPF32[(($2 << 2) + $0 | 0) + 7180 >> 2] = HEAP16[($2 << 1) + $7 >> 1];
|
|
$3 = ($5 | 0) > 1;
|
|
$5 = $2;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = $1 + $4 | 0;
|
|
}
|
|
HEAP32[$0 + 4560 >> 2] = HEAP32[$0 + 4556 >> 2];
|
|
__stack_pointer = $8 + 304 | 0;
|
|
return $5;
|
|
}
|
|
function compute_mdcts($0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
var $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = Math_fround(0);
|
|
$10 = HEAP32[$0 + 44 >> 2];
|
|
$12 = HEAP32[$0 + 4 >> 2];
|
|
if ($1) {
|
|
$15 = HEAP32[$0 + 36 >> 2];
|
|
} else {
|
|
$10 = $10 << $6;
|
|
$1 = 1;
|
|
$15 = HEAP32[$0 + 36 >> 2] - $6 | 0;
|
|
}
|
|
$16 = ($5 | 0) > 1 ? $5 : 1;
|
|
$17 = $0 - -64 | 0;
|
|
$9 = Math_imul($1, $10);
|
|
$18 = $12 + $9 | 0;
|
|
while (1) {
|
|
if (($1 | 0) >= 1) {
|
|
$11 = Math_imul($9, $13);
|
|
$14 = (Math_imul($13, $18) << 2) + $2 | 0;
|
|
$6 = 0;
|
|
while (1) {
|
|
clt_mdct_forward_c($17, (Math_imul($6, $10) << 2) + $14 | 0, ($6 + $11 << 2) + $3 | 0, HEAP32[$0 + 60 >> 2], $12, $15, $1, $8);
|
|
$6 = $6 + 1 | 0;
|
|
if (($6 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$13 = $13 + 1 | 0;
|
|
if (($16 | 0) != ($13 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!(($4 | 0) != 1 | ($5 | 0) != 2 | ($9 | 0) < 1)) {
|
|
$6 = 0;
|
|
while (1) {
|
|
$1 = ($6 << 2) + $3 | 0;
|
|
HEAPF32[$1 >> 2] = Math_fround(HEAPF32[$1 >> 2] * Math_fround(.5)) + Math_fround(HEAPF32[($6 + $9 << 2) + $3 >> 2] * Math_fround(.5));
|
|
$6 = $6 + 1 | 0;
|
|
if (($9 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($7 | 0) != 1) {
|
|
$10 = ($4 | 0) > 1 ? $4 : 1;
|
|
$11 = ($9 | 0) / ($7 | 0) | 0;
|
|
$12 = $9 - $11 << 2;
|
|
$19 = Math_fround($7 | 0);
|
|
$0 = 0;
|
|
while (1) {
|
|
$14 = Math_imul($0, $9);
|
|
$6 = 0;
|
|
if (($11 | 0) >= 1) {
|
|
while (1) {
|
|
$1 = ($6 + $14 << 2) + $3 | 0;
|
|
HEAPF32[$1 >> 2] = HEAPF32[$1 >> 2] * $19;
|
|
$6 = $6 + 1 | 0;
|
|
if (($11 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memset(($11 + $14 << 2) + $3 | 0, 0, $12);
|
|
$0 = $0 + 1 | 0;
|
|
if (($10 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function celt_preemphasis($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = Math_fround(0), $9 = Math_fround(0), $10 = 0, $11 = Math_fround(0), $12 = Math_fround(0);
|
|
$9 = HEAPF32[$6 >> 2];
|
|
$11 = HEAPF32[$5 >> 2];
|
|
label$1 : {
|
|
if (!(($4 | 0) != 1 | $7 | HEAPF32[$5 + 4 >> 2] != Math_fround(0))) {
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
$8 = Math_fround(HEAPF32[(Math_imul($3, $5) << 2) + $0 >> 2] * Math_fround(32768));
|
|
HEAPF32[($5 << 2) + $1 >> 2] = $8 - $9;
|
|
$9 = Math_fround($11 * $8);
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
$10 = ($2 | 0) / ($4 | 0) | 0;
|
|
if (($4 | 0) != 1) {
|
|
memset($1, 0, $2 << 2);
|
|
}
|
|
label$5 : {
|
|
if (($10 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
HEAPF32[(Math_imul($4, $5) << 2) + $1 >> 2] = HEAPF32[(Math_imul($3, $5) << 2) + $0 >> 2] * Math_fround(32768);
|
|
$5 = $5 + 1 | 0;
|
|
if (($10 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!$7 | ($10 | 0) < 1) {
|
|
break label$5;
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
$0 = (Math_imul($4, $5) << 2) + $1 | 0;
|
|
$7 = $0;
|
|
$8 = HEAPF32[$0 >> 2];
|
|
$0 = $8 > Math_fround(65536);
|
|
$3 = ($0 ? Math_fround(65536) : $8) < Math_fround(-65536);
|
|
$12 = $3 ? Math_fround(-65536) : Math_fround(65536);
|
|
HEAPF32[$7 >> 2] = $0 ? $12 : $3 ? $12 : $8;
|
|
$5 = $5 + 1 | 0;
|
|
if (($10 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = 0;
|
|
while (1) {
|
|
$0 = ($5 << 2) + $1 | 0;
|
|
$8 = HEAPF32[$0 >> 2];
|
|
HEAPF32[$0 >> 2] = $8 - $9;
|
|
$9 = Math_fround($11 * $8);
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$6 >> 2] = $9;
|
|
}
|
|
function silk_LTP_analysis_filter_FLP($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = Math_fround(0), $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = Math_fround(0);
|
|
$9 = __stack_pointer - 32 | 0;
|
|
if (($6 | 0) >= 1) {
|
|
$14 = $5 + $7 | 0;
|
|
$15 = ($14 | 0) < 1;
|
|
while (1) {
|
|
$7 = $13 << 2;
|
|
$16 = HEAPF32[$7 + $4 >> 2];
|
|
$11 = HEAP32[$3 + $7 >> 2];
|
|
$7 = Math_imul($13, 20) + $2 | 0;
|
|
HEAP32[$9 + 16 >> 2] = HEAP32[$7 + 16 >> 2];
|
|
$12 = HEAP32[$7 + 4 >> 2];
|
|
$10 = HEAP32[$7 >> 2];
|
|
HEAP32[$9 >> 2] = $10;
|
|
HEAP32[$9 + 4 >> 2] = $12;
|
|
$10 = HEAP32[$7 + 12 >> 2];
|
|
$12 = HEAP32[$7 + 8 >> 2];
|
|
HEAP32[$9 + 8 >> 2] = $12;
|
|
HEAP32[$9 + 12 >> 2] = $10;
|
|
if (!$15) {
|
|
$7 = $1 - ($11 << 2) | 0;
|
|
$12 = 0;
|
|
while (1) {
|
|
$10 = $12 << 2;
|
|
$11 = $10 + $0 | 0;
|
|
$10 = $1 + $10 | 0;
|
|
$8 = HEAPF32[$10 >> 2];
|
|
$10 = HEAP32[$10 >> 2];
|
|
HEAP32[$11 >> 2] = $10;
|
|
$8 = Math_fround($8 - Math_fround(HEAPF32[$9 >> 2] * HEAPF32[$7 + 8 >> 2]));
|
|
HEAPF32[$11 >> 2] = $8;
|
|
$8 = Math_fround($8 - Math_fround(HEAPF32[$9 + 4 >> 2] * HEAPF32[$7 + 4 >> 2]));
|
|
HEAPF32[$11 >> 2] = $8;
|
|
$8 = Math_fround($8 - Math_fround(HEAPF32[$9 + 8 >> 2] * HEAPF32[$7 >> 2]));
|
|
HEAPF32[$11 >> 2] = $8;
|
|
$8 = Math_fround($8 - Math_fround(HEAPF32[$9 + 12 >> 2] * HEAPF32[$7 - 4 >> 2]));
|
|
HEAPF32[$11 >> 2] = $8;
|
|
HEAPF32[$11 >> 2] = $16 * Math_fround($8 - Math_fround(HEAPF32[$9 + 16 >> 2] * HEAPF32[$7 - 8 >> 2]));
|
|
$7 = $7 + 4 | 0;
|
|
$12 = $12 + 1 | 0;
|
|
if (($14 | 0) != ($12 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = ($5 << 2) + $1 | 0;
|
|
$0 = ($14 << 2) + $0 | 0;
|
|
$13 = $13 + 1 | 0;
|
|
if (($13 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function __stdio_write($0, $1, $2) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
$3 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $3;
|
|
$4 = HEAP32[$0 + 28 >> 2];
|
|
HEAP32[$3 + 16 >> 2] = $4;
|
|
$5 = HEAP32[$0 + 20 >> 2];
|
|
HEAP32[$3 + 28 >> 2] = $2;
|
|
HEAP32[$3 + 24 >> 2] = $1;
|
|
$1 = $5 - $4 | 0;
|
|
HEAP32[$3 + 20 >> 2] = $1;
|
|
$8 = $1 + $2 | 0;
|
|
$9 = 2;
|
|
$1 = $3 + 16 | 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
if (!__wasi_syscall_ret(__wasi_fd_write(HEAP32[$0 + 60 >> 2], $3 + 16 | 0, 2, $3 + 12 | 0) | 0)) {
|
|
while (1) {
|
|
$4 = HEAP32[$3 + 12 >> 2];
|
|
if (($8 | 0) == ($4 | 0)) {
|
|
break label$3;
|
|
}
|
|
if (($4 | 0) <= -1) {
|
|
break label$2;
|
|
}
|
|
$6 = HEAP32[$1 + 4 >> 2];
|
|
$5 = $6 >>> 0 < $4 >>> 0;
|
|
$7 = ($5 << 3) + $1 | 0;
|
|
$6 = $4 - ($5 ? $6 : 0) | 0;
|
|
HEAP32[$7 >> 2] = $6 + HEAP32[$7 >> 2];
|
|
$7 = ($5 ? 12 : 4) + $1 | 0;
|
|
HEAP32[$7 >> 2] = HEAP32[$7 >> 2] - $6;
|
|
$8 = $8 - $4 | 0;
|
|
$1 = $5 ? $1 + 8 | 0 : $1;
|
|
$9 = $9 - $5 | 0;
|
|
if (!__wasi_syscall_ret(__wasi_fd_write(HEAP32[$0 + 60 >> 2], $1 | 0, $9 | 0, $3 + 12 | 0) | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($8 | 0) != -1) {
|
|
break label$2;
|
|
}
|
|
}
|
|
$1 = HEAP32[$0 + 44 >> 2];
|
|
HEAP32[$0 + 28 >> 2] = $1;
|
|
HEAP32[$0 + 20 >> 2] = $1;
|
|
HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 48 >> 2] + $1;
|
|
$0 = $2;
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = 0;
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
HEAP32[$0 + 20 >> 2] = 0;
|
|
HEAP32[$0 >> 2] = HEAP32[$0 >> 2] | 32;
|
|
$0 = 0;
|
|
if (($9 | 0) == 2) {
|
|
break label$1;
|
|
}
|
|
$0 = $2 - HEAP32[$1 + 4 >> 2] | 0;
|
|
}
|
|
__stack_pointer = $3 + 32 | 0;
|
|
$4 = $0;
|
|
return $4 | 0;
|
|
}
|
|
function ec_enc_bit_logp($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0;
|
|
$3 = HEAP32[$0 + 28 >> 2];
|
|
$2 = $3 >>> $2 | 0;
|
|
$3 = $3 - $2 | 0;
|
|
label$1 : {
|
|
if (!$1) {
|
|
$2 = $3;
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] + $3;
|
|
}
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
if ($2 >>> 0 <= 8388608) {
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
while (1) {
|
|
$5 = $1 >>> 23 | 0;
|
|
label$5 : {
|
|
if (($5 | 0) != 255) {
|
|
$2 = $1 >>> 31 | 0;
|
|
$3 = HEAP32[$0 + 40 >> 2];
|
|
if (($3 | 0) >= 0) {
|
|
$1 = -1;
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $4 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $4 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $4 | 0] = $2 + $3;
|
|
$1 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $1;
|
|
}
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
if ($1) {
|
|
$4 = $2 - 1 | 0;
|
|
while (1) {
|
|
$2 = -1;
|
|
$3 = HEAP32[$0 + 24 >> 2];
|
|
if (HEAPU32[$0 + 4 >> 2] > $3 + HEAP32[$0 + 8 >> 2] >>> 0) {
|
|
HEAP32[$0 + 24 >> 2] = $3 + 1;
|
|
HEAP8[HEAP32[$0 >> 2] + $3 | 0] = $4;
|
|
$2 = 0;
|
|
$1 = HEAP32[$0 + 36 >> 2];
|
|
}
|
|
$1 = $1 - 1 | 0;
|
|
HEAP32[$0 + 36 >> 2] = $1;
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $2;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $5 & 255;
|
|
$2 = HEAP32[$0 + 28 >> 2];
|
|
$1 = HEAP32[$0 + 32 >> 2];
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 36 >> 2] = HEAP32[$0 + 36 >> 2] + 1;
|
|
}
|
|
$2 = $2 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
$1 = $1 << 8 & 2147483392;
|
|
HEAP32[$0 + 32 >> 2] = $1;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + 8;
|
|
if ($2 >>> 0 < 8388609) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_gains_quant($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
if (($4 | 0) >= 1) {
|
|
while (1) {
|
|
$10 = ($9 << 2) + $1 | 0;
|
|
silk_lin2log(HEAP32[$10 >> 2]);
|
|
$6 = $0 + $9 | 0;
|
|
$7 = Math_imul((silk_lin2log(HEAP32[$10 >> 2]) << 16) - 136970240 >> 16, 2251);
|
|
$5 = $7 >>> 16 | 0;
|
|
HEAP8[$6 | 0] = $5;
|
|
if (HEAP8[$2 | 0] > $7 << 8 >> 24) {
|
|
$5 = $5 + 1 | 0;
|
|
HEAP8[$6 | 0] = $5;
|
|
}
|
|
$5 = $5 << 24 >> 24 > 0 ? $5 : 0;
|
|
$7 = $5 << 24 >> 24 < 63 ? $5 : 63;
|
|
HEAP8[$6 | 0] = $7;
|
|
$5 = HEAP8[$2 | 0];
|
|
label$4 : {
|
|
if (!($3 | $9)) {
|
|
$8 = $5 - 4 | 0;
|
|
$7 = $7 & 255;
|
|
$5 = ($5 | 0) > 67 ? 63 : ($7 | 0) < ($8 | 0) ? $8 : $7;
|
|
HEAP8[$6 | 0] = $5;
|
|
HEAP8[$2 | 0] = $5;
|
|
break label$4;
|
|
}
|
|
$5 = $7 - $5 | 0;
|
|
HEAP8[$6 | 0] = $5;
|
|
$7 = HEAP8[$2 | 0] + 8 | 0;
|
|
$8 = $5 << 24 >> 24;
|
|
if (($7 | 0) < ($8 | 0)) {
|
|
$5 = (($8 - $7 | 0) + 1 >>> 1 | 0) + $7 | 0;
|
|
HEAP8[$6 | 0] = $5;
|
|
}
|
|
$5 = $5 << 24 >> 24 > -4 ? $5 : -4;
|
|
$5 = $5 << 24 >> 24 < 36 ? $5 : 36;
|
|
HEAP8[$6 | 0] = $5;
|
|
$11 = $2;
|
|
$8 = $5 << 24 >> 24;
|
|
label$7 : {
|
|
if (($8 | 0) > ($7 | 0)) {
|
|
$5 = HEAPU8[$2 | 0] + (($8 << 1) - $7 | 0) | 0;
|
|
HEAP8[$2 | 0] = $5;
|
|
$5 = $5 << 24 >> 24 < 63 ? $5 : 63;
|
|
break label$7;
|
|
}
|
|
$5 = HEAPU8[$2 | 0] + $5 | 0;
|
|
}
|
|
HEAP8[$11 | 0] = $5;
|
|
HEAP8[$6 | 0] = HEAPU8[$6 | 0] + 4;
|
|
$5 = HEAPU8[$2 | 0];
|
|
}
|
|
$6 = $5 << 24 >> 24;
|
|
$6 = (Math_imul($6, 7281) >> 16) + Math_imul($6, 29) | 0;
|
|
HEAP32[$10 >> 2] = silk_log2lin((($6 | 0) < 1877 ? $6 : 1877) + 2090 | 0);
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_warped_autocorrelation_FLP($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0;
|
|
$5 = __stack_pointer - 416 | 0;
|
|
__stack_pointer = $5;
|
|
memset($5 + 208 | 0, 0, 200);
|
|
$5 = memset($5, 0, 200);
|
|
if (!($4 & 1)) {
|
|
if (($3 | 0) >= 1) {
|
|
$6 = $4 << 3;
|
|
$11 = $6 + $5 | 0;
|
|
$18 = ($5 + 208 | 0) + $6 | 0;
|
|
$12 = +$2;
|
|
$19 = ($4 | 0) < 1;
|
|
while (1) {
|
|
$8 = +HEAPF32[($9 << 2) + $1 >> 2];
|
|
$6 = 0;
|
|
if (!$19) {
|
|
while (1) {
|
|
$7 = $6 << 3;
|
|
$13 = $7 | 8;
|
|
$14 = $13 + ($5 + 208 | 0) | 0;
|
|
$15 = HEAPF64[$14 >> 3];
|
|
HEAPF64[($5 + 208 | 0) + $7 >> 3] = $8;
|
|
$7 = $5 + $7 | 0;
|
|
$16 = HEAPF64[$5 + 208 >> 3];
|
|
HEAPF64[$7 >> 3] = HEAPF64[$7 >> 3] + $8 * $16;
|
|
$6 = $6 + 2 | 0;
|
|
$17 = HEAPF64[($5 + 208 | 0) + ($6 << 3) >> 3];
|
|
$8 = $10 + ($15 - $8) * $12;
|
|
HEAPF64[$14 >> 3] = $8;
|
|
$7 = $5 + $13 | 0;
|
|
HEAPF64[$7 >> 3] = $16 * $8 + HEAPF64[$7 >> 3];
|
|
$8 = $15 + ($17 - $8) * $12;
|
|
$10 = $17;
|
|
if (($4 | 0) > ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF64[$18 >> 3] = $8;
|
|
$10 = HEAPF64[$5 + 208 >> 3];
|
|
HEAPF64[$11 >> 3] = HEAPF64[$11 >> 3] + $8 * $10;
|
|
$9 = $9 + 1 | 0;
|
|
if (($9 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = 0;
|
|
if (($4 | 0) >= 0) {
|
|
while (1) {
|
|
HEAPF32[($6 << 2) + $0 >> 2] = HEAPF64[($6 << 3) + $5 >> 3];
|
|
$7 = ($4 | 0) != ($6 | 0);
|
|
$6 = $6 + 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $5 + 416 | 0;
|
|
return;
|
|
}
|
|
celt_fatal(10944, 10981, 49);
|
|
abort();
|
|
}
|
|
function pop_arg($0, $1, $2, $3) {
|
|
label$1 : {
|
|
if ($1 >>> 0 > 20) {
|
|
break label$1;
|
|
}
|
|
label$2 : {
|
|
switch ($1 - 9 | 0) {
|
|
case 0:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
HEAP32[$0 >> 2] = HEAP32[$1 >> 2];
|
|
return;
|
|
case 1:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$1 = HEAP32[$1 >> 2];
|
|
$2 = $1 >> 31;
|
|
HEAP32[$0 >> 2] = $1;
|
|
HEAP32[$0 + 4 >> 2] = $2;
|
|
return;
|
|
case 2:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$2 = HEAP32[$1 >> 2];
|
|
HEAP32[$0 >> 2] = $2;
|
|
HEAP32[$0 + 4 >> 2] = 0;
|
|
return;
|
|
case 3:
|
|
$1 = HEAP32[$2 >> 2] + 7 & -8;
|
|
HEAP32[$2 >> 2] = $1 + 8;
|
|
$2 = HEAP32[$1 + 4 >> 2];
|
|
$1 = HEAP32[$1 >> 2];
|
|
HEAP32[$0 >> 2] = $1;
|
|
HEAP32[$0 + 4 >> 2] = $2;
|
|
return;
|
|
case 4:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$2 = HEAP16[$1 >> 1];
|
|
$1 = $2 >> 31;
|
|
HEAP32[$0 >> 2] = $2;
|
|
HEAP32[$0 + 4 >> 2] = $1;
|
|
return;
|
|
case 5:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$1 = HEAPU16[$1 >> 1];
|
|
HEAP32[$0 >> 2] = $1;
|
|
HEAP32[$0 + 4 >> 2] = 0;
|
|
return;
|
|
case 6:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$2 = HEAP8[$1 | 0];
|
|
$1 = $2 >> 31;
|
|
HEAP32[$0 >> 2] = $2;
|
|
HEAP32[$0 + 4 >> 2] = $1;
|
|
return;
|
|
case 7:
|
|
$1 = HEAP32[$2 >> 2];
|
|
HEAP32[$2 >> 2] = $1 + 4;
|
|
$1 = HEAPU8[$1 | 0];
|
|
HEAP32[$0 >> 2] = $1;
|
|
HEAP32[$0 + 4 >> 2] = 0;
|
|
return;
|
|
case 8:
|
|
$1 = HEAP32[$2 >> 2] + 7 & -8;
|
|
HEAP32[$2 >> 2] = $1 + 8;
|
|
HEAPF64[$0 >> 3] = HEAPF64[$1 >> 3];
|
|
return;
|
|
case 9:
|
|
break label$2;
|
|
default:
|
|
break label$1;
|
|
}
|
|
}
|
|
FUNCTION_TABLE[$3 | 0]($0, $2);
|
|
}
|
|
}
|
|
function speex_resampler_init_frac($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (!(!$2 | (!$0 | !$1))) {
|
|
if ($5 >>> 0 < 11) {
|
|
break label$2;
|
|
}
|
|
}
|
|
if (!$6) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$6 >> 2] = 3;
|
|
return 0;
|
|
}
|
|
$7 = dlcalloc(96, 1);
|
|
if (!$7) {
|
|
$7 = 0;
|
|
if (!$6) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$6 >> 2] = 1;
|
|
return 0;
|
|
}
|
|
HEAP32[$7 >> 2] = 0;
|
|
HEAP32[$7 + 4 >> 2] = 0;
|
|
HEAP32[$7 + 44 >> 2] = 1065353216;
|
|
HEAP32[$7 + 16 >> 2] = -1;
|
|
HEAP32[$7 + 88 >> 2] = 1;
|
|
HEAP32[$7 + 92 >> 2] = 1;
|
|
HEAP32[$7 + 20 >> 2] = $0;
|
|
HEAP32[$7 + 32 >> 2] = 160;
|
|
HEAP32[$7 + 8 >> 2] = 0;
|
|
HEAP32[$7 + 12 >> 2] = 0;
|
|
$0 = $0 << 2;
|
|
$8 = dlcalloc($0, 1);
|
|
HEAP32[$7 + 60 >> 2] = $8;
|
|
label$5 : {
|
|
if (!$8) {
|
|
break label$5;
|
|
}
|
|
$8 = dlcalloc($0, 1);
|
|
HEAP32[$7 + 68 >> 2] = $8;
|
|
if (!$8) {
|
|
break label$5;
|
|
}
|
|
$0 = dlcalloc($0, 1);
|
|
HEAP32[$7 + 64 >> 2] = $0;
|
|
if (!$0) {
|
|
break label$5;
|
|
}
|
|
HEAP32[$7 + 16 >> 2] = $5;
|
|
speex_resampler_set_rate_frac($7, $1, $2, $3, $4);
|
|
$0 = update_filter($7);
|
|
label$6 : {
|
|
if (!$0) {
|
|
HEAP32[$7 + 52 >> 2] = 1;
|
|
break label$6;
|
|
}
|
|
dlfree(HEAP32[$7 + 72 >> 2]);
|
|
dlfree(HEAP32[$7 + 76 >> 2]);
|
|
dlfree(HEAP32[$7 + 60 >> 2]);
|
|
dlfree(HEAP32[$7 + 68 >> 2]);
|
|
dlfree(HEAP32[$7 + 64 >> 2]);
|
|
dlfree($7);
|
|
$7 = 0;
|
|
}
|
|
if (!$6) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$6 >> 2] = $0;
|
|
return $7;
|
|
}
|
|
if ($6) {
|
|
HEAP32[$6 >> 2] = 1;
|
|
}
|
|
dlfree(HEAP32[$7 + 76 >> 2]);
|
|
dlfree(HEAP32[$7 + 60 >> 2]);
|
|
dlfree(HEAP32[$7 + 68 >> 2]);
|
|
dlfree(HEAP32[$7 + 64 >> 2]);
|
|
dlfree($7);
|
|
$7 = 0;
|
|
}
|
|
return $7;
|
|
}
|
|
function speex_resampler_set_rate_frac($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
$6 = 3;
|
|
label$1 : {
|
|
if (!$1 | !$2) {
|
|
break label$1;
|
|
}
|
|
if (!(HEAP32[$0 >> 2] != ($3 | 0) | HEAP32[$0 + 4 >> 2] != ($4 | 0) | HEAP32[$0 + 8 >> 2] != ($1 | 0))) {
|
|
$6 = 0;
|
|
if (HEAP32[$0 + 12 >> 2] == ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
}
|
|
HEAP32[$0 + 8 >> 2] = $1;
|
|
HEAP32[$0 + 4 >> 2] = $4;
|
|
HEAP32[$0 >> 2] = $3;
|
|
$7 = HEAP32[$0 + 12 >> 2];
|
|
HEAP32[$0 + 12 >> 2] = $2;
|
|
$5 = $1;
|
|
$3 = $2;
|
|
while (1) {
|
|
$4 = $3;
|
|
$3 = ($5 >>> 0) % ($3 >>> 0) | 0;
|
|
$5 = $4;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = ($2 >>> 0) / ($4 >>> 0) | 0;
|
|
HEAP32[$0 + 12 >> 2] = $3;
|
|
HEAP32[$0 + 8 >> 2] = ($1 >>> 0) / ($4 >>> 0);
|
|
label$4 : {
|
|
if (!$7 | !HEAP32[$0 + 20 >> 2]) {
|
|
break label$4;
|
|
}
|
|
$9 = HEAP32[$0 + 64 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$6 = 5;
|
|
$2 = 4294967295 / ($3 >>> 0) | 0;
|
|
$1 = ($4 << 2) + $9 | 0;
|
|
$5 = HEAP32[$1 >> 2];
|
|
$8 = $5;
|
|
$5 = ($5 >>> 0) / ($7 >>> 0) | 0;
|
|
$8 = $8 - Math_imul($7, $5) | 0;
|
|
if ($2 >>> 0 < $8 >>> 0 | $2 >>> 0 < $5 >>> 0) {
|
|
break label$1;
|
|
}
|
|
$5 = Math_imul($3, $5);
|
|
$3 = (Math_imul($3, $8) >>> 0) / ($7 >>> 0) | 0;
|
|
if ($5 >>> 0 > ($3 ^ -1) >>> 0) {
|
|
break label$1;
|
|
}
|
|
$3 = $3 + $5 | 0;
|
|
HEAP32[$1 >> 2] = $3;
|
|
$5 = HEAP32[$0 + 12 >> 2];
|
|
if ($5 >>> 0 <= $3 >>> 0) {
|
|
HEAP32[$1 >> 2] = $5 - 1;
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if ($4 >>> 0 >= HEAPU32[$0 + 20 >> 2]) {
|
|
break label$4;
|
|
}
|
|
$3 = HEAP32[$0 + 12 >> 2];
|
|
continue;
|
|
}
|
|
}
|
|
if (!HEAP32[$0 + 52 >> 2]) {
|
|
return 0;
|
|
}
|
|
$6 = update_filter($0);
|
|
}
|
|
return $6;
|
|
}
|
|
function log($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$2 = wasm2js_scratch_load_i32(1) | 0;
|
|
$4 = wasm2js_scratch_load_i32(0) | 0;
|
|
$5 = $2;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
if (($2 | 0) > 0 ? 1 : ($2 | 0) >= 0) {
|
|
$1 = $5;
|
|
if ($1 >>> 0 > 1048575) {
|
|
break label$4;
|
|
}
|
|
}
|
|
$2 = $5;
|
|
$1 = $2 & 2147483647;
|
|
if (!($1 | $4)) {
|
|
return -1 / ($0 * $0);
|
|
}
|
|
$1 = $5;
|
|
if (($1 | 0) > -1) {
|
|
break label$3;
|
|
}
|
|
return ($0 - $0) / 0;
|
|
}
|
|
if ($1 >>> 0 > 2146435071) {
|
|
break label$1;
|
|
}
|
|
$2 = 1072693248;
|
|
$6 = -1023;
|
|
if (($1 | 0) != 1072693248) {
|
|
$2 = $1;
|
|
break label$2;
|
|
}
|
|
if ($4) {
|
|
break label$2;
|
|
}
|
|
return 0;
|
|
}
|
|
wasm2js_scratch_store_f64(+($0 * 0x40000000000000));
|
|
$2 = wasm2js_scratch_load_i32(1) | 0;
|
|
$4 = wasm2js_scratch_load_i32(0) | 0;
|
|
$6 = -1077;
|
|
}
|
|
$1 = $2 + 614242 | 0;
|
|
$3 = +(($1 >>> 20 | 0) + $6 | 0);
|
|
$8 = $3 * .6931471803691238;
|
|
$1 = ($1 & 1048575) + 1072079006 | 0;
|
|
$2 = 0;
|
|
$1 = $2 | $1;
|
|
wasm2js_scratch_store_i32(0, $4 | 0);
|
|
wasm2js_scratch_store_i32(1, $1 | 0);
|
|
$0 = +wasm2js_scratch_load_f64() + -1;
|
|
$9 = $0;
|
|
$10 = $3 * 1.9082149292705877e-10;
|
|
$3 = $0 / ($0 + 2);
|
|
$11 = $3;
|
|
$7 = $0 * ($0 * .5);
|
|
$3 = $3 * $3;
|
|
$0 = $3 * $3;
|
|
$0 = $8 + ($9 + ($10 + $11 * ($7 + ($0 * ($0 * ($0 * .15313837699209373 + .22222198432149784) + .3999999999940942) + $3 * ($0 * ($0 * ($0 * .14798198605116586 + .1818357216161805) + .2857142874366239) + .6666666666666735))) - $7));
|
|
}
|
|
return $0;
|
|
}
|
|
function memset($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
label$1 : {
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
$3 = $0 + $2 | 0;
|
|
HEAP8[$3 - 1 | 0] = $1;
|
|
HEAP8[$0 | 0] = $1;
|
|
if ($2 >>> 0 < 3) {
|
|
break label$1;
|
|
}
|
|
HEAP8[$3 - 2 | 0] = $1;
|
|
HEAP8[$0 + 1 | 0] = $1;
|
|
HEAP8[$3 - 3 | 0] = $1;
|
|
HEAP8[$0 + 2 | 0] = $1;
|
|
if ($2 >>> 0 < 7) {
|
|
break label$1;
|
|
}
|
|
HEAP8[$3 - 4 | 0] = $1;
|
|
HEAP8[$0 + 3 | 0] = $1;
|
|
if ($2 >>> 0 < 9) {
|
|
break label$1;
|
|
}
|
|
$4 = 0 - $0 & 3;
|
|
$3 = $4 + $0 | 0;
|
|
$1 = Math_imul($1 & 255, 16843009);
|
|
HEAP32[$3 >> 2] = $1;
|
|
$4 = $2 - $4 & -4;
|
|
$2 = $4 + $3 | 0;
|
|
HEAP32[$2 - 4 >> 2] = $1;
|
|
if ($4 >>> 0 < 9) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 + 8 >> 2] = $1;
|
|
HEAP32[$3 + 4 >> 2] = $1;
|
|
HEAP32[$2 - 8 >> 2] = $1;
|
|
HEAP32[$2 - 12 >> 2] = $1;
|
|
if ($4 >>> 0 < 25) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 + 24 >> 2] = $1;
|
|
HEAP32[$3 + 20 >> 2] = $1;
|
|
HEAP32[$3 + 16 >> 2] = $1;
|
|
HEAP32[$3 + 12 >> 2] = $1;
|
|
HEAP32[$2 - 16 >> 2] = $1;
|
|
HEAP32[$2 - 20 >> 2] = $1;
|
|
HEAP32[$2 - 24 >> 2] = $1;
|
|
HEAP32[$2 - 28 >> 2] = $1;
|
|
$6 = $3 & 4 | 24;
|
|
$2 = $4 - $6 | 0;
|
|
if ($2 >>> 0 < 32) {
|
|
break label$1;
|
|
}
|
|
$5 = __wasm_i64_mul($1, 0, 1, 1);
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$7 = $4;
|
|
$1 = $3 + $6 | 0;
|
|
while (1) {
|
|
HEAP32[$1 + 24 >> 2] = $5;
|
|
$4 = $7;
|
|
HEAP32[$1 + 28 >> 2] = $4;
|
|
HEAP32[$1 + 16 >> 2] = $5;
|
|
HEAP32[$1 + 20 >> 2] = $4;
|
|
HEAP32[$1 + 8 >> 2] = $5;
|
|
HEAP32[$1 + 12 >> 2] = $4;
|
|
HEAP32[$1 >> 2] = $5;
|
|
HEAP32[$1 + 4 >> 2] = $4;
|
|
$1 = $1 + 32 | 0;
|
|
$2 = $2 - 32 | 0;
|
|
if ($2 >>> 0 > 31) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $0;
|
|
}
|
|
function silk_LPC_analysis_filter($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($4 | 0) > 5) {
|
|
if ($4 & 1) {
|
|
break label$2;
|
|
}
|
|
if (($3 | 0) < ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
if (($3 | 0) > ($4 | 0)) {
|
|
$12 = ($4 | 0) < 7;
|
|
$5 = $4;
|
|
while (1) {
|
|
$11 = $5 << 1;
|
|
$7 = $11 + $1 | 0;
|
|
$8 = $7 - 2 | 0;
|
|
$9 = ((((Math_imul(HEAP16[$2 + 2 >> 1], HEAP16[$7 - 4 >> 1]) + Math_imul(HEAP16[$2 >> 1], HEAP16[$8 >> 1]) | 0) + Math_imul(HEAP16[$2 + 4 >> 1], HEAP16[$7 - 6 >> 1]) | 0) + Math_imul(HEAP16[$2 + 6 >> 1], HEAP16[$7 - 8 >> 1]) | 0) + Math_imul(HEAP16[$2 + 8 >> 1], HEAP16[$7 - 10 >> 1]) | 0) + Math_imul(HEAP16[$2 + 10 >> 1], HEAP16[$7 - 12 >> 1]) | 0;
|
|
$6 = 6;
|
|
if (!$12) {
|
|
while (1) {
|
|
$10 = $6 << 1;
|
|
$9 = (Math_imul(HEAP16[$10 + $2 >> 1], HEAP16[$8 - $10 >> 1]) + $9 | 0) + Math_imul(HEAP16[($10 | 2) + $2 >> 1], HEAP16[(($6 ^ -1) << 1) + $8 >> 1]) | 0;
|
|
$6 = $6 + 2 | 0;
|
|
if (($6 | 0) < ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = ((HEAP16[$7 >> 1] << 12) - $9 >> 11) + 1 >> 1;
|
|
$6 = ($6 | 0) > -32768 ? $6 : -32768;
|
|
HEAP16[$0 + $11 >> 1] = ($6 | 0) < 32767 ? $6 : 32767;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memset($0, 0, $4 << 1);
|
|
return;
|
|
}
|
|
celt_fatal(16065, 16090, 67);
|
|
abort();
|
|
}
|
|
celt_fatal(16117, 16090, 68);
|
|
abort();
|
|
}
|
|
celt_fatal(16148, 16090, 69);
|
|
abort();
|
|
}
|
|
function silk_corrMatrix_FLP($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = Math_fround(0);
|
|
$10 = $2 - 1 | 0;
|
|
$8 = ($10 << 2) + $0 | 0;
|
|
$6 = silk_energy_FLP($8, $1);
|
|
HEAPF32[$3 >> 2] = $6;
|
|
label$1 : {
|
|
if (($2 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
$4 = 1;
|
|
while (1) {
|
|
$5 = HEAPF32[$8 - ($4 << 2) >> 2];
|
|
$12 = Math_fround($5 * $5);
|
|
$5 = HEAPF32[($1 - $4 << 2) + $8 >> 2];
|
|
$6 = $6 + +Math_fround($12 - Math_fround($5 * $5));
|
|
HEAPF32[(Math_imul($2, $4) + $4 << 2) + $3 >> 2] = $6;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($2 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
$0 = (($2 << 2) + $0 | 0) - 8 | 0;
|
|
$7 = 1;
|
|
while (1) {
|
|
$4 = (Math_imul($2, $7) << 2) + $3 | 0;
|
|
$6 = silk_inner_product_FLP($8, $0, $1);
|
|
$5 = Math_fround($6);
|
|
HEAPF32[$4 >> 2] = $5;
|
|
HEAPF32[($7 << 2) + $3 >> 2] = $5;
|
|
$4 = 1;
|
|
if (($2 - $7 | 0) >= 2) {
|
|
while (1) {
|
|
$11 = $4 + $7 | 0;
|
|
$9 = $4 << 2;
|
|
$5 = Math_fround(HEAPF32[$8 - $9 >> 2] * HEAPF32[$0 - $9 >> 2]);
|
|
$9 = $1 - $4 << 2;
|
|
$6 = $6 + +Math_fround($5 - Math_fround(HEAPF32[$9 + $8 >> 2] * HEAPF32[$0 + $9 >> 2]));
|
|
$5 = Math_fround($6);
|
|
HEAPF32[(Math_imul($11, $2) + $4 << 2) + $3 >> 2] = $5;
|
|
HEAPF32[(Math_imul($2, $4) + $11 << 2) + $3 >> 2] = $5;
|
|
$4 = $4 + 1 | 0;
|
|
if (($10 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$10 = $10 - 1 | 0;
|
|
$0 = $0 - 4 | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function quant_fine_energy($0, $1, $2, $3, $4, $5, $6, $7) {
|
|
var $8 = 0, $9 = 0, $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = Math_fround(0), $19 = Math_fround(0);
|
|
if (($1 | 0) < ($2 | 0)) {
|
|
$16 = ($7 | 0) > 1 ? $7 : 1;
|
|
while (1) {
|
|
$14 = ($1 << 2) + $5 | 0;
|
|
$9 = HEAP32[$14 >> 2];
|
|
if (($9 | 0) >= 1) {
|
|
$12 = 65536 << $9 >> 16;
|
|
$17 = $12 - 1 | 0;
|
|
$18 = Math_fround($12 | 0);
|
|
$8 = HEAP32[$0 + 8 >> 2];
|
|
$7 = 0;
|
|
while (1) {
|
|
$13 = $6;
|
|
$10 = Math_fround(Math_floor(Math_fround(Math_fround(HEAPF32[(Math_imul($7, $8) + $1 << 2) + $4 >> 2] + Math_fround(.5)) * $18)));
|
|
label$5 : {
|
|
if (Math_fround(Math_abs($10)) < Math_fround(2147483648)) {
|
|
$8 = ~~$10;
|
|
break label$5;
|
|
}
|
|
$8 = -2147483648;
|
|
}
|
|
$8 = ($8 | 0) < ($12 | 0) ? $8 : $17;
|
|
$11 = ($8 | 0) > 0 ? $8 : 0;
|
|
ec_enc_bits($13, $11, $9);
|
|
$8 = HEAP32[$0 + 8 >> 2];
|
|
$15 = Math_imul($8, $7) + $1 << 2;
|
|
$9 = $15 + $3 | 0;
|
|
$13 = $9;
|
|
$19 = HEAPF32[$9 >> 2];
|
|
$9 = HEAP32[$14 >> 2];
|
|
$10 = Math_fround(Math_fround(Math_fround(Math_fround(Math_fround($11 | 0) + Math_fround(.5)) * Math_fround(1 << 14 - $9)) * Math_fround(6103515625e-14)) + Math_fround(-.5));
|
|
HEAPF32[$13 >> 2] = $19 + $10;
|
|
$11 = $4 + $15 | 0;
|
|
HEAPF32[$11 >> 2] = HEAPF32[$11 >> 2] - $10;
|
|
$7 = $7 + 1 | 0;
|
|
if (($16 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = $1 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_HP_variable_cutoff($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0;
|
|
if (HEAPU8[$0 + 4541 | 0] == 2) {
|
|
$1 = silk_lin2log((Math_imul(HEAP32[$0 + 4576 >> 2], 65536e3) | 0) / HEAP32[$0 + 4544 >> 2] | 0);
|
|
$2 = HEAP32[$0 + 4696 >> 2];
|
|
$3 = silk_lin2log(3932160);
|
|
$6 = silk_lin2log(3932160);
|
|
$4 = 0 - ($2 << 2) | 0;
|
|
$5 = HEAP32[$0 + 8 >> 2];
|
|
$2 = $2 << 16 >> 16;
|
|
$2 = (Math_imul($2, $4 & 65532) >> 16) + Math_imul($4 >> 16, $2) | 0;
|
|
$1 = ((($1 - ($5 >> 8) | 0) + Math_imul($2 >> 16, $1 - $3 << 16 >> 16) | 0) + (Math_imul($2 & 65535, $1 - $6 << 16 >> 16) >> 16) | 0) - 2048 | 0;
|
|
$1 = ($1 | 0) < 0 ? Math_imul($1, 3) : $1;
|
|
$1 = ($1 | 0) > -51 ? $1 : -51;
|
|
$1 = Math_imul(HEAP16[$0 + 4532 >> 1], ($1 | 0) < 51 ? $1 : 51);
|
|
HEAP32[$0 + 8 >> 2] = Math_imul($1 >> 16, 6554) + $5 + (Math_imul($1 & 65535, 6554) >>> 16);
|
|
$1 = silk_lin2log(60);
|
|
$2 = silk_lin2log(100);
|
|
$3 = HEAP32[$0 + 8 >> 2];
|
|
$4 = $0;
|
|
label$2 : {
|
|
label$3 : {
|
|
if ($1 << 8 > $2 << 8) {
|
|
if (silk_lin2log(60) << 8 < ($3 | 0)) {
|
|
$1 = silk_lin2log(60) << 8;
|
|
break label$2;
|
|
}
|
|
if (HEAP32[$0 + 8 >> 2] >= silk_lin2log(100) << 8) {
|
|
break label$3;
|
|
}
|
|
$1 = silk_lin2log(100) << 8;
|
|
break label$2;
|
|
}
|
|
if (silk_lin2log(100) << 8 < ($3 | 0)) {
|
|
$1 = silk_lin2log(100) << 8;
|
|
break label$2;
|
|
}
|
|
if (HEAP32[$0 + 8 >> 2] >= silk_lin2log(60) << 8) {
|
|
break label$3;
|
|
}
|
|
$1 = silk_lin2log(60) << 8;
|
|
break label$2;
|
|
}
|
|
$1 = HEAP32[$0 + 8 >> 2];
|
|
}
|
|
HEAP32[$4 + 8 >> 2] = $1;
|
|
}
|
|
}
|
|
function silk_A2NLSF_eval_poly($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
|
|
$4 = $1 << 4;
|
|
$3 = HEAP32[($2 << 2) + $0 >> 2];
|
|
if (($2 | 0) != 8) {
|
|
if (($2 | 0) >= 1) {
|
|
$1 = $1 << 20 >> 16;
|
|
$5 = ($4 >> 15) + 1 >> 1;
|
|
while (1) {
|
|
$4 = $2 - 1 | 0;
|
|
$3 = HEAP32[($4 << 2) + $0 >> 2] + ((Math_imul($3 >> 16, $1) + Math_imul($3, $5) | 0) + (Math_imul($3 & 65535, $1) >> 16) | 0) | 0;
|
|
$6 = ($2 | 0) > 1;
|
|
$2 = $4;
|
|
if ($6) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $3;
|
|
}
|
|
$2 = $1 << 20 >> 16;
|
|
$1 = ($4 >> 15) + 1 >> 1;
|
|
$3 = HEAP32[$0 + 28 >> 2] + ((Math_imul($2, $3 >> 16) + Math_imul($3, $1) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0) | 0;
|
|
$3 = ((HEAP32[$0 + 24 >> 2] + Math_imul($1, $3) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$3 = ((HEAP32[$0 + 20 >> 2] + Math_imul($3, $1) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$3 = ((HEAP32[$0 + 16 >> 2] + Math_imul($3, $1) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$3 = ((HEAP32[$0 + 12 >> 2] + Math_imul($3, $1) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$3 = ((HEAP32[$0 + 8 >> 2] + Math_imul($3, $1) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
$3 = ((HEAP32[$0 + 4 >> 2] + Math_imul($3, $1) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
return ((HEAP32[$0 >> 2] + Math_imul($3, $1) | 0) + Math_imul($3 >> 16, $2) | 0) + (Math_imul($3 & 65535, $2) >> 16) | 0;
|
|
}
|
|
function resampler_basic_direct_single($0, $1, $2, $3, $4, $5) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$5 = $5 | 0;
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $19 = 0, $20 = 0;
|
|
$1 = $1 << 2;
|
|
$11 = $1 + HEAP32[$0 + 64 >> 2] | 0;
|
|
$8 = HEAP32[$11 >> 2];
|
|
$12 = HEAP32[$0 + 60 >> 2] + $1 | 0;
|
|
$6 = HEAP32[$12 >> 2];
|
|
$13 = HEAP32[$3 >> 2];
|
|
label$1 : {
|
|
if (($6 | 0) >= ($13 | 0)) {
|
|
break label$1;
|
|
}
|
|
$9 = HEAP32[$0 + 12 >> 2];
|
|
$15 = HEAP32[$0 + 40 >> 2];
|
|
$16 = HEAP32[$0 + 36 >> 2];
|
|
$17 = HEAP32[$0 + 92 >> 2];
|
|
$18 = HEAP32[$0 + 76 >> 2];
|
|
$3 = HEAP32[$5 >> 2];
|
|
$14 = ($3 | 0) > 0 ? $3 : 0;
|
|
$1 = HEAP32[$0 + 24 >> 2];
|
|
$19 = ($1 | 0) < 1;
|
|
while (1) {
|
|
if (($7 | 0) == ($14 | 0)) {
|
|
$7 = $14;
|
|
break label$1;
|
|
}
|
|
$10 = Math_fround(0);
|
|
if (!$19) {
|
|
$5 = ($6 << 2) + $2 | 0;
|
|
$20 = (Math_imul($1, $8) << 2) + $18 | 0;
|
|
$0 = 0;
|
|
while (1) {
|
|
$3 = $0 << 2;
|
|
$10 = Math_fround($10 + Math_fround(HEAPF32[$20 + $3 >> 2] * HEAPF32[$3 + $5 >> 2]));
|
|
$0 = $0 + 1 | 0;
|
|
if (($1 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[(Math_imul($7, $17) << 2) + $4 >> 2] = $10;
|
|
$0 = $8 + $15 | 0;
|
|
$8 = $0 - ($0 >>> 0 < $9 >>> 0 ? 0 : $9) | 0;
|
|
$7 = $7 + 1 | 0;
|
|
$6 = ($6 + $16 | 0) + ($0 >>> 0 >= $9 >>> 0) | 0;
|
|
if (($13 | 0) > ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$12 >> 2] = $6;
|
|
HEAP32[$11 >> 2] = $8;
|
|
return $7 | 0;
|
|
}
|
|
function silk_schur_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$6 = __stack_pointer - 400 | 0;
|
|
__stack_pointer = $6;
|
|
if ($2 >>> 0 <= 24) {
|
|
while (1) {
|
|
$4 = ($3 << 4) + $6 | 0;
|
|
$5 = +HEAPF32[($3 << 2) + $1 >> 2];
|
|
HEAPF64[$4 >> 3] = $5;
|
|
HEAPF64[$4 + 8 >> 3] = $5;
|
|
$4 = ($2 | 0) != ($3 | 0);
|
|
$3 = $3 + 1 | 0;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if ($2) {
|
|
$1 = 0;
|
|
$9 = $2;
|
|
while (1) {
|
|
$3 = $1;
|
|
$1 = $3 + 1 | 0;
|
|
$4 = ($1 << 4) + $6 | 0;
|
|
$7 = HEAPF64[$6 + 8 >> 3];
|
|
$5 = -HEAPF64[$4 >> 3] / ($7 > 9.999999717180685e-10 ? $7 : 9.999999717180685e-10);
|
|
HEAPF32[($3 << 2) + $0 >> 2] = $5;
|
|
label$5 : {
|
|
if (($2 | 0) <= ($3 | 0)) {
|
|
break label$5;
|
|
}
|
|
$8 = HEAPF64[$4 >> 3];
|
|
HEAPF64[$4 >> 3] = $8 + $5 * $7;
|
|
HEAPF64[$6 + 8 >> 3] = $7 + $5 * $8;
|
|
$3 = 1;
|
|
if (($9 | 0) == 1) {
|
|
break label$5;
|
|
}
|
|
while (1) {
|
|
$4 = ($1 + $3 << 4) + $6 | 0;
|
|
$10 = $4;
|
|
$7 = HEAPF64[$4 >> 3];
|
|
$4 = ($3 << 4) + $6 | 0;
|
|
$8 = HEAPF64[$4 + 8 >> 3];
|
|
HEAPF64[$10 >> 3] = $7 + $5 * $8;
|
|
HEAPF64[$4 + 8 >> 3] = $8 + $5 * $7;
|
|
$3 = $3 + 1 | 0;
|
|
if (($9 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$9 = $9 - 1 | 0;
|
|
if (($1 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $6 + 400 | 0;
|
|
$5 = HEAPF64[$6 + 8 >> 3];
|
|
return Math_fround($5);
|
|
}
|
|
celt_fatal(9497, 9557, 44);
|
|
abort();
|
|
}
|
|
function gain_fade($0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
var $9 = Math_fround(0), $10 = 0, $11 = 0;
|
|
$10 = 48e3 / ($8 | 0) | 0;
|
|
$11 = ($4 | 0) / ($10 | 0) | 0;
|
|
label$1 : {
|
|
if (($6 | 0) != 1) {
|
|
$4 = 0;
|
|
if (($11 | 0) <= 0) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$8 = $4 << 3;
|
|
$9 = HEAPF32[(Math_imul($4, $10) << 2) + $7 >> 2];
|
|
$9 = Math_fround($9 * $9);
|
|
$9 = Math_fround(Math_fround($9 * $3) + Math_fround(Math_fround(Math_fround(1) - $9) * $2));
|
|
HEAPF32[$8 + $1 >> 2] = HEAPF32[$0 + $8 >> 2] * $9;
|
|
$8 = $8 | 4;
|
|
HEAPF32[$8 + $1 >> 2] = HEAPF32[$0 + $8 >> 2] * $9;
|
|
$4 = $4 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($11 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$4 = 0;
|
|
while (1) {
|
|
$8 = $4 << 2;
|
|
$9 = HEAPF32[(Math_imul($4, $10) << 2) + $7 >> 2];
|
|
$9 = Math_fround($9 * $9);
|
|
HEAPF32[$8 + $1 >> 2] = HEAPF32[$0 + $8 >> 2] * Math_fround(Math_fround($9 * $3) + Math_fround(Math_fround(Math_fround(1) - $9) * $2));
|
|
$4 = $4 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$10 = ($6 | 0) > 1 ? $6 : 1;
|
|
$7 = 0;
|
|
while (1) {
|
|
$4 = $11;
|
|
if (($5 | 0) > ($4 | 0)) {
|
|
while (1) {
|
|
$8 = Math_imul($4, $6) + $7 << 2;
|
|
HEAPF32[$8 + $1 >> 2] = HEAPF32[$0 + $8 >> 2] * $3;
|
|
$4 = $4 + 1 | 0;
|
|
if (($5 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = $7 + 1 | 0;
|
|
if (($10 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function _celt_lpc($0, $1, $2) {
|
|
var $3 = Math_fround(0), $4 = 0, $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0;
|
|
$5 = HEAPF32[$1 >> 2];
|
|
$0 = memset($0, 0, $2 << 2);
|
|
label$1 : {
|
|
if (HEAPF32[$1 >> 2] == Math_fround(0)) {
|
|
break label$1;
|
|
}
|
|
$11 = ($2 | 0) > 0 ? $2 : 0;
|
|
$7 = 1;
|
|
while (1) {
|
|
if (($4 | 0) == ($11 | 0)) {
|
|
break label$1;
|
|
}
|
|
$2 = 0;
|
|
$3 = Math_fround(0);
|
|
if ($4) {
|
|
while (1) {
|
|
$3 = Math_fround($3 + Math_fround(HEAPF32[($2 << 2) + $0 >> 2] * HEAPF32[($4 - $2 << 2) + $1 >> 2]));
|
|
$2 = $2 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $4 + 1 | 0;
|
|
$3 = Math_fround(Math_fround(-Math_fround($3 + HEAPF32[($8 << 2) + $1 >> 2])) / $5);
|
|
HEAPF32[($4 << 2) + $0 >> 2] = $3;
|
|
if ($4) {
|
|
$12 = $7 >>> 1 | 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$6 = ($2 << 2) + $0 | 0;
|
|
$13 = $6;
|
|
$9 = HEAPF32[$6 >> 2];
|
|
$6 = (($2 ^ -1) + $4 << 2) + $0 | 0;
|
|
$10 = HEAPF32[$6 >> 2];
|
|
HEAPF32[$13 >> 2] = $9 + Math_fround($3 * $10);
|
|
HEAPF32[$6 >> 2] = $10 + Math_fround($3 * $9);
|
|
$2 = $2 + 1 | 0;
|
|
if (($12 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = $7 + 1 | 0;
|
|
$4 = $8;
|
|
$5 = Math_fround($5 - Math_fround($5 * Math_fround($3 * $3)));
|
|
if ($5 < Math_fround(HEAPF32[$1 >> 2] * Math_fround(.0010000000474974513)) ^ 1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_resampler($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
label$1 : {
|
|
$4 = HEAP32[$0 + 284 >> 2];
|
|
if (($4 | 0) <= ($3 | 0)) {
|
|
$6 = HEAP32[$0 + 292 >> 2];
|
|
if (($6 | 0) > ($4 | 0)) {
|
|
break label$1;
|
|
}
|
|
$5 = $0 + 168 | 0;
|
|
$4 = $4 - $6 << 1;
|
|
memcpy($5 + ($6 << 1) | 0, $2, $4);
|
|
label$3 : {
|
|
label$4 : {
|
|
switch (HEAP32[$0 + 264 >> 2] - 1 | 0) {
|
|
case 0:
|
|
silk_resampler_private_up2_HQ_wrapper($0, $1, $5, HEAP32[$0 + 284 >> 2]);
|
|
silk_resampler_private_up2_HQ_wrapper($0, (HEAP32[$0 + 288 >> 2] << 1) + $1 | 0, $2 + $4 | 0, $3 - HEAP32[$0 + 284 >> 2] | 0);
|
|
break label$3;
|
|
case 1:
|
|
silk_resampler_private_IIR_FIR($0, $1, $5, HEAP32[$0 + 284 >> 2]);
|
|
silk_resampler_private_IIR_FIR($0, (HEAP32[$0 + 288 >> 2] << 1) + $1 | 0, $2 + $4 | 0, $3 - HEAP32[$0 + 284 >> 2] | 0);
|
|
break label$3;
|
|
case 2:
|
|
silk_resampler_private_down_FIR($0, $1, $5, HEAP32[$0 + 284 >> 2]);
|
|
silk_resampler_private_down_FIR($0, (HEAP32[$0 + 288 >> 2] << 1) + $1 | 0, $2 + $4 | 0, $3 - HEAP32[$0 + 284 >> 2] | 0);
|
|
break label$3;
|
|
default:
|
|
break label$4;
|
|
}
|
|
}
|
|
memcpy(memcpy($1, $5, HEAP32[$0 + 284 >> 2] << 1) + (HEAP32[$0 + 288 >> 2] << 1) | 0, $2 + $4 | 0, $3 - HEAP32[$0 + 284 >> 2] << 1);
|
|
}
|
|
$0 = HEAP32[$0 + 292 >> 2];
|
|
memcpy($5, ($3 - $0 << 1) + $2 | 0, $0 << 1);
|
|
return 0;
|
|
}
|
|
celt_fatal(6521, 6474, 184);
|
|
abort();
|
|
}
|
|
celt_fatal(6561, 6474, 186);
|
|
abort();
|
|
}
|
|
function silk_quant_LTP_gains_FLP($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
var $10 = 0, $11 = 0, $12 = 0, $13 = 0;
|
|
$11 = __stack_pointer - 528 | 0;
|
|
__stack_pointer = $11;
|
|
$13 = Math_imul($8, 25);
|
|
if (($13 | 0) > 0) {
|
|
while (1) {
|
|
$12 = $10 << 2;
|
|
HEAP32[$12 + ($11 + 80 | 0) >> 2] = lrintf(Math_fround(HEAPF32[$5 + $12 >> 2] * Math_fround(131072)));
|
|
$10 = $10 + 1 | 0;
|
|
if (($13 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$3 : {
|
|
if (($8 | 0) >= 1) {
|
|
$10 = Math_imul($8, 5);
|
|
$5 = ($10 | 0) > 1 ? $10 : 1;
|
|
$10 = 0;
|
|
while (1) {
|
|
$12 = $10 << 2;
|
|
HEAP32[$12 + $11 >> 2] = lrintf(Math_fround(HEAPF32[$6 + $12 >> 2] * Math_fround(131072)));
|
|
$10 = $10 + 1 | 0;
|
|
if (($10 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
silk_quant_LTP_gains($11 + 480 | 0, $1, $2, $3, $11 + 524 | 0, $11 + 80 | 0, $11, $7, $8, $9);
|
|
if (($8 | 0) < 1) {
|
|
break label$3;
|
|
}
|
|
$10 = Math_imul($8, 5);
|
|
$12 = ($10 | 0) > 1 ? $10 : 1;
|
|
$10 = 0;
|
|
while (1) {
|
|
HEAPF32[($10 << 2) + $0 >> 2] = Math_fround(HEAP16[($11 + 480 | 0) + ($10 << 1) >> 1]) * Math_fround(6103515625e-14);
|
|
$10 = $10 + 1 | 0;
|
|
if (($12 | 0) != ($10 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$3;
|
|
}
|
|
silk_quant_LTP_gains($11 + 480 | 0, $1, $2, $3, $11 + 524 | 0, $11 + 80 | 0, $11, $7, $8, $9);
|
|
}
|
|
HEAPF32[$4 >> 2] = Math_fround(HEAP32[$11 + 524 >> 2]) * Math_fround(.0078125);
|
|
__stack_pointer = $11 + 528 | 0;
|
|
}
|
|
function __vfprintf_internal($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0;
|
|
$5 = __stack_pointer - 208 | 0;
|
|
__stack_pointer = $5;
|
|
HEAP32[$5 + 204 >> 2] = $2;
|
|
$2 = 0;
|
|
memset($5 + 160 | 0, 0, 40);
|
|
HEAP32[$5 + 200 >> 2] = HEAP32[$5 + 204 >> 2];
|
|
label$1 : {
|
|
if ((printf_core(0, $1, $5 + 200 | 0, $5 + 80 | 0, $5 + 160 | 0, $3, $4) | 0) < 0) {
|
|
$1 = -1;
|
|
break label$1;
|
|
}
|
|
if (HEAP32[$0 + 76 >> 2] >= 0) {
|
|
$2 = __lockfile($0);
|
|
}
|
|
$6 = HEAP32[$0 >> 2];
|
|
if (HEAP8[$0 + 74 | 0] <= 0) {
|
|
HEAP32[$0 >> 2] = $6 & -33;
|
|
}
|
|
$6 = $6 & 32;
|
|
label$5 : {
|
|
if (HEAP32[$0 + 48 >> 2]) {
|
|
$4 = printf_core($0, $1, $5 + 200 | 0, $5 + 80 | 0, $5 + 160 | 0, $3, $4);
|
|
break label$5;
|
|
}
|
|
HEAP32[$0 + 48 >> 2] = 80;
|
|
HEAP32[$0 + 16 >> 2] = $5 + 80;
|
|
HEAP32[$0 + 28 >> 2] = $5;
|
|
HEAP32[$0 + 20 >> 2] = $5;
|
|
$7 = HEAP32[$0 + 44 >> 2];
|
|
HEAP32[$0 + 44 >> 2] = $5;
|
|
$1 = printf_core($0, $1, $5 + 200 | 0, $5 + 80 | 0, $5 + 160 | 0, $3, $4);
|
|
$4 = $1;
|
|
if (!$7) {
|
|
break label$5;
|
|
}
|
|
FUNCTION_TABLE[HEAP32[$0 + 36 >> 2]]($0, 0, 0) | 0;
|
|
HEAP32[$0 + 48 >> 2] = 0;
|
|
HEAP32[$0 + 44 >> 2] = $7;
|
|
HEAP32[$0 + 28 >> 2] = 0;
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
$3 = HEAP32[$0 + 20 >> 2];
|
|
HEAP32[$0 + 20 >> 2] = 0;
|
|
$4 = $3 ? $1 : -1;
|
|
}
|
|
$3 = HEAP32[$0 >> 2];
|
|
HEAP32[$0 >> 2] = $6 | $3;
|
|
$1 = $4;
|
|
$1 = $3 & 32 ? -1 : $1;
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
__unlockfile($0);
|
|
}
|
|
__stack_pointer = $5 + 208 | 0;
|
|
return $1;
|
|
}
|
|
function _celt_autocorr($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = 0, $11 = 0;
|
|
$7 = __stack_pointer;
|
|
$11 = $7;
|
|
$7 = $7 - (($5 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $7;
|
|
label$1 : {
|
|
if (($5 | 0) > 0) {
|
|
if (($3 | 0) <= -1) {
|
|
break label$1;
|
|
}
|
|
if ($3) {
|
|
$10 = memcpy($7, $0, $5 << 2);
|
|
$7 = 0;
|
|
while (1) {
|
|
$8 = $7 << 2;
|
|
$9 = HEAPF32[$8 + $2 >> 2];
|
|
HEAPF32[$8 + $10 >> 2] = HEAPF32[$0 + $8 >> 2] * $9;
|
|
$8 = ($7 ^ -1) + $5 << 2;
|
|
HEAPF32[$10 + $8 >> 2] = $9 * HEAPF32[$0 + $8 >> 2];
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$0 = $10;
|
|
}
|
|
$2 = $5 - $4 | 0;
|
|
celt_pitch_xcorr_c($0, $0, $1, $2, $4 + 1 | 0, $6);
|
|
$8 = 0;
|
|
if (($4 | 0) >= 0) {
|
|
while (1) {
|
|
$9 = Math_fround(0);
|
|
$7 = $8 + $2 | 0;
|
|
if (($7 | 0) < ($5 | 0)) {
|
|
while (1) {
|
|
$9 = Math_fround($9 + Math_fround(HEAPF32[($7 << 2) + $0 >> 2] * HEAPF32[($7 - $8 << 2) + $0 >> 2]));
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = ($8 << 2) + $1 | 0;
|
|
HEAPF32[$7 >> 2] = $9 + HEAPF32[$7 >> 2];
|
|
$7 = ($4 | 0) != ($8 | 0);
|
|
$8 = $8 + 1 | 0;
|
|
if ($7) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $11;
|
|
return 0;
|
|
}
|
|
celt_fatal(9687, 9671, 228);
|
|
abort();
|
|
}
|
|
celt_fatal(9709, 9671, 229);
|
|
abort();
|
|
}
|
|
function silk_biquad_alt_stride1($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0;
|
|
if (($5 | 0) >= 1) {
|
|
$7 = 0 - HEAP32[$2 + 4 >> 2] | 0;
|
|
$11 = $7 & 16383;
|
|
$2 = 0 - HEAP32[$2 >> 2] | 0;
|
|
$12 = $2 & 16383;
|
|
$13 = $7 << 2 >> 16;
|
|
$14 = $2 << 2 >> 16;
|
|
$6 = HEAP32[$3 + 4 >> 2];
|
|
$8 = HEAP32[$3 >> 2];
|
|
while (1) {
|
|
$15 = $10 << 1;
|
|
$2 = HEAP16[$15 + $0 >> 1];
|
|
$7 = HEAP32[$1 >> 2];
|
|
$7 = (Math_imul($2, $7 >> 16) + $8 | 0) + (Math_imul($7 & 65535, $2) >> 16) << 2;
|
|
$8 = $7 >> 16;
|
|
$9 = Math_imul($14, $8) + $6 | 0;
|
|
$6 = $7 & 65532;
|
|
$16 = ($9 + (Math_imul($14, $6) >> 16) | 0) + ((Math_imul($8, $12) + (Math_imul($6, $12) >>> 16 | 0) >> 13) + 1 >> 1) | 0;
|
|
HEAP32[$3 >> 2] = $16;
|
|
$9 = HEAP32[$1 + 4 >> 2];
|
|
$6 = (Math_imul($8, $13) + (Math_imul($6, $13) >> 16) | 0) + ((Math_imul($8, $11) + (Math_imul($6, $11) >>> 16 | 0) >> 13) + 1 >> 1) | 0;
|
|
HEAP32[$3 + 4 >> 2] = $6;
|
|
$8 = (Math_imul($9 >> 16, $2) + (Math_imul($9 & 65535, $2) >> 16) | 0) + $16 | 0;
|
|
HEAP32[$3 >> 2] = $8;
|
|
$9 = HEAP32[$1 + 8 >> 2];
|
|
$6 = ((Math_imul($9 & 65535, $2) >> 16) + Math_imul($9 >> 16, $2) | 0) + $6 | 0;
|
|
HEAP32[$3 + 4 >> 2] = $6;
|
|
$2 = $7 + 16383 >> 14;
|
|
HEAP16[$4 + $15 >> 1] = ($7 | 0) > 536854528 ? 32767 : ($2 | 0) > -32768 ? $2 : -32768;
|
|
$10 = $10 + 1 | 0;
|
|
if (($10 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function downmix_float($0, $1, $2, $3, $4, $5, $6) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$5 = $5 | 0;
|
|
$6 = $6 | 0;
|
|
var $7 = 0, $8 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
if (($2 | 0) >= 1) {
|
|
while (1) {
|
|
HEAPF32[($7 << 2) + $1 >> 2] = HEAPF32[(Math_imul($3 + $7 | 0, $6) + $4 << 2) + $0 >> 2] * Math_fround(32768);
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($5 | 0) <= -1) {
|
|
break label$2;
|
|
}
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$7 = 0;
|
|
while (1) {
|
|
$4 = ($7 << 2) + $1 | 0;
|
|
HEAPF32[$4 >> 2] = HEAPF32[$4 >> 2] + Math_fround(HEAPF32[(Math_imul($3 + $7 | 0, $6) + $5 << 2) + $0 >> 2] * Math_fround(32768));
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($5 | 0) > -1) {
|
|
break label$1;
|
|
}
|
|
}
|
|
if (($5 | 0) != -2 | ($6 | 0) < 2) {
|
|
break label$1;
|
|
}
|
|
$5 = 1;
|
|
$8 = ($2 | 0) < 1;
|
|
while (1) {
|
|
$7 = 0;
|
|
if (!$8) {
|
|
while (1) {
|
|
$4 = ($7 << 2) + $1 | 0;
|
|
HEAPF32[$4 >> 2] = HEAPF32[$4 >> 2] + Math_fround(HEAPF32[(Math_imul($3 + $7 | 0, $6) + $5 << 2) + $0 >> 2] * Math_fround(32768));
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($6 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function alg_quant($0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
var $9 = 0, $10 = 0, $11 = Math_fround(0);
|
|
$8 = __stack_pointer;
|
|
$10 = $8;
|
|
label$1 : {
|
|
if (($2 | 0) > 0) {
|
|
if (($1 | 0) <= 1) {
|
|
break label$1;
|
|
}
|
|
$8 = $8 - (($1 << 2) + 27 & -16) | 0;
|
|
__stack_pointer = $8;
|
|
exp_rotation($0, $1, 1, $4, $2, $3);
|
|
$11 = op_pvq_search_c($0, $8, $2, $1, $5);
|
|
encode_pulses($8, $1, $2, $5);
|
|
if ($7) {
|
|
$6 = Math_fround(Math_fround(Math_fround(1) / Math_fround(Math_sqrt($11))) * $6);
|
|
$5 = 0;
|
|
while (1) {
|
|
$7 = $5 << 2;
|
|
HEAPF32[$7 + $0 >> 2] = $6 * Math_fround(HEAP32[$7 + $8 >> 2]);
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
exp_rotation($0, $1, -1, $4, $2, $3);
|
|
}
|
|
$3 = 1;
|
|
if (($4 | 0) >= 2) {
|
|
$9 = ($1 >>> 0) / ($4 >>> 0) | 0;
|
|
$0 = ($9 | 0) > 1 ? $9 : 1;
|
|
$3 = 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = Math_imul($2, $9);
|
|
$5 = 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$7 = HEAP32[($1 + $5 << 2) + $8 >> 2] | $7;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = (($7 | 0) != 0) << $2 | $3;
|
|
$2 = $2 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $10;
|
|
return $3;
|
|
}
|
|
celt_fatal(41540, 41599, 338);
|
|
abort();
|
|
}
|
|
celt_fatal(41609, 41599, 339);
|
|
abort();
|
|
}
|
|
function silk_NLSF_VQ_weights_laroia($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
|
|
label$1 : {
|
|
if (($2 | 0) > 0) {
|
|
$3 = 1;
|
|
if ($2 & 1) {
|
|
break label$1;
|
|
}
|
|
$5 = HEAP16[$1 >> 1];
|
|
$4 = HEAP16[$1 + 2 >> 1] - $5 | 0;
|
|
$4 = 131072 / ((($4 | 0) > 1 ? $4 : 1) >>> 0) | 0;
|
|
$5 = $4 + (131072 / ((($5 | 0) > 1 ? $5 : 1) >>> 0) | 0) | 0;
|
|
HEAP16[$0 >> 1] = $5 >>> 0 < 32767 ? $5 : 32767;
|
|
$6 = $2 - 1 | 0;
|
|
if (($2 | 0) >= 3) {
|
|
while (1) {
|
|
$2 = $3 << 1;
|
|
$8 = $2 + $0 | 0;
|
|
$5 = $2 + 2 | 0;
|
|
$7 = $5 + $1 | 0;
|
|
$2 = HEAP16[$7 >> 1] - HEAP16[$1 + $2 >> 1] | 0;
|
|
$2 = 131072 / ((($2 | 0) > 1 ? $2 : 1) >>> 0) | 0;
|
|
$4 = $4 + $2 | 0;
|
|
HEAP16[$8 >> 1] = $4 >>> 0 < 32767 ? $4 : 32767;
|
|
$3 = $3 + 2 | 0;
|
|
$4 = HEAP16[($3 << 1) + $1 >> 1] - HEAP16[$7 >> 1] | 0;
|
|
$4 = 131072 / ((($4 | 0) > 1 ? $4 : 1) >>> 0) | 0;
|
|
$2 = $4 + $2 | 0;
|
|
HEAP16[$0 + $5 >> 1] = $2 >>> 0 < 32767 ? $2 : 32767;
|
|
if (($3 | 0) < ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $6 << 1;
|
|
$0 = $3 + $0 | 0;
|
|
$3 = 32768 - HEAP16[$1 + $3 >> 1] | 0;
|
|
$3 = (131072 / ((($3 | 0) > 1 ? $3 : 1) >>> 0) | 0) + $4 | 0;
|
|
HEAP16[$0 >> 1] = $3 >>> 0 < 32767 ? $3 : 32767;
|
|
return;
|
|
}
|
|
celt_fatal(15465, 15489, 51);
|
|
abort();
|
|
}
|
|
celt_fatal(15519, 15489, 52);
|
|
abort();
|
|
}
|
|
function silk_NLSF_decode($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$6 = __stack_pointer - 80 | 0;
|
|
__stack_pointer = $6;
|
|
silk_NLSF_unpack($6 + 32 | 0, $6 - -64 | 0, $2, HEAP8[$1 | 0]);
|
|
$4 = HEAPU16[$2 + 2 >> 1];
|
|
$7 = $4 << 16 >> 16;
|
|
$9 = ($7 | 0) < 1;
|
|
if (!$9) {
|
|
$8 = HEAP16[$2 + 4 >> 1];
|
|
while (1) {
|
|
$5 = HEAP8[$1 + $4 | 0];
|
|
$3 = $5 << 10;
|
|
$5 = ($5 | 0) > 0 ? $3 - 102 | 0 : ($3 | 102) & $5 >> 31;
|
|
$3 = $4 - 1 | 0;
|
|
$10 = (Math_imul($5 >> 16, $8) + (Math_imul(HEAPU8[$3 + ($6 - -64 | 0) | 0], $10 << 16 >> 16) >> 8) | 0) + (Math_imul($5 & 65534, $8) >> 16) | 0;
|
|
HEAP16[($3 << 1) + $6 >> 1] = $10;
|
|
$5 = ($4 | 0) > 1;
|
|
$4 = $3;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$9) {
|
|
$4 = Math_imul(HEAP8[$1 | 0], $7);
|
|
$5 = $4 + HEAP32[$2 + 8 >> 2] | 0;
|
|
$8 = HEAP32[$2 + 12 >> 2] + ($4 << 1) | 0;
|
|
$4 = 0;
|
|
while (1) {
|
|
$3 = $4 << 1;
|
|
$1 = $3 + $0 | 0;
|
|
$3 = ((HEAP16[$3 + $6 >> 1] << 14) / HEAP16[$3 + $8 >> 1] | 0) + (HEAPU8[$4 + $5 | 0] << 7) | 0;
|
|
$3 = ($3 | 0) > 0 ? $3 : 0;
|
|
HEAP16[$1 >> 1] = ($3 | 0) < 32767 ? $3 : 32767;
|
|
$4 = $4 + 1 | 0;
|
|
$7 = HEAP16[$2 + 2 >> 1];
|
|
if (($4 | 0) < ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_NLSF_stabilize($0, HEAP32[$2 + 36 >> 2], $7);
|
|
__stack_pointer = $6 + 80 | 0;
|
|
}
|
|
function ec_enc_uint($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
label$1 : {
|
|
if ($2 >>> 0 > 1) {
|
|
$3 = $2 - 1 | 0;
|
|
if ($3 >>> 0 >= 256) {
|
|
$4 = 24 - Math_clz32($3) | 0;
|
|
$2 = $1 >>> $4 | 0;
|
|
ec_encode($0, $2, $2 + 1 | 0, ($3 >>> $4 | 0) + 1 | 0);
|
|
if (!$4) {
|
|
break label$1;
|
|
}
|
|
$7 = (-1 << $4 ^ -1) & $1;
|
|
$1 = HEAP32[$0 + 12 >> 2];
|
|
$2 = HEAP32[$0 + 16 >> 2];
|
|
$3 = $4 + $2 | 0;
|
|
label$4 : {
|
|
if ($3 >>> 0 < 33) {
|
|
$5 = $2;
|
|
break label$4;
|
|
}
|
|
while (1) {
|
|
$3 = -1;
|
|
$6 = HEAP32[$0 + 4 >> 2];
|
|
$5 = HEAP32[$0 + 8 >> 2];
|
|
if ($6 >>> 0 > $5 + HEAP32[$0 + 24 >> 2] >>> 0) {
|
|
$3 = $5 + 1 | 0;
|
|
HEAP32[$0 + 8 >> 2] = $3;
|
|
HEAP8[HEAP32[$0 >> 2] + ($6 - $3 | 0) | 0] = $1;
|
|
$3 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
$1 = $1 >>> 8 | 0;
|
|
$3 = ($2 | 0) > 15;
|
|
$5 = $2 - 8 | 0;
|
|
$2 = $5;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = $4 + $5 | 0;
|
|
}
|
|
HEAP32[$0 + 16 >> 2] = $3;
|
|
HEAP32[$0 + 12 >> 2] = $7 << $5 | $1;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $4;
|
|
return;
|
|
}
|
|
ec_encode($0, $1, $1 + 1 | 0, $2);
|
|
return;
|
|
}
|
|
celt_fatal(6995, 7019, 180);
|
|
abort();
|
|
}
|
|
celt_fatal(7033, 7019, 198);
|
|
abort();
|
|
}
|
|
function opus_encoder_create($0, $1, $2, $3) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
var $4 = 0, $5 = 0;
|
|
$5 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $5;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
if (($0 | 0) <= 15999) {
|
|
if (($0 | 0) == 8e3 | ($0 | 0) == 12e3) {
|
|
break label$4;
|
|
}
|
|
break label$3;
|
|
}
|
|
if (($0 | 0) == 16e3 | ($0 | 0) == 48e3) {
|
|
break label$4;
|
|
}
|
|
if (($0 | 0) != 24e3) {
|
|
break label$3;
|
|
}
|
|
}
|
|
if ($1 - 1 >>> 0 > 1) {
|
|
break label$3;
|
|
}
|
|
$4 = $2 - 2048 | 0;
|
|
if ($4 >>> 0 > 3) {
|
|
break label$3;
|
|
}
|
|
if (($4 | 0) != 2) {
|
|
break label$2;
|
|
}
|
|
}
|
|
$4 = 0;
|
|
if (!$3) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 >> 2] = -1;
|
|
break label$1;
|
|
}
|
|
$4 = 0;
|
|
if (!silk_Get_Encoder_Size($5 + 12 | 0)) {
|
|
HEAP32[$5 + 12 >> 2] = HEAP32[$5 + 12 >> 2] + 3 & -4;
|
|
$4 = (celt_encoder_get_size($1) + HEAP32[$5 + 12 >> 2] | 0) + 18140 | 0;
|
|
}
|
|
$4 = dlmalloc($4);
|
|
if (!$4) {
|
|
$4 = 0;
|
|
if (!$3) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 >> 2] = -7;
|
|
break label$1;
|
|
}
|
|
$0 = opus_encoder_init($4, $0, $1, $2);
|
|
if ($3) {
|
|
HEAP32[$3 >> 2] = $0;
|
|
}
|
|
if (!$0) {
|
|
break label$1;
|
|
}
|
|
dlfree($4);
|
|
$4 = 0;
|
|
}
|
|
__stack_pointer = $5 + 16 | 0;
|
|
return $4 | 0;
|
|
}
|
|
function deinterleave_hadamard($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$5 = __stack_pointer;
|
|
$9 = $5;
|
|
$8 = Math_imul($1, $2);
|
|
$5 = $5 - (($8 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $5;
|
|
if (($2 | 0) > 0) {
|
|
label$2 : {
|
|
if (!$3) {
|
|
$6 = ($1 | 0) < 1;
|
|
while (1) {
|
|
if (!$6) {
|
|
$7 = Math_imul($1, $4);
|
|
$3 = 0;
|
|
while (1) {
|
|
HEAP32[($3 + $7 << 2) + $5 >> 2] = HEAP32[(Math_imul($2, $3) + $4 << 2) + $0 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$2;
|
|
}
|
|
$10 = ($2 << 2) + 41976 | 0;
|
|
$6 = ($1 | 0) < 1;
|
|
while (1) {
|
|
if (!$6) {
|
|
$7 = Math_imul(HEAP32[($4 << 2) + $10 >> 2], $1);
|
|
$3 = 0;
|
|
while (1) {
|
|
HEAP32[($3 + $7 << 2) + $5 >> 2] = HEAP32[(Math_imul($2, $3) + $4 << 2) + $0 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memcpy($0, $5, $8 << 2);
|
|
__stack_pointer = $9;
|
|
return;
|
|
}
|
|
celt_fatal(41952, 41800, 591);
|
|
abort();
|
|
}
|
|
function ec_laplace_encode($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
$7 = HEAP32[$1 >> 2];
|
|
if ($7) {
|
|
$5 = 1;
|
|
$4 = Math_imul(16384 - $3 | 0, 32736 - $2 | 0) >>> 15 | 0;
|
|
$6 = $7 >> 31;
|
|
$8 = $6 ^ $6 + $7;
|
|
label$5 : {
|
|
if (!$4 | ($8 | 0) < 2) {
|
|
break label$5;
|
|
}
|
|
while (1) {
|
|
$9 = $4 << 1;
|
|
$4 = Math_imul($9, $3) >>> 15 | 0;
|
|
$2 = ($2 + $9 | 0) + 2 | 0;
|
|
$5 = $5 + 1 | 0;
|
|
if (($8 | 0) <= ($5 | 0)) {
|
|
break label$5;
|
|
}
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
label$7 : {
|
|
if (!$4) {
|
|
$3 = $5 + $6 | 0;
|
|
$4 = $8 - $5 | 0;
|
|
$5 = (($7 >>> 31 | 32768) - $2 >> 1) - 1 | 0;
|
|
$4 = ($4 | 0) < ($5 | 0) ? $4 : $5;
|
|
HEAP32[$1 >> 2] = $3 + $4 ^ $6;
|
|
$4 = ($2 + $6 | 0) + ($4 << 1 | 1) | 0;
|
|
$2 = ($4 | 0) != 32768;
|
|
break label$7;
|
|
}
|
|
$5 = $4 + 1 | 0;
|
|
$4 = ($5 & ($6 ^ -1)) + $2 | 0;
|
|
$2 = $5;
|
|
}
|
|
if ($2 + $4 >>> 0 >= 32769) {
|
|
break label$2;
|
|
}
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
}
|
|
ec_encode_bin($0, $4, $2 + $4 | 0, 15);
|
|
return;
|
|
}
|
|
celt_fatal(32848, 32879, 88);
|
|
abort();
|
|
}
|
|
celt_fatal(32894, 32879, 89);
|
|
abort();
|
|
}
|
|
function alg_unquant($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$7 = __stack_pointer;
|
|
$10 = $7;
|
|
label$1 : {
|
|
if (($2 | 0) > 0) {
|
|
if (($1 | 0) <= 1) {
|
|
break label$1;
|
|
}
|
|
$8 = $7 - (($1 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $8;
|
|
$6 = Math_fround(Math_fround(Math_fround(1) / Math_fround(Math_sqrt(decode_pulses($8, $1, $2, $5)))) * $6);
|
|
$5 = 0;
|
|
while (1) {
|
|
$7 = $5 << 2;
|
|
HEAPF32[$7 + $0 >> 2] = $6 * Math_fround(HEAP32[$7 + $8 >> 2]);
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
exp_rotation($0, $1, -1, $4, $2, $3);
|
|
$3 = 1;
|
|
if (($4 | 0) >= 2) {
|
|
$9 = ($1 >>> 0) / ($4 >>> 0) | 0;
|
|
$0 = ($9 | 0) > 1 ? $9 : 1;
|
|
$3 = 0;
|
|
$2 = 0;
|
|
while (1) {
|
|
$1 = Math_imul($2, $9);
|
|
$5 = 0;
|
|
$7 = 0;
|
|
while (1) {
|
|
$7 = HEAP32[($1 + $5 << 2) + $8 >> 2] | $7;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = (($7 | 0) != 0) << $2 | $3;
|
|
$2 = $2 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $10;
|
|
return $3;
|
|
}
|
|
celt_fatal(41673, 41599, 371);
|
|
abort();
|
|
}
|
|
celt_fatal(41734, 41599, 372);
|
|
abort();
|
|
}
|
|
function interleave_hadamard($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$5 = __stack_pointer;
|
|
$9 = $5;
|
|
$8 = Math_imul($1, $2);
|
|
$5 = $5 - (($8 << 2) + 15 & -16) | 0;
|
|
__stack_pointer = $5;
|
|
label$1 : {
|
|
if (!$3) {
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$6 = ($1 | 0) < 1;
|
|
while (1) {
|
|
if (!$6) {
|
|
$7 = Math_imul($1, $4);
|
|
$3 = 0;
|
|
while (1) {
|
|
HEAP32[(Math_imul($2, $3) + $4 << 2) + $5 >> 2] = HEAP32[($3 + $7 << 2) + $0 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
break label$1;
|
|
}
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$10 = ($2 << 2) + 41976 | 0;
|
|
$6 = ($1 | 0) < 1;
|
|
while (1) {
|
|
if (!$6) {
|
|
$7 = Math_imul(HEAP32[($4 << 2) + $10 >> 2], $1);
|
|
$3 = 0;
|
|
while (1) {
|
|
HEAP32[(Math_imul($2, $3) + $4 << 2) + $5 >> 2] = HEAP32[($3 + $7 << 2) + $0 >> 2];
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
memcpy($0, $5, $8 << 2);
|
|
__stack_pointer = $9;
|
|
}
|
|
function encode_pulses($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
label$1 : {
|
|
if (($2 | 0) > 0) {
|
|
if (($1 | 0) <= 1) {
|
|
break label$1;
|
|
}
|
|
$8 = $1 - 1 | 0;
|
|
$4 = HEAP32[($8 << 2) + $0 >> 2];
|
|
$5 = $4 >> 31;
|
|
$5 = $5 ^ $4 + $5;
|
|
$7 = $4 >>> 31 | 0;
|
|
while (1) {
|
|
$9 = $8 - 1 | 0;
|
|
$4 = $1 - $9 | 0;
|
|
$7 = HEAP32[HEAP32[((($4 | 0) < ($5 | 0) ? $4 : $5) << 2) + 36320 >> 2] + ((($4 | 0) > ($5 | 0) ? $4 : $5) << 2) >> 2] + $7 | 0;
|
|
$6 = HEAP32[($9 << 2) + $0 >> 2];
|
|
$10 = $6 >> 31;
|
|
$5 = ($10 ^ $6 + $10) + $5 | 0;
|
|
if (($6 | 0) <= -1) {
|
|
$6 = $5 + 1 | 0;
|
|
$7 = HEAP32[HEAP32[((($4 | 0) > ($5 | 0) ? $6 : $4) << 2) + 36320 >> 2] + ((($4 | 0) > ($6 | 0) ? $4 : $6) << 2) >> 2] + $7 | 0;
|
|
}
|
|
$4 = ($8 | 0) > 1;
|
|
$8 = $9;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = $2 + 1 | 0;
|
|
$4 = ($1 | 0) > ($2 | 0);
|
|
ec_enc_uint($3, $7, HEAP32[HEAP32[(($4 ? $5 : $1) << 2) + 36320 >> 2] + ((($1 | 0) > ($5 | 0) ? $1 : $5) << 2) >> 2] + HEAP32[HEAP32[((($1 | 0) < ($2 | 0) ? $1 : $2) << 2) + 36320 >> 2] + (($4 ? $1 : $2) << 2) >> 2] | 0);
|
|
return;
|
|
}
|
|
celt_fatal(36272, 36295, 459);
|
|
abort();
|
|
}
|
|
celt_fatal(36380, 36295, 444);
|
|
abort();
|
|
}
|
|
function silk_apply_sine_window_FLP($0, $1, $2, $3) {
|
|
var $4 = Math_fround(0), $5 = Math_fround(0), $6 = 0, $7 = Math_fround(0), $8 = 0;
|
|
label$1 : {
|
|
if ($2 - 1 >>> 0 < 2) {
|
|
if ($3 & 3) {
|
|
break label$1;
|
|
}
|
|
if (($3 | 0) >= 1) {
|
|
$4 = Math_fround(Math_fround(3.1415927410125732) / Math_fround($3 + 1 | 0));
|
|
$7 = Math_fround(Math_fround(2) - Math_fround($4 * $4));
|
|
$2 = ($2 | 0) < 2;
|
|
$4 = $2 ? $4 : Math_fround($7 * Math_fround(.5));
|
|
$5 = $2 ? Math_fround(0) : Math_fround(1);
|
|
while (1) {
|
|
$2 = $8 << 2;
|
|
HEAPF32[$2 + $0 >> 2] = Math_fround($5 + $4) * Math_fround(HEAPF32[$1 + $2 >> 2] * Math_fround(.5));
|
|
$6 = $2 | 4;
|
|
HEAPF32[$6 + $0 >> 2] = $4 * HEAPF32[$1 + $6 >> 2];
|
|
$6 = $2 | 8;
|
|
$5 = Math_fround(Math_fround($7 * $4) - $5);
|
|
HEAPF32[$6 + $0 >> 2] = Math_fround($4 + $5) * Math_fround(HEAPF32[$1 + $6 >> 2] * Math_fround(.5));
|
|
$2 = $2 | 12;
|
|
HEAPF32[$2 + $0 >> 2] = $5 * HEAPF32[$1 + $2 >> 2];
|
|
$4 = Math_fround(Math_fround($7 * $5) - $4);
|
|
$8 = $8 + 4 | 0;
|
|
if (($8 | 0) < ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(9375, 9424, 48);
|
|
abort();
|
|
}
|
|
celt_fatal(9459, 9424, 51);
|
|
abort();
|
|
}
|
|
function silk_sum_sqr_shift($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$9 = $3 - 1 | 0;
|
|
$10 = Math_clz32($3);
|
|
$7 = 31 - $10 | 0;
|
|
label$1 : {
|
|
if (($3 | 0) < 2) {
|
|
$5 = $3;
|
|
break label$1;
|
|
}
|
|
$5 = $3;
|
|
while (1) {
|
|
$6 = $4 << 1;
|
|
$8 = HEAP16[($6 | 2) + $2 >> 1];
|
|
$6 = HEAP16[$2 + $6 >> 1];
|
|
$5 = (Math_imul($8, $8) + Math_imul($6, $6) >>> $7 | 0) + $5 | 0;
|
|
$4 = $4 + 2 | 0;
|
|
if (($9 | 0) > ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $3 & -2;
|
|
}
|
|
$6 = 0;
|
|
if (($3 | 0) > ($4 | 0)) {
|
|
$4 = HEAP16[($4 << 1) + $2 >> 1];
|
|
$5 = (Math_imul($4, $4) >>> $7 | 0) + $5 | 0;
|
|
}
|
|
$4 = 34 - (Math_clz32($5) + $10 | 0) | 0;
|
|
$7 = ($4 | 0) > 0 ? $4 : 0;
|
|
if (($3 | 0) < 2) {
|
|
$4 = 0;
|
|
} else {
|
|
$4 = 0;
|
|
while (1) {
|
|
$5 = $4 << 1;
|
|
$8 = HEAP16[($5 | 2) + $2 >> 1];
|
|
$5 = HEAP16[$2 + $5 >> 1];
|
|
$6 = (Math_imul($8, $8) + Math_imul($5, $5) >>> $7 | 0) + $6 | 0;
|
|
$4 = $4 + 2 | 0;
|
|
if (($9 | 0) > ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $3 & -2;
|
|
}
|
|
if (($4 | 0) < ($3 | 0)) {
|
|
$2 = HEAP16[($4 << 1) + $2 >> 1];
|
|
$6 = (Math_imul($2, $2) >>> $7 | 0) + $6 | 0;
|
|
}
|
|
HEAP32[$1 >> 2] = $7;
|
|
HEAP32[$0 >> 2] = $6;
|
|
}
|
|
function sinc($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = Math_fround(0), $9 = 0, $10 = Math_fround(0), $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0;
|
|
$4 = +$1;
|
|
$6 = Math_abs($4);
|
|
if ($6 < 1e-6) {
|
|
return $0;
|
|
}
|
|
$7 = +($2 | 0);
|
|
if (!($7 * .5 < $6)) {
|
|
$1 = Math_fround($0 * $1);
|
|
$2 = HEAP32[$3 >> 2];
|
|
$8 = Math_fround(Math_fround(Math_abs(Math_fround(($4 + $4) / $7))) * Math_fround(HEAP32[$3 + 4 >> 2]));
|
|
$10 = Math_fround(Math_floor($8));
|
|
label$3 : {
|
|
if (Math_fround(Math_abs($10)) < Math_fround(2147483648)) {
|
|
$3 = ~~$10;
|
|
break label$3;
|
|
}
|
|
$3 = -2147483648;
|
|
}
|
|
$2 = $2 + ($3 << 3) | 0;
|
|
$6 = HEAPF64[$2 + 8 >> 3];
|
|
$7 = HEAPF64[$2 >> 3];
|
|
$13 = HEAPF64[$2 + 16 >> 3];
|
|
$9 = HEAPF64[$2 + 24 >> 3];
|
|
$4 = +$1 * 3.141592653589793;
|
|
$14 = sin($4) * +$0 / $4;
|
|
$1 = Math_fround($8 - Math_fround($3 | 0));
|
|
$0 = Math_fround($1 * $1);
|
|
$5 = +Math_fround($1 * $0);
|
|
$11 = $5 * .1666666667;
|
|
$4 = +$1;
|
|
$12 = $11 - $4 * .1666666667;
|
|
$15 = $9 * $12;
|
|
$9 = +$0 * .5;
|
|
$5 = $9 + $4 - $5 * .5;
|
|
$4 = $9 + $4 * -.3333333333 - $11;
|
|
$8 = Math_fround($14 * ($15 + ($13 * $5 + ($7 * $4 + $6 * (1 - $12 - $5 - $4)))));
|
|
}
|
|
return $8;
|
|
}
|
|
function compute_band_energies($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = 0, $11 = 0, $12 = 0, $13 = Math_fround(0), $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0;
|
|
$14 = ($4 | 0) > 1 ? $4 : 1;
|
|
$15 = HEAP32[$0 + 44 >> 2] << $5;
|
|
$10 = HEAP32[$0 + 32 >> 2];
|
|
while (1) {
|
|
if (($3 | 0) >= 1) {
|
|
$16 = Math_imul($7, $15);
|
|
$17 = Math_imul(HEAP32[$0 + 8 >> 2], $7);
|
|
$8 = HEAPU16[$10 >> 1];
|
|
$6 = 0;
|
|
while (1) {
|
|
$4 = $8 << 16;
|
|
$9 = Math_fround(0);
|
|
$11 = $6 + 1 | 0;
|
|
$8 = HEAP16[($11 << 1) + $10 >> 1];
|
|
$4 = $4 >> 16;
|
|
$12 = $8 - $4 << $5;
|
|
if (($12 | 0) >= 1) {
|
|
$18 = (($4 << $5) + $16 << 2) + $1 | 0;
|
|
$4 = 0;
|
|
while (1) {
|
|
$13 = HEAPF32[($4 << 2) + $18 >> 2];
|
|
$9 = Math_fround($9 + Math_fround($13 * $13));
|
|
$4 = $4 + 1 | 0;
|
|
if (($12 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[($6 + $17 << 2) + $2 >> 2] = Math_sqrt(Math_fround($9 + Math_fround(1.0000000272452012e-27)));
|
|
$6 = $11;
|
|
if (($6 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$7 = $7 + 1 | 0;
|
|
if (($14 | 0) != ($7 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function opus_encode_float($0, $1, $2, $3, $4) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
$9 = -1;
|
|
$5 = HEAP32[$0 + 144 >> 2];
|
|
$7 = ($5 | 0) / 400 | 0;
|
|
label$1 : {
|
|
if (($7 | 0) > ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
$6 = $2;
|
|
$8 = HEAP32[$0 + 156 >> 2];
|
|
if (($8 | 0) != 5e3) {
|
|
$6 = $8 - 5001 | 0;
|
|
if ($6 >>> 0 > 8) {
|
|
break label$1;
|
|
}
|
|
$6 = ($8 | 0) <= 5005 ? $7 << $6 : (Math_imul($8 - 5003 | 0, $5) | 0) / 50 | 0;
|
|
if (($6 | 0) > ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
}
|
|
label$5 : {
|
|
if ((Math_imul($6, 100) | 0) == ($5 | 0) | (Math_imul($6, 400) | 0) == ($5 | 0) | (Math_imul($6, 200) | 0) == ($5 | 0)) {
|
|
break label$5;
|
|
}
|
|
$7 = Math_imul($6, 50);
|
|
if (($7 | 0) == (Math_imul($5, 6) | 0) | (Math_imul($5, 5) | 0) == ($7 | 0) | ($5 << 2 == ($7 | 0) | (Math_imul($5, 3) | 0) == ($7 | 0))) {
|
|
break label$5;
|
|
}
|
|
if (($5 | 0) == ($7 | 0)) {
|
|
break label$5;
|
|
}
|
|
if ((Math_imul($6, 25) | 0) != ($5 | 0)) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$9 = $6;
|
|
}
|
|
return opus_encode_native($0, $1, $9, $3, $4, 24, $1, $2, 0, -2, HEAP32[$0 + 112 >> 2], 4, 1) | 0;
|
|
}
|
|
function silk_InitEncoder($0, $1, $2) {
|
|
var $3 = 0;
|
|
label$1 : {
|
|
$0 = memset($0, 0, 20216);
|
|
if (silk_init_encoder($0, $1)) {
|
|
break label$1;
|
|
}
|
|
if (silk_init_encoder($0 + 10064 | 0, $1)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 20192 >> 2] = 1;
|
|
HEAP32[$0 + 20196 >> 2] = 1;
|
|
HEAP32[$2 >> 2] = 1;
|
|
HEAP32[$2 + 4 >> 2] = 1;
|
|
HEAP32[$2 + 8 >> 2] = HEAP32[$0 + 4556 >> 2];
|
|
HEAP32[$2 + 12 >> 2] = HEAP32[$0 + 4564 >> 2];
|
|
HEAP32[$2 + 16 >> 2] = HEAP32[$0 + 4568 >> 2];
|
|
HEAP32[$2 + 20 >> 2] = HEAP32[$0 + 4572 >> 2];
|
|
HEAP32[$2 + 24 >> 2] = HEAP32[$0 + 4612 >> 2];
|
|
HEAP32[$2 + 28 >> 2] = HEAP32[$0 + 4608 >> 2];
|
|
HEAP32[$2 + 32 >> 2] = HEAP32[$0 + 4616 >> 2];
|
|
HEAP32[$2 + 36 >> 2] = HEAP32[$0 + 4624 >> 2];
|
|
HEAP32[$2 + 40 >> 2] = HEAP32[$0 + 6088 >> 2];
|
|
HEAP32[$2 + 48 >> 2] = HEAP32[$0 + 6076 >> 2];
|
|
HEAP32[$2 + 52 >> 2] = HEAP32[$0 + 4676 >> 2];
|
|
$3 = HEAP32[$0 + 4576 >> 2];
|
|
HEAP32[$2 + 72 >> 2] = Math_imul($3 << 16 >> 16, 1e3);
|
|
HEAP32[$2 + 76 >> 2] = HEAP32[$0 + 4536 >> 2];
|
|
$1 = 0;
|
|
$1 = ($3 | 0) == 16 ? !HEAP32[$0 + 28 >> 2] : $1;
|
|
HEAP32[$2 + 80 >> 2] = $1;
|
|
return 0;
|
|
}
|
|
celt_fatal(17487, 17507, 85);
|
|
abort();
|
|
}
|
|
function silk_NLSF_VQ($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0;
|
|
if (!($5 & 1)) {
|
|
if (($4 | 0) >= 1) {
|
|
$12 = ($5 | 0) < 2;
|
|
while (1) {
|
|
$10 = $5;
|
|
$6 = 0;
|
|
$7 = 0;
|
|
if (!$12) {
|
|
while (1) {
|
|
$8 = $10 - 1 | 0;
|
|
$9 = $8 << 1;
|
|
$8 = Math_imul(HEAPU16[$9 + $1 >> 1] - (HEAPU8[$2 + $8 | 0] << 7) << 16 >> 16, HEAP16[$3 + $9 >> 1]);
|
|
$6 = $8 - ($6 >> 1) | 0;
|
|
$9 = $6;
|
|
$6 = $6 >> 31;
|
|
$13 = ($6 ^ $6 + $9) + $7 | 0;
|
|
$6 = $10 - 2 | 0;
|
|
$7 = $6 << 1;
|
|
$9 = Math_imul(HEAPU16[$7 + $1 >> 1] - (HEAPU8[$2 + $6 | 0] << 7) << 16 >> 16, HEAP16[$3 + $7 >> 1]);
|
|
$7 = $9 - ($8 >> 1) | 0;
|
|
$8 = $7;
|
|
$7 = $7 >> 31;
|
|
$7 = ($7 ^ $7 + $8) + $13 | 0;
|
|
$8 = ($10 | 0) > 3;
|
|
$10 = $6;
|
|
$6 = $9;
|
|
if ($8) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[($11 << 2) + $0 >> 2] = $7;
|
|
$2 = $2 + $5 | 0;
|
|
$3 = ($5 << 1) + $3 | 0;
|
|
$11 = $11 + 1 | 0;
|
|
if (($11 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(15720, 15761, 49);
|
|
abort();
|
|
}
|
|
function exp2($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0;
|
|
label$1 : {
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$1 = wasm2js_scratch_load_i32(1) | 0;
|
|
$5 = wasm2js_scratch_load_i32(0) | 0;
|
|
$3 = $1;
|
|
$1 = $1 & 2147483647;
|
|
label$2 : {
|
|
if ($1 >>> 0 >= 1083174912) {
|
|
if (!(($3 | 0) < 0 | $1 >>> 0 < 1083179008)) {
|
|
return $0 * 8.98846567431158e+307;
|
|
}
|
|
if ($1 >>> 0 >= 2146435072) {
|
|
return -1 / $0;
|
|
}
|
|
if ($0 <= -1075 ^ 1) {
|
|
break label$1;
|
|
}
|
|
$1 = $3;
|
|
$2 = 0;
|
|
if (($1 | 0) < -1 ? 1 : ($1 | 0) <= -1) {
|
|
break label$2;
|
|
}
|
|
break label$1;
|
|
}
|
|
if ($1 >>> 0 > 1016070143) {
|
|
break label$1;
|
|
}
|
|
$2 = $0 + 1;
|
|
}
|
|
return $2;
|
|
}
|
|
$2 = $0 + 26388279066624;
|
|
wasm2js_scratch_store_f64(+$2);
|
|
wasm2js_scratch_load_i32(1) | 0;
|
|
$1 = (wasm2js_scratch_load_i32(0) | 0) + 128 | 0;
|
|
$3 = $1 << 4 & 4080;
|
|
$4 = HEAPF64[$3 + 11024 >> 3];
|
|
$0 = $0 - ($2 + -26388279066624) - HEAPF64[($3 | 8) + 11024 >> 3];
|
|
return scalbn($4 + $4 * $0 * ($0 * ($0 * ($0 * ($0 * .0013333559164630223 + .009618129842126066) + .0555041086648214) + .2402265069591) + .6931471805599453), ($1 & -256) / 256 | 0);
|
|
}
|
|
function normalise_bands($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = Math_fround(0);
|
|
$13 = ($5 | 0) > 1 ? $5 : 1;
|
|
$14 = Math_imul(HEAP32[$0 + 44 >> 2], $6);
|
|
$11 = HEAP32[$0 + 32 >> 2];
|
|
while (1) {
|
|
if (($4 | 0) >= 1) {
|
|
$15 = Math_imul($8, $14);
|
|
$16 = Math_imul(HEAP32[$0 + 8 >> 2], $8);
|
|
$10 = HEAP16[$11 >> 1];
|
|
$9 = 0;
|
|
while (1) {
|
|
$5 = Math_imul($6, $10);
|
|
$7 = $9;
|
|
$9 = $7 + 1 | 0;
|
|
$10 = HEAP16[($9 << 1) + $11 >> 1];
|
|
$12 = Math_imul($10, $6);
|
|
if (($5 | 0) < ($12 | 0)) {
|
|
$17 = Math_fround(Math_fround(1) / Math_fround(HEAPF32[($7 + $16 << 2) + $3 >> 2] + Math_fround(1.0000000272452012e-27)));
|
|
while (1) {
|
|
$7 = $5 + $15 << 2;
|
|
HEAPF32[$7 + $2 >> 2] = $17 * HEAPF32[$1 + $7 >> 2];
|
|
$5 = $5 + 1 | 0;
|
|
if (($12 | 0) > ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($4 | 0) != ($9 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$8 = $8 + 1 | 0;
|
|
if (($13 | 0) != ($8 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function silk_ana_filt_bank_1($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
if (($4 | 0) >= 2) {
|
|
$4 = $4 >> 1;
|
|
$12 = ($4 | 0) > 1 ? $4 : 1;
|
|
$5 = HEAP32[$1 + 4 >> 2];
|
|
$6 = HEAP32[$1 >> 2];
|
|
$4 = 0;
|
|
while (1) {
|
|
$7 = $4 << 2;
|
|
$9 = HEAP16[($7 | 2) + $0 >> 1] << 10;
|
|
$8 = $9 - $5 | 0;
|
|
$8 = (Math_imul($8 & 65535, 10788) >>> 16 | 0) + Math_imul($8 >> 16, 10788) | 0;
|
|
$10 = $8 + $5 | 0;
|
|
$5 = HEAP16[$0 + $7 >> 1] << 10;
|
|
$6 = $5 - $6 | 0;
|
|
$11 = $4 << 1;
|
|
$7 = (Math_imul($6 >> 16, -24290) + (Math_imul($6 & 65535, -24290) >> 16) | 0) + $5 | 0;
|
|
$5 = $10 + $7 | 0;
|
|
HEAP16[$11 + $2 >> 1] = ($5 | 0) > 67107839 ? 32767 : ($5 | 0) < -67109888 ? -32768 : ($5 >>> 10 | 0) + 1 >>> 1 | 0;
|
|
$5 = $10 - $7 | 0;
|
|
HEAP16[$3 + $11 >> 1] = ($5 | 0) > 67107839 ? 32767 : ($5 | 0) < -67109888 ? -32768 : ($5 >>> 10 | 0) + 1 >>> 1 | 0;
|
|
$5 = $8 + $9 | 0;
|
|
$6 = $6 + $7 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($12 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$1 + 4 >> 2] = $5;
|
|
HEAP32[$1 >> 2] = $6;
|
|
}
|
|
}
|
|
function memchr($0, $1, $2) {
|
|
var $3 = 0, $4 = 0;
|
|
$3 = ($2 | 0) != 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
if (!$2 | !($0 & 3)) {
|
|
break label$3;
|
|
}
|
|
$4 = $1 & 255;
|
|
while (1) {
|
|
if (HEAPU8[$0 | 0] == ($4 | 0)) {
|
|
break label$2;
|
|
}
|
|
$0 = $0 + 1 | 0;
|
|
$2 = $2 - 1 | 0;
|
|
$3 = ($2 | 0) != 0;
|
|
if (!$2) {
|
|
break label$3;
|
|
}
|
|
if ($0 & 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
label$5 : {
|
|
if (HEAPU8[$0 | 0] == ($1 & 255) | $2 >>> 0 < 4) {
|
|
break label$5;
|
|
}
|
|
$4 = Math_imul($1 & 255, 16843009);
|
|
while (1) {
|
|
$3 = HEAP32[$0 >> 2] ^ $4;
|
|
if (($3 ^ -1) & $3 - 16843009 & -2139062144) {
|
|
break label$5;
|
|
}
|
|
$0 = $0 + 4 | 0;
|
|
$2 = $2 - 4 | 0;
|
|
if ($2 >>> 0 > 3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
$3 = $1 & 255;
|
|
while (1) {
|
|
if (HEAPU8[$0 | 0] == ($3 | 0)) {
|
|
return $0;
|
|
}
|
|
$0 = $0 + 1 | 0;
|
|
$2 = $2 - 1 | 0;
|
|
if ($2) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function resampler_basic_zero($0, $1, $2, $3, $4, $5) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$5 = $5 | 0;
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0, $12 = 0;
|
|
$2 = $1 << 2;
|
|
$7 = $2 + HEAP32[$0 + 64 >> 2] | 0;
|
|
$6 = HEAP32[$7 >> 2];
|
|
$1 = 0;
|
|
$8 = HEAP32[$0 + 60 >> 2] + $2 | 0;
|
|
$2 = HEAP32[$8 >> 2];
|
|
$9 = HEAP32[$3 >> 2];
|
|
label$1 : {
|
|
if (($2 | 0) >= ($9 | 0)) {
|
|
break label$1;
|
|
}
|
|
$3 = HEAP32[$0 + 12 >> 2];
|
|
$10 = HEAP32[$0 + 40 >> 2];
|
|
$11 = HEAP32[$0 + 36 >> 2];
|
|
$12 = HEAP32[$0 + 92 >> 2];
|
|
$1 = HEAP32[$5 >> 2];
|
|
$5 = ($1 | 0) > 0 ? $1 : 0;
|
|
$1 = 0;
|
|
while (1) {
|
|
if (($1 | 0) == ($5 | 0)) {
|
|
$1 = $5;
|
|
break label$1;
|
|
}
|
|
HEAP32[(Math_imul($1, $12) << 2) + $4 >> 2] = 0;
|
|
$0 = $6 + $10 | 0;
|
|
$6 = $0 - ($0 >>> 0 < $3 >>> 0 ? 0 : $3) | 0;
|
|
$1 = $1 + 1 | 0;
|
|
$2 = ($2 + $11 | 0) + ($0 >>> 0 >= $3 >>> 0) | 0;
|
|
if (($9 | 0) > ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$8 >> 2] = $2;
|
|
HEAP32[$7 >> 2] = $6;
|
|
return $1 | 0;
|
|
}
|
|
function ec_dec_bit_logp($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$2 = HEAP32[$0 + 28 >> 2];
|
|
$1 = $2 >>> $1 | 0;
|
|
$3 = HEAP32[$0 + 32 >> 2];
|
|
$6 = $1 >>> 0 > $3 >>> 0;
|
|
if (!$6) {
|
|
$3 = $3 - $1 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $3;
|
|
}
|
|
$2 = $6 ? $1 : $2 - $1 | 0;
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
if ($2 >>> 0 <= 8388608) {
|
|
$4 = HEAP32[$0 + 24 >> 2];
|
|
$8 = HEAP32[$0 + 40 >> 2];
|
|
$7 = HEAP32[$0 + 20 >> 2];
|
|
$10 = HEAP32[$0 + 4 >> 2];
|
|
while (1) {
|
|
$9 = $2 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $9;
|
|
$7 = $7 + 8 | 0;
|
|
HEAP32[$0 + 20 >> 2] = $7;
|
|
$1 = 0;
|
|
if ($4 >>> 0 < $10 >>> 0) {
|
|
$5 = $4 + 1 | 0;
|
|
HEAP32[$0 + 24 >> 2] = $5;
|
|
$1 = HEAPU8[HEAP32[$0 >> 2] + $4 | 0];
|
|
$4 = $5;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $1;
|
|
$3 = ($3 << 8 & 2147483392 | ($8 << 8 | $1) >>> 1 & 255) ^ 255;
|
|
HEAP32[$0 + 32 >> 2] = $3;
|
|
$5 = $2 >>> 0 < 32769;
|
|
$8 = $1;
|
|
$2 = $9;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $6;
|
|
}
|
|
function ec_dec_update($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
$4 = HEAP32[$0 + 36 >> 2];
|
|
$3 = Math_imul($4, $3 - $2 | 0);
|
|
$5 = HEAP32[$0 + 32 >> 2] - $3 | 0;
|
|
HEAP32[$0 + 32 >> 2] = $5;
|
|
$2 = $1 ? Math_imul($2 - $1 | 0, $4) : HEAP32[$0 + 28 >> 2] - $3 | 0;
|
|
HEAP32[$0 + 28 >> 2] = $2;
|
|
if ($2 >>> 0 <= 8388608) {
|
|
$3 = HEAP32[$0 + 24 >> 2];
|
|
$4 = HEAP32[$0 + 40 >> 2];
|
|
$7 = HEAP32[$0 + 20 >> 2];
|
|
$9 = HEAP32[$0 + 4 >> 2];
|
|
while (1) {
|
|
$8 = $2 << 8;
|
|
HEAP32[$0 + 28 >> 2] = $8;
|
|
$7 = $7 + 8 | 0;
|
|
HEAP32[$0 + 20 >> 2] = $7;
|
|
$1 = 0;
|
|
if ($3 >>> 0 < $9 >>> 0) {
|
|
$6 = $3 + 1 | 0;
|
|
HEAP32[$0 + 24 >> 2] = $6;
|
|
$1 = HEAPU8[HEAP32[$0 >> 2] + $3 | 0];
|
|
$3 = $6;
|
|
}
|
|
HEAP32[$0 + 40 >> 2] = $1;
|
|
$5 = ($5 << 8 & 2147483392 | ($4 << 8 | $1) >>> 1 & 255) ^ 255;
|
|
HEAP32[$0 + 32 >> 2] = $5;
|
|
$6 = $2 >>> 0 < 32769;
|
|
$4 = $1;
|
|
$2 = $8;
|
|
if ($6) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function wcrtomb($0, $1, $2) {
|
|
$2 = 1;
|
|
label$1 : {
|
|
if ($0) {
|
|
if ($1 >>> 0 <= 127) {
|
|
break label$1;
|
|
}
|
|
label$3 : {
|
|
if (!HEAP32[HEAP32[__pthread_self() + 172 >> 2] >> 2]) {
|
|
if (($1 & -128) == 57216) {
|
|
break label$1;
|
|
}
|
|
break label$3;
|
|
}
|
|
if ($1 >>> 0 <= 2047) {
|
|
HEAP8[$0 + 1 | 0] = $1 & 63 | 128;
|
|
HEAP8[$0 | 0] = $1 >>> 6 | 192;
|
|
return 2;
|
|
}
|
|
if (!(($1 & -8192) != 57344 ? $1 >>> 0 >= 55296 : 0)) {
|
|
HEAP8[$0 + 2 | 0] = $1 & 63 | 128;
|
|
HEAP8[$0 | 0] = $1 >>> 12 | 224;
|
|
HEAP8[$0 + 1 | 0] = $1 >>> 6 & 63 | 128;
|
|
return 3;
|
|
}
|
|
if ($1 - 65536 >>> 0 <= 1048575) {
|
|
HEAP8[$0 + 3 | 0] = $1 & 63 | 128;
|
|
HEAP8[$0 | 0] = $1 >>> 18 | 240;
|
|
HEAP8[$0 + 2 | 0] = $1 >>> 6 & 63 | 128;
|
|
HEAP8[$0 + 1 | 0] = $1 >>> 12 & 63 | 128;
|
|
return 4;
|
|
}
|
|
}
|
|
HEAP32[__errno_location() >> 2] = 25;
|
|
$2 = -1;
|
|
}
|
|
return $2;
|
|
}
|
|
HEAP8[$0 | 0] = $1;
|
|
return 1;
|
|
}
|
|
function opus_repacketizer_cat_impl($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
$5 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $5;
|
|
$4 = -4;
|
|
label$1 : {
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
label$2 : {
|
|
if (!HEAP32[$0 + 4 >> 2]) {
|
|
HEAP8[$0 | 0] = HEAPU8[$1 | 0];
|
|
HEAP32[$0 + 296 >> 2] = opus_packet_get_samples_per_frame($1, 8e3);
|
|
break label$2;
|
|
}
|
|
if ((HEAPU8[$1 | 0] ^ HEAPU8[$0 | 0]) >>> 0 > 3) {
|
|
break label$1;
|
|
}
|
|
}
|
|
$6 = opus_packet_get_nb_frames($1, $2);
|
|
if (($6 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$7 = HEAP32[$0 + 4 >> 2];
|
|
if ((Math_imul(HEAP32[$0 + 296 >> 2], $7 + $6 | 0) | 0) > 960) {
|
|
break label$1;
|
|
}
|
|
$4 = opus_packet_parse_impl($1, $2, $3, $5 + 15 | 0, (($7 << 2) + $0 | 0) + 8 | 0, (($7 << 1) + $0 | 0) + 200 | 0, 0, 0);
|
|
if (($4 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = HEAP32[$0 + 4 >> 2] + $6;
|
|
$4 = 0;
|
|
}
|
|
__stack_pointer = $5 + 16 | 0;
|
|
return $4;
|
|
}
|
|
function cos($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0;
|
|
$1 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $1;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$3 = wasm2js_scratch_load_i32(1) | 0;
|
|
wasm2js_scratch_load_i32(0) | 0;
|
|
$3 = $3 & 2147483647;
|
|
label$1 : {
|
|
if ($3 >>> 0 <= 1072243195) {
|
|
$2 = 1;
|
|
if ($3 >>> 0 < 1044816030) {
|
|
break label$1;
|
|
}
|
|
$2 = __cos($0, 0);
|
|
break label$1;
|
|
}
|
|
$2 = $0 - $0;
|
|
if ($3 >>> 0 >= 2146435072) {
|
|
break label$1;
|
|
}
|
|
label$3 : {
|
|
switch (__rem_pio2($0, $1) & 3) {
|
|
case 0:
|
|
$2 = __cos(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
|
|
break label$1;
|
|
case 1:
|
|
$2 = -__sin(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3], 1);
|
|
break label$1;
|
|
case 2:
|
|
$2 = -__cos(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
|
|
break label$1;
|
|
default:
|
|
break label$3;
|
|
}
|
|
}
|
|
$2 = __sin(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3], 1);
|
|
}
|
|
__stack_pointer = $1 + 16 | 0;
|
|
return $2;
|
|
}
|
|
function silk_resampler_down2($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
if (($3 | 0) >= 2) {
|
|
$3 = $3 >> 1;
|
|
$10 = ($3 | 0) > 1 ? $3 : 1;
|
|
$4 = HEAP32[$0 + 4 >> 2];
|
|
$5 = HEAP32[$0 >> 2];
|
|
$3 = 0;
|
|
while (1) {
|
|
$6 = $3 << 2;
|
|
$7 = HEAP16[$6 + $2 >> 1] << 10;
|
|
$5 = $7 - $5 | 0;
|
|
$7 = (Math_imul($5 >> 16, -25727) + (Math_imul($5 & 65535, -25727) >> 16) | 0) + $7 | 0;
|
|
$8 = $7 + $4 | 0;
|
|
$6 = HEAP16[($6 | 2) + $2 >> 1] << 10;
|
|
$4 = $6 - $4 | 0;
|
|
$4 = (Math_imul($4 & 65535, 9872) >>> 16 | 0) + Math_imul($4 >> 16, 9872) | 0;
|
|
$8 = $8 + $4 | 0;
|
|
$9 = ($8 >> 10) + 1 >> 1;
|
|
HEAP16[($3 << 1) + $1 >> 1] = ($8 | 0) > 67107839 ? 32767 : ($9 | 0) > -32768 ? $9 : -32768;
|
|
$4 = $4 + $6 | 0;
|
|
$5 = $5 + $7 | 0;
|
|
$3 = $3 + 1 | 0;
|
|
if (($10 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = $4;
|
|
HEAP32[$0 >> 2] = $5;
|
|
}
|
|
}
|
|
function celt_encoder_init($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0;
|
|
$5 = -1;
|
|
$4 = opus_custom_mode_create(48e3, 960, 0);
|
|
label$1 : {
|
|
if ($2 >>> 0 > 2) {
|
|
break label$1;
|
|
}
|
|
$5 = -7;
|
|
if (!$0 | !$4) {
|
|
break label$1;
|
|
}
|
|
$5 = 0;
|
|
$0 = memset($0, 0, Math_imul(((HEAP32[$4 + 4 >> 2] << 2) + (HEAP32[$4 + 8 >> 2] << 4) | 0) + 4096 | 0, $2) + 244 | 0);
|
|
HEAP32[$0 + 28 >> 2] = 1;
|
|
HEAP32[$0 + 32 >> 2] = 0;
|
|
HEAP32[$0 + 8 >> 2] = $2;
|
|
HEAP32[$0 + 4 >> 2] = $2;
|
|
HEAP32[$0 >> 2] = $4;
|
|
$2 = HEAP32[$4 + 12 >> 2];
|
|
HEAP32[$0 + 24 >> 2] = 5;
|
|
HEAP32[$0 + 60 >> 2] = 24;
|
|
HEAP32[$0 + 12 >> 2] = 0;
|
|
HEAP32[$0 + 16 >> 2] = 1;
|
|
HEAP32[$0 + 40 >> 2] = -1;
|
|
HEAP32[$0 + 44 >> 2] = 0;
|
|
HEAP32[$0 + 72 >> 2] = $3;
|
|
HEAP32[$0 + 48 >> 2] = 1;
|
|
HEAP32[$0 + 52 >> 2] = 1;
|
|
HEAP32[$0 + 36 >> 2] = $2;
|
|
opus_custom_encoder_ctl($0, 4028, 0);
|
|
HEAP32[$0 + 28 >> 2] = resampling_factor($1);
|
|
}
|
|
return $5;
|
|
}
|
|
function __fwritex($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0;
|
|
$3 = HEAP32[$2 + 16 >> 2];
|
|
label$1 : {
|
|
if (!$3) {
|
|
if (__towrite($2)) {
|
|
break label$1;
|
|
}
|
|
$3 = HEAP32[$2 + 16 >> 2];
|
|
}
|
|
$5 = HEAP32[$2 + 20 >> 2];
|
|
if ($3 - $5 >>> 0 < $1 >>> 0) {
|
|
return FUNCTION_TABLE[HEAP32[$2 + 36 >> 2]]($2, $0, $1) | 0;
|
|
}
|
|
label$5 : {
|
|
if (HEAP8[$2 + 75 | 0] < 0) {
|
|
$3 = 0;
|
|
break label$5;
|
|
}
|
|
$4 = $1;
|
|
while (1) {
|
|
$3 = $4;
|
|
if (!$3) {
|
|
$3 = 0;
|
|
break label$5;
|
|
}
|
|
$4 = $3 - 1 | 0;
|
|
if (HEAPU8[$4 + $0 | 0] != 10) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = FUNCTION_TABLE[HEAP32[$2 + 36 >> 2]]($2, $0, $3) | 0;
|
|
if ($4 >>> 0 < $3 >>> 0) {
|
|
break label$1;
|
|
}
|
|
$0 = $0 + $3 | 0;
|
|
$1 = $1 - $3 | 0;
|
|
$5 = HEAP32[$2 + 20 >> 2];
|
|
}
|
|
memcpy($5, $0, $1);
|
|
HEAP32[$2 + 20 >> 2] = HEAP32[$2 + 20 >> 2] + $1;
|
|
$4 = $1 + $3 | 0;
|
|
}
|
|
return $4;
|
|
}
|
|
function sin($0) {
|
|
var $1 = 0, $2 = 0;
|
|
$1 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $1;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$2 = wasm2js_scratch_load_i32(1) | 0;
|
|
wasm2js_scratch_load_i32(0) | 0;
|
|
$2 = $2 & 2147483647;
|
|
label$1 : {
|
|
if ($2 >>> 0 <= 1072243195) {
|
|
if ($2 >>> 0 < 1045430272) {
|
|
break label$1;
|
|
}
|
|
$0 = __sin($0, 0, 0);
|
|
break label$1;
|
|
}
|
|
if ($2 >>> 0 >= 2146435072) {
|
|
$0 = $0 - $0;
|
|
break label$1;
|
|
}
|
|
label$4 : {
|
|
switch (__rem_pio2($0, $1) & 3) {
|
|
case 0:
|
|
$0 = __sin(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3], 1);
|
|
break label$1;
|
|
case 1:
|
|
$0 = __cos(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
|
|
break label$1;
|
|
case 2:
|
|
$0 = -__sin(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3], 1);
|
|
break label$1;
|
|
default:
|
|
break label$4;
|
|
}
|
|
}
|
|
$0 = -__cos(HEAPF64[$1 >> 3], HEAPF64[$1 + 8 >> 3]);
|
|
}
|
|
__stack_pointer = $1 + 16 | 0;
|
|
return $0;
|
|
}
|
|
function ec_enc_bits($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
if ($2) {
|
|
$6 = HEAP32[$0 + 12 >> 2];
|
|
$5 = HEAP32[$0 + 16 >> 2];
|
|
$3 = $5 + $2 | 0;
|
|
label$2 : {
|
|
if ($3 >>> 0 < 33) {
|
|
$4 = $5;
|
|
break label$2;
|
|
}
|
|
while (1) {
|
|
$3 = -1;
|
|
$7 = HEAP32[$0 + 4 >> 2];
|
|
$4 = HEAP32[$0 + 8 >> 2];
|
|
if ($7 >>> 0 > $4 + HEAP32[$0 + 24 >> 2] >>> 0) {
|
|
$3 = $4 + 1 | 0;
|
|
HEAP32[$0 + 8 >> 2] = $3;
|
|
HEAP8[HEAP32[$0 >> 2] + ($7 - $3 | 0) | 0] = $6;
|
|
$3 = 0;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = HEAP32[$0 + 44 >> 2] | $3;
|
|
$6 = $6 >>> 8 | 0;
|
|
$3 = ($5 | 0) > 15;
|
|
$4 = $5 - 8 | 0;
|
|
$5 = $4;
|
|
if ($3) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = $2 + $4 | 0;
|
|
}
|
|
HEAP32[$0 + 16 >> 2] = $3;
|
|
HEAP32[$0 + 12 >> 2] = $1 << $4 | $6;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $2;
|
|
return;
|
|
}
|
|
celt_fatal(7033, 7019, 198);
|
|
abort();
|
|
}
|
|
function speex_resampler_process_interleaved_float($0, $1, $2, $3, $4) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
$7 = HEAP32[$0 + 92 >> 2];
|
|
$8 = HEAP32[$2 >> 2];
|
|
$9 = HEAP32[$4 >> 2];
|
|
$5 = HEAP32[$0 + 20 >> 2];
|
|
HEAP32[$0 + 92 >> 2] = $5;
|
|
$10 = HEAP32[$0 + 88 >> 2];
|
|
HEAP32[$0 + 88 >> 2] = $5;
|
|
if ($5) {
|
|
$5 = 0;
|
|
while (1) {
|
|
HEAP32[$4 >> 2] = $9;
|
|
HEAP32[$2 >> 2] = $8;
|
|
label$3 : {
|
|
if ($1) {
|
|
$6 = $5 << 2;
|
|
speex_resampler_process_float($0, $5, $6 + $1 | 0, $2, $3 + $6 | 0, $4);
|
|
break label$3;
|
|
}
|
|
speex_resampler_process_float($0, $5, 0, $2, ($5 << 2) + $3 | 0, $4);
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if ($5 >>> 0 < HEAPU32[$0 + 20 >> 2]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 92 >> 2] = $7;
|
|
HEAP32[$0 + 88 >> 2] = $10;
|
|
return HEAP32[$0 + 84 >> 2] == 9 | 0;
|
|
}
|
|
function silk_VAD_Init($0) {
|
|
var $1 = 0;
|
|
$1 = $0;
|
|
HEAP32[$1 >> 2] = 0;
|
|
HEAP32[$1 + 4 >> 2] = 0;
|
|
HEAP32[$1 + 56 >> 2] = 0;
|
|
HEAP32[$1 + 60 >> 2] = 5e3;
|
|
HEAP32[$1 + 32 >> 2] = 0;
|
|
HEAP32[$1 + 36 >> 2] = 0;
|
|
HEAP32[$1 + 24 >> 2] = 0;
|
|
HEAP32[$1 + 28 >> 2] = 0;
|
|
HEAP32[$1 + 16 >> 2] = 0;
|
|
HEAP32[$1 + 20 >> 2] = 0;
|
|
HEAP32[$1 + 8 >> 2] = 0;
|
|
HEAP32[$1 + 12 >> 2] = 0;
|
|
HEAP32[$1 + 96 >> 2] = 25;
|
|
HEAP32[$1 + 100 >> 2] = 16;
|
|
HEAP32[$1 + 80 >> 2] = 858993;
|
|
HEAP32[$1 + 84 >> 2] = 1342177;
|
|
$1 = $1 - -64 | 0;
|
|
HEAP32[$1 >> 2] = 2500;
|
|
HEAP32[$1 + 4 >> 2] = 1600;
|
|
$1 = $0;
|
|
HEAP32[$1 + 104 >> 2] = 12;
|
|
HEAP32[$1 + 108 >> 2] = 15;
|
|
HEAP32[$1 + 88 >> 2] = 1789569;
|
|
HEAP32[$1 + 92 >> 2] = 50;
|
|
HEAP32[$1 + 72 >> 2] = 1200;
|
|
HEAP32[$1 + 76 >> 2] = 429496;
|
|
HEAP32[$1 + 40 >> 2] = 25600;
|
|
HEAP32[$1 + 44 >> 2] = 25600;
|
|
HEAP32[$1 + 48 >> 2] = 25600;
|
|
HEAP32[$1 + 52 >> 2] = 25600;
|
|
return 0;
|
|
}
|
|
function silk_residual_energy_FLP($0, $1, $2, $3, $4, $5, $6) {
|
|
var $7 = Math_fround(0), $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
$8 = __stack_pointer - 768 | 0;
|
|
__stack_pointer = $8;
|
|
$9 = $4 + $6 | 0;
|
|
$10 = $9 << 1;
|
|
silk_LPC_analysis_filter_FLP($8, $2, $1, $10, $6);
|
|
$7 = HEAPF32[$3 >> 2];
|
|
$11 = ($6 << 2) + $8 | 0;
|
|
HEAPF32[$0 >> 2] = silk_energy_FLP($11, $4) * +Math_fround($7 * $7);
|
|
$7 = HEAPF32[$3 + 4 >> 2];
|
|
$9 = ($9 << 2) + $11 | 0;
|
|
HEAPF32[$0 + 4 >> 2] = silk_energy_FLP($9, $4) * +Math_fround($7 * $7);
|
|
if (($5 | 0) == 4) {
|
|
silk_LPC_analysis_filter_FLP($8, $2 - -64 | 0, ($10 << 2) + $1 | 0, $10, $6);
|
|
$7 = HEAPF32[$3 + 8 >> 2];
|
|
HEAPF32[$0 + 8 >> 2] = silk_energy_FLP($11, $4) * +Math_fround($7 * $7);
|
|
$7 = HEAPF32[$3 + 12 >> 2];
|
|
HEAPF32[$0 + 12 >> 2] = silk_energy_FLP($9, $4) * +Math_fround($7 * $7);
|
|
}
|
|
__stack_pointer = $8 + 768 | 0;
|
|
}
|
|
function silk_gains_dequant($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
if (($4 | 0) >= 1) {
|
|
while (1) {
|
|
$5 = HEAP8[$1 + $7 | 0];
|
|
$9 = $2;
|
|
label$3 : {
|
|
if (!($3 | $7)) {
|
|
$6 = HEAP8[$2 | 0] - 16 | 0;
|
|
$5 = ($5 | 0) > ($6 | 0) ? $5 : $6;
|
|
break label$3;
|
|
}
|
|
$5 = $5 - 4 | 0;
|
|
$6 = HEAP8[$2 | 0];
|
|
$8 = $6 + 8 | 0;
|
|
if (($5 | 0) > ($8 | 0)) {
|
|
$5 = (($5 << 1) - $8 | 0) + $6 | 0;
|
|
break label$3;
|
|
}
|
|
$5 = $5 + $6 | 0;
|
|
}
|
|
$5 = $5 << 24 >> 24 > 0 ? $5 : 0;
|
|
$5 = $5 << 24 >> 24 < 63 ? $5 : 63;
|
|
HEAP8[$9 | 0] = $5;
|
|
$5 = $5 & 255;
|
|
$5 = (Math_imul($5, 7281) >>> 16 | 0) + Math_imul($5, 29) | 0;
|
|
HEAP32[($7 << 2) + $0 >> 2] = silk_log2lin(($5 >>> 0 < 1877 ? $5 : 1877) + 2090 | 0);
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_k2a_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = Math_fround(0), $8 = 0, $9 = 0, $10 = Math_fround(0), $11 = Math_fround(0), $12 = 0, $13 = 0;
|
|
$6 = 1;
|
|
if (($2 | 0) >= 1) {
|
|
while (1) {
|
|
$8 = $5 << 2;
|
|
$7 = HEAPF32[$8 + $1 >> 2];
|
|
$9 = $5 + 1 | 0;
|
|
if ($9 & 2147483646) {
|
|
$12 = $6 >>> 1 | 0;
|
|
$3 = 0;
|
|
while (1) {
|
|
$4 = ($3 << 2) + $0 | 0;
|
|
$13 = $4;
|
|
$10 = HEAPF32[$4 >> 2];
|
|
$4 = (($3 ^ -1) + $5 << 2) + $0 | 0;
|
|
$11 = HEAPF32[$4 >> 2];
|
|
HEAPF32[$13 >> 2] = $10 + Math_fround($7 * $11);
|
|
HEAPF32[$4 >> 2] = $11 + Math_fround($7 * $10);
|
|
$3 = $3 + 1 | 0;
|
|
if (($12 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAPF32[$0 + $8 >> 2] = -$7;
|
|
$6 = $6 + 1 | 0;
|
|
$5 = $9;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_encode_signs($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0;
|
|
$6 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $6;
|
|
HEAP8[$6 + 15 | 0] = 0;
|
|
if (($2 | 0) >= 8) {
|
|
$8 = Math_imul(($3 << 1) + $4 << 16 >> 16, 7) + 9232 | 0;
|
|
$2 = $2 + 8 >> 4;
|
|
$3 = ($2 | 0) > 1 ? $2 : 1;
|
|
while (1) {
|
|
$2 = HEAP32[($7 << 2) + $5 >> 2];
|
|
if (($2 | 0) >= 1) {
|
|
$2 = $2 & 31;
|
|
HEAP8[$6 + 14 | 0] = HEAPU8[($2 >>> 0 < 6 ? $2 : 6) + $8 | 0];
|
|
$2 = 0;
|
|
while (1) {
|
|
$4 = HEAPU8[$1 + $2 | 0];
|
|
if ($4) {
|
|
ec_enc_icdf($0, ($4 << 24 >> 24 >>> 7 | 0) + 1 & 255, $6 + 14 | 0, 8);
|
|
}
|
|
$2 = $2 + 1 | 0;
|
|
if (($2 | 0) != 16) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = $1 + 16 | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $6 + 16 | 0;
|
|
}
|
|
function haar1($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = Math_fround(0), $6 = Math_fround(0), $7 = 0, $8 = 0, $9 = 0, $10 = 0;
|
|
if (($2 | 0) >= 1) {
|
|
$3 = $1 >> 1;
|
|
$7 = ($3 | 0) > 1 ? $3 : 1;
|
|
$8 = $2 << 1;
|
|
$3 = 0;
|
|
$9 = ($1 | 0) < 2;
|
|
while (1) {
|
|
$1 = 0;
|
|
if (!$9) {
|
|
while (1) {
|
|
$4 = (Math_imul($1, $8) + $3 << 2) + $0 | 0;
|
|
$10 = $4;
|
|
$5 = Math_fround(HEAPF32[$4 >> 2] * Math_fround(.7071067690849304));
|
|
$4 = (Math_imul($1 << 1 | 1, $2) + $3 << 2) + $0 | 0;
|
|
$6 = Math_fround(HEAPF32[$4 >> 2] * Math_fround(.7071067690849304));
|
|
HEAPF32[$10 >> 2] = $5 + $6;
|
|
HEAPF32[$4 >> 2] = $5 - $6;
|
|
$1 = $1 + 1 | 0;
|
|
if (($7 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_find_LTP_FLP($0, $1, $2, $3, $4, $5) {
|
|
var $6 = Math_fround(0), $7 = 0, $8 = 0, $9 = Math_fround(0), $10 = 0;
|
|
if (($5 | 0) >= 1) {
|
|
$10 = $4 + 5 | 0;
|
|
while (1) {
|
|
$8 = ($2 - (HEAP32[($7 << 2) + $3 >> 2] << 2) | 0) - 8 | 0;
|
|
silk_corrMatrix_FLP($8, $4, 5, $0);
|
|
silk_corrVector_FLP($8, $2, $4, 5, $1);
|
|
$6 = Math_fround(silk_energy_FLP($2, $10));
|
|
$9 = Math_fround(Math_fround(Math_fround(HEAPF32[$0 >> 2] + HEAPF32[$0 + 96 >> 2]) * Math_fround(.014999999664723873)) + Math_fround(1));
|
|
$6 = Math_fround(Math_fround(1) / ($6 > $9 ? $6 : $9));
|
|
silk_scale_vector_FLP($0, $6, 25);
|
|
silk_scale_vector_FLP($1, $6, 5);
|
|
$1 = $1 + 20 | 0;
|
|
$0 = $0 + 100 | 0;
|
|
$2 = ($4 << 2) + $2 | 0;
|
|
$7 = $7 + 1 | 0;
|
|
if (($7 | 0) != ($5 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_stereo_encode_pred($0, $1) {
|
|
var $2 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
$2 = HEAP8[$1 + 5 | 0] + Math_imul(HEAP8[$1 + 2 | 0], 5) | 0;
|
|
if (($2 | 0) < 25) {
|
|
ec_enc_icdf($0, $2, 5776, 8);
|
|
$2 = HEAP8[$1 | 0];
|
|
if (($2 | 0) >= 3) {
|
|
break label$2;
|
|
}
|
|
if (HEAP8[$1 + 1 | 0] >= 5) {
|
|
break label$1;
|
|
}
|
|
ec_enc_icdf($0, $2, 5854, 8);
|
|
ec_enc_icdf($0, HEAP8[$1 + 1 | 0], 5861, 8);
|
|
$2 = HEAP8[$1 + 3 | 0];
|
|
if (($2 | 0) > 2) {
|
|
break label$2;
|
|
}
|
|
if (HEAP8[$1 + 4 | 0] > 4) {
|
|
break label$1;
|
|
}
|
|
ec_enc_icdf($0, $2, 5854, 8);
|
|
ec_enc_icdf($0, HEAP8[$1 + 4 | 0], 5861, 8);
|
|
return;
|
|
}
|
|
celt_fatal(7150, 7175, 44);
|
|
abort();
|
|
}
|
|
celt_fatal(7201, 7175, 47);
|
|
abort();
|
|
}
|
|
celt_fatal(7236, 7175, 48);
|
|
abort();
|
|
}
|
|
function silk_encode_do_VAD_FLP($0, $1) {
|
|
var $2 = 0;
|
|
silk_VAD_GetSA_Q8_c($0, $0 + 5098 | 0);
|
|
$2 = HEAP32[$0 + 4532 >> 2];
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
if (!$1) {
|
|
if (($2 | 0) < 13) {
|
|
break label$3;
|
|
}
|
|
HEAP32[$0 + 4532 >> 2] = 12;
|
|
break label$3;
|
|
}
|
|
if (($2 | 0) > 12) {
|
|
break label$2;
|
|
}
|
|
}
|
|
$1 = 0;
|
|
HEAP8[$0 + 4765 | 0] = 0;
|
|
$2 = HEAP32[$0 + 6084 >> 2];
|
|
HEAP32[$0 + 6084 >> 2] = $2 + 1;
|
|
if (($2 | 0) >= 10) {
|
|
if (($2 | 0) < 30) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 6084 >> 2] = 10;
|
|
}
|
|
HEAP32[$0 + 6080 >> 2] = 0;
|
|
break label$1;
|
|
}
|
|
HEAP32[$0 + 6080 >> 2] = 0;
|
|
HEAP32[$0 + 6084 >> 2] = 0;
|
|
$1 = 1;
|
|
HEAP8[$0 + 4765 | 0] = 1;
|
|
}
|
|
HEAP8[(HEAP32[$0 + 5748 >> 2] + $0 | 0) + 4720 | 0] = $1;
|
|
}
|
|
function amp2Log2($0, $1, $2, $3, $4, $5) {
|
|
var $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
$8 = ($5 | 0) > 1 ? $5 : 1;
|
|
while (1) {
|
|
if (($1 | 0) >= 1) {
|
|
$9 = Math_imul(HEAP32[$0 + 8 >> 2], $6);
|
|
$5 = 0;
|
|
while (1) {
|
|
$7 = $5 + $9 << 2;
|
|
HEAPF32[$7 + $4 >> 2] = Math_fround(log(+HEAPF32[$3 + $7 >> 2]) * 1.4426950408889634) - HEAPF32[($5 << 2) + 32928 >> 2];
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($1 | 0) < ($2 | 0)) {
|
|
$7 = Math_imul(HEAP32[$0 + 8 >> 2], $6);
|
|
$5 = $1;
|
|
while (1) {
|
|
HEAP32[($5 + $7 << 2) + $4 >> 2] = -1050673152;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$6 = $6 + 1 | 0;
|
|
if (($8 | 0) != ($6 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function silk_process_NLSFs_FLP($0, $1, $2, $3) {
|
|
var $4 = 0;
|
|
$4 = __stack_pointer + -64 | 0;
|
|
__stack_pointer = $4;
|
|
silk_process_NLSFs($0, $4, $2, $3);
|
|
$2 = HEAP32[$0 + 4640 >> 2];
|
|
label$1 : {
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$0 = 0;
|
|
while (1) {
|
|
HEAPF32[($0 << 2) + $1 >> 2] = Math_fround(HEAP16[($0 << 1) + $4 >> 1]) * Math_fround(.000244140625);
|
|
$0 = $0 + 1 | 0;
|
|
if (($2 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($2 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$0 = 0;
|
|
while (1) {
|
|
HEAPF32[(($0 << 2) + $1 | 0) - -64 >> 2] = Math_fround(HEAP16[(($0 << 1) + $4 | 0) + 32 >> 1]) * Math_fround(.000244140625);
|
|
$0 = $0 + 1 | 0;
|
|
if (($2 | 0) != ($0 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $4 - -64 | 0;
|
|
}
|
|
function silk_inner_product_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
|
|
if (($2 | 0) > 3) {
|
|
$7 = $2 - 3 | 0;
|
|
while (1) {
|
|
$3 = $4 << 2;
|
|
$5 = $3 | 4;
|
|
$8 = +HEAPF32[$0 + $3 >> 2] * +HEAPF32[$1 + $3 >> 2] + +HEAPF32[$0 + $5 >> 2] * +HEAPF32[$1 + $5 >> 2];
|
|
$5 = $3 | 8;
|
|
$3 = $3 | 12;
|
|
$6 = $6 + ($8 + +HEAPF32[$5 + $0 >> 2] * +HEAPF32[$1 + $5 >> 2] + +HEAPF32[$3 + $0 >> 2] * +HEAPF32[$1 + $3 >> 2]);
|
|
$4 = $4 + 4 | 0;
|
|
if (($7 | 0) > ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$4 = $2 & -4;
|
|
}
|
|
if (($2 | 0) > ($4 | 0)) {
|
|
while (1) {
|
|
$3 = $4 << 2;
|
|
$6 = $6 + +HEAPF32[$3 + $0 >> 2] * +HEAPF32[$1 + $3 >> 2];
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $6;
|
|
}
|
|
function silk_bwexpander_32($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0;
|
|
$4 = $2 >> 16;
|
|
$5 = $1 - 1 | 0;
|
|
if (($1 | 0) >= 2) {
|
|
$7 = $2 - 65536 | 0;
|
|
$1 = 0;
|
|
while (1) {
|
|
$3 = ($1 << 2) + $0 | 0;
|
|
$8 = $3;
|
|
$3 = HEAP32[$3 >> 2];
|
|
$6 = $3 << 16 >> 16;
|
|
HEAP32[$8 >> 2] = ((Math_imul($6, $2 & 65535) >> 16) + Math_imul($4, $6) | 0) + Math_imul(($3 >> 15) + 1 >> 1, $2);
|
|
$2 = ((Math_imul($2, $7) >> 15) + 1 >> 1) + $2 | 0;
|
|
$4 = $2 >> 16;
|
|
$1 = $1 + 1 | 0;
|
|
if (($5 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = ($5 << 2) + $0 | 0;
|
|
$0 = $1;
|
|
$1 = HEAP32[$1 >> 2];
|
|
$3 = $1 << 16 >> 16;
|
|
HEAP32[$0 >> 2] = ((Math_imul($3, $2 & 65535) >> 16) + Math_imul($3, $4) | 0) + Math_imul(($1 >> 15) + 1 >> 1, $2);
|
|
}
|
|
function silk_NLSF_unpack($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
$4 = HEAP16[$2 + 2 >> 1];
|
|
if (($4 | 0) >= 1) {
|
|
$5 = HEAP32[$2 + 24 >> 2] + ((Math_imul($4 & 65535, $3) | 0) / 2 | 0) | 0;
|
|
$3 = 0;
|
|
while (1) {
|
|
$4 = HEAPU8[$5 | 0];
|
|
HEAP16[($3 << 1) + $0 >> 1] = Math_imul($4 >>> 1 & 7, 9);
|
|
HEAP8[$1 + $3 | 0] = HEAPU8[HEAP32[$2 + 20 >> 2] + (Math_imul(HEAP16[$2 + 2 >> 1] - 1 | 0, $4 & 1) + $3 | 0) | 0];
|
|
$6 = $3 | 1;
|
|
HEAP16[($6 << 1) + $0 >> 1] = Math_imul($4 >>> 5 | 0, 9);
|
|
HEAP8[$1 + $6 | 0] = HEAPU8[HEAP32[$2 + 20 >> 2] + (Math_imul(HEAP16[$2 + 2 >> 1] - 1 | 0, $4 >>> 4 & 1) + $6 | 0) | 0];
|
|
$5 = $5 + 1 | 0;
|
|
$3 = $3 + 2 | 0;
|
|
if (($3 | 0) < HEAP16[$2 + 2 >> 1]) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_insertion_sort_increasing_all_values_int16($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0;
|
|
$3 = 1;
|
|
if (($1 | 0) >= 1) {
|
|
if (($1 | 0) != 1) {
|
|
while (1) {
|
|
$5 = HEAP16[($3 << 1) + $0 >> 1];
|
|
$2 = $3;
|
|
label$4 : {
|
|
while (1) {
|
|
$6 = $2 - 1 | 0;
|
|
$4 = HEAP16[($6 << 1) + $0 >> 1];
|
|
if (($5 | 0) >= ($4 | 0)) {
|
|
break label$4;
|
|
}
|
|
HEAP16[($2 << 1) + $0 >> 1] = $4;
|
|
$4 = ($2 | 0) > 1;
|
|
$2 = $6;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$2 = 0;
|
|
}
|
|
HEAP16[($2 << 1) + $0 >> 1] = $5;
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(15671, 15659, 144);
|
|
abort();
|
|
}
|
|
function ec_dec_bits($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
$4 = HEAP32[$0 + 12 >> 2];
|
|
$2 = HEAP32[$0 + 16 >> 2];
|
|
label$1 : {
|
|
if ($2 >>> 0 >= $1 >>> 0) {
|
|
$6 = $2;
|
|
break label$1;
|
|
}
|
|
$3 = HEAP32[$0 + 8 >> 2];
|
|
$7 = HEAP32[$0 + 4 >> 2];
|
|
while (1) {
|
|
$5 = 0;
|
|
if ($3 >>> 0 < $7 >>> 0) {
|
|
$3 = $3 + 1 | 0;
|
|
HEAP32[$0 + 8 >> 2] = $3;
|
|
$5 = HEAPU8[HEAP32[$0 >> 2] + ($7 - $3 | 0) | 0];
|
|
}
|
|
$4 = $5 << $2 | $4;
|
|
$5 = ($2 | 0) < 17;
|
|
$6 = $2 + 8 | 0;
|
|
$2 = $6;
|
|
if ($5) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
HEAP32[$0 + 16 >> 2] = $6 - $1;
|
|
HEAP32[$0 + 12 >> 2] = $4 >>> $1;
|
|
HEAP32[$0 + 20 >> 2] = HEAP32[$0 + 20 >> 2] + $1;
|
|
return (-1 << $1 ^ -1) & $4;
|
|
}
|
|
function silk_scale_vector_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
|
|
$6 = $2 & 65532;
|
|
if ($6) {
|
|
while (1) {
|
|
$3 = $4 << 2;
|
|
$5 = $3 + $0 | 0;
|
|
HEAPF32[$5 >> 2] = HEAPF32[$5 >> 2] * $1;
|
|
$5 = ($3 | 4) + $0 | 0;
|
|
HEAPF32[$5 >> 2] = HEAPF32[$5 >> 2] * $1;
|
|
$5 = ($3 | 8) + $0 | 0;
|
|
HEAPF32[$5 >> 2] = HEAPF32[$5 >> 2] * $1;
|
|
$3 = ($3 | 12) + $0 | 0;
|
|
HEAPF32[$3 >> 2] = HEAPF32[$3 >> 2] * $1;
|
|
$4 = $4 + 4 | 0;
|
|
if ($6 >>> 0 > $4 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($2 | 0) > ($4 | 0)) {
|
|
while (1) {
|
|
$3 = ($4 << 2) + $0 | 0;
|
|
HEAPF32[$3 >> 2] = HEAPF32[$3 >> 2] * $1;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_scale_copy_vector_FLP($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
$7 = $3 & 65532;
|
|
if ($7) {
|
|
while (1) {
|
|
$4 = $5 << 2;
|
|
HEAPF32[$4 + $0 >> 2] = HEAPF32[$1 + $4 >> 2] * $2;
|
|
$6 = $4 | 4;
|
|
HEAPF32[$6 + $0 >> 2] = HEAPF32[$1 + $6 >> 2] * $2;
|
|
$6 = $4 | 8;
|
|
HEAPF32[$6 + $0 >> 2] = HEAPF32[$1 + $6 >> 2] * $2;
|
|
$4 = $4 | 12;
|
|
HEAPF32[$4 + $0 >> 2] = HEAPF32[$1 + $4 >> 2] * $2;
|
|
$5 = $5 + 4 | 0;
|
|
if ($7 >>> 0 > $5 >>> 0) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (($3 | 0) > ($5 | 0)) {
|
|
while (1) {
|
|
$4 = $5 << 2;
|
|
HEAPF32[$4 + $0 >> 2] = HEAPF32[$1 + $4 >> 2] * $2;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function fmt_u($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0, $6 = 0;
|
|
label$1 : {
|
|
if ($1 >>> 0 < 1) {
|
|
$5 = $0;
|
|
$3 = $1;
|
|
$6 = $3;
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$2 = $2 - 1 | 0;
|
|
$3 = $1;
|
|
$5 = __wasm_i64_udiv($0, $3, 10, 0);
|
|
$3 = i64toi32_i32$HIGH_BITS;
|
|
$6 = $3;
|
|
$4 = __wasm_i64_mul($5, $3, 10, 0);
|
|
$3 = $1;
|
|
HEAP8[$2 | 0] = $0 - $4 | 48;
|
|
$4 = $3 >>> 0 > 9;
|
|
$0 = $5;
|
|
$3 = $6;
|
|
$1 = $3;
|
|
if ($4) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = $5;
|
|
if ($4) {
|
|
while (1) {
|
|
$2 = $2 - 1 | 0;
|
|
$0 = ($4 >>> 0) / 10 | 0;
|
|
HEAP8[$2 | 0] = $4 - Math_imul($0, 10) | 48;
|
|
$1 = $4 >>> 0 > 9;
|
|
$4 = $0;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $2;
|
|
}
|
|
function silk_energy_FLP($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0, $6 = 0, $7 = 0;
|
|
if (($1 | 0) > 3) {
|
|
$7 = $1 - 3 | 0;
|
|
while (1) {
|
|
$5 = $3 << 2;
|
|
$2 = +HEAPF32[$5 + $0 >> 2];
|
|
$4 = $2 * $2;
|
|
$2 = +HEAPF32[($5 | 4) + $0 >> 2];
|
|
$4 = $4 + $2 * $2;
|
|
$2 = +HEAPF32[($5 | 8) + $0 >> 2];
|
|
$4 = $4 + $2 * $2;
|
|
$2 = +HEAPF32[($5 | 12) + $0 >> 2];
|
|
$6 = $6 + ($4 + $2 * $2);
|
|
$3 = $3 + 4 | 0;
|
|
if (($7 | 0) > ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$3 = $1 & -4;
|
|
}
|
|
if (($1 | 0) > ($3 | 0)) {
|
|
while (1) {
|
|
$2 = +HEAPF32[($3 << 2) + $0 >> 2];
|
|
$6 = $6 + $2 * $2;
|
|
$3 = $3 + 1 | 0;
|
|
if (($3 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $6;
|
|
}
|
|
function renormalise_vector($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = Math_fround(0), $6 = Math_fround(0);
|
|
label$1 : {
|
|
if (($1 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
$6 = HEAPF32[($4 << 2) + $0 >> 2];
|
|
$5 = Math_fround($5 + Math_fround($6 * $6));
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (($1 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$5 = Math_fround(Math_fround(Math_fround(1) / Math_fround(Math_sqrt(Math_fround($5 + Math_fround(1.0000000036274937e-15))))) * $2);
|
|
$4 = 0;
|
|
while (1) {
|
|
HEAPF32[$0 >> 2] = $5 * HEAPF32[$0 >> 2];
|
|
$0 = $0 + 4 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function hysteresis_decision($0, $1, $2, $3, $4) {
|
|
var $5 = 0;
|
|
label$1 : {
|
|
if (($3 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
while (1) {
|
|
if (HEAPF32[($5 << 2) + $1 >> 2] > $0) {
|
|
break label$1;
|
|
}
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
$5 = $3;
|
|
}
|
|
label$3 : {
|
|
label$4 : {
|
|
if (($4 | 0) < ($5 | 0)) {
|
|
$3 = $4 << 2;
|
|
if (Math_fround(HEAPF32[$3 + $1 >> 2] + HEAPF32[$2 + $3 >> 2]) > $0) {
|
|
break label$4;
|
|
}
|
|
}
|
|
if (($4 | 0) <= ($5 | 0)) {
|
|
break label$3;
|
|
}
|
|
$3 = ($4 << 2) - 4 | 0;
|
|
if (Math_fround(HEAPF32[$3 + $1 >> 2] - HEAPF32[$2 + $3 >> 2]) < $0 ^ 1) {
|
|
break label$3;
|
|
}
|
|
}
|
|
$5 = $4;
|
|
}
|
|
return $5;
|
|
}
|
|
function silk_LTP_scale_ctrl_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = Math_fround(0), $5 = 0;
|
|
$5 = $0 + 4769 | 0;
|
|
$3 = 0;
|
|
label$1 : {
|
|
if ($2) {
|
|
break label$1;
|
|
}
|
|
$3 = 2;
|
|
$4 = Math_fround(Math_fround(HEAPF32[$1 + 708 >> 2] * Math_fround(HEAP32[$0 + 5744 >> 2] + HEAP32[$0 + 4616 >> 2] | 0)) * Math_fround(.10000000149011612));
|
|
if ($4 > Math_fround(2)) {
|
|
break label$1;
|
|
}
|
|
$3 = 0;
|
|
if ($4 < Math_fround(0)) {
|
|
break label$1;
|
|
}
|
|
$3 = ~~$4;
|
|
if (Math_fround(Math_abs($4)) < Math_fround(2147483648)) {
|
|
break label$1;
|
|
}
|
|
$3 = -2147483648;
|
|
}
|
|
HEAP8[$5 | 0] = $3;
|
|
HEAPF32[$1 + 224 >> 2] = Math_fround(HEAP16[($3 << 1) + 5848 >> 1]) * Math_fround(6103515625e-14);
|
|
}
|
|
function scalbn($0, $1) {
|
|
label$1 : {
|
|
if (($1 | 0) >= 1024) {
|
|
$0 = $0 * 8.98846567431158e+307;
|
|
if (($1 | 0) < 2047) {
|
|
$1 = $1 - 1023 | 0;
|
|
break label$1;
|
|
}
|
|
$0 = $0 * 8.98846567431158e+307;
|
|
$1 = (($1 | 0) < 3069 ? $1 : 3069) - 2046 | 0;
|
|
break label$1;
|
|
}
|
|
if (($1 | 0) > -1023) {
|
|
break label$1;
|
|
}
|
|
$0 = $0 * 2.2250738585072014e-308;
|
|
if (($1 | 0) > -2045) {
|
|
$1 = $1 + 1022 | 0;
|
|
break label$1;
|
|
}
|
|
$0 = $0 * 2.2250738585072014e-308;
|
|
$1 = (($1 | 0) > -3066 ? $1 : -3066) + 2044 | 0;
|
|
}
|
|
$1 = $1 + 1023 << 20;
|
|
wasm2js_scratch_store_i32(0, 0);
|
|
wasm2js_scratch_store_i32(1, $1 | 0);
|
|
return $0 * +wasm2js_scratch_load_f64();
|
|
}
|
|
function silk_resampler_private_AR2($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0;
|
|
if (($4 | 0) >= 1) {
|
|
$5 = HEAP32[$0 >> 2];
|
|
$6 = HEAP16[$3 + 2 >> 1];
|
|
$7 = HEAP16[$3 >> 1];
|
|
$3 = 0;
|
|
while (1) {
|
|
$5 = (HEAP16[($3 << 1) + $2 >> 1] << 8) + $5 | 0;
|
|
HEAP32[($3 << 2) + $1 >> 2] = $5;
|
|
$9 = HEAP32[$0 + 4 >> 2];
|
|
$5 = $5 << 2;
|
|
$8 = $5 & 65532;
|
|
$5 = $5 >> 16;
|
|
HEAP32[$0 + 4 >> 2] = (Math_imul($8, $6) >> 16) + Math_imul($6, $5);
|
|
$5 = (Math_imul($5, $7) + $9 | 0) + (Math_imul($7, $8) >> 16) | 0;
|
|
HEAP32[$0 >> 2] = $5;
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_control_SNR($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0;
|
|
HEAP32[$0 + 4608 >> 2] = $1;
|
|
$2 = HEAP32[$0 + 4576 >> 2];
|
|
$1 = HEAP32[$0 + 4580 >> 2] == 2 ? ((($2 | 0) / -16 | 0) + $1 | 0) - 2e3 | 0 : $1;
|
|
$4 = 17024;
|
|
$3 = 106;
|
|
label$2 : {
|
|
label$3 : {
|
|
switch ($2 - 8 | 0) {
|
|
case 4:
|
|
$4 = 17136;
|
|
$3 = 154;
|
|
break label$2;
|
|
case 0:
|
|
break label$2;
|
|
default:
|
|
break label$3;
|
|
}
|
|
}
|
|
$4 = 17296;
|
|
$3 = 190;
|
|
}
|
|
$2 = 0;
|
|
$1 = (($1 + 200 | 0) / 400 | 0) - 10 | 0;
|
|
$1 = ($1 | 0) < ($3 | 0) ? $1 : $3;
|
|
if (($1 | 0) >= 1) {
|
|
$2 = Math_imul(HEAPU8[$1 + $4 | 0], 21);
|
|
}
|
|
HEAP32[$0 + 4716 >> 2] = $2;
|
|
return 0;
|
|
}
|
|
function opus_fft_c($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = Math_fround(0), $6 = 0, $7 = 0, $8 = 0, $9 = Math_fround(0);
|
|
if (($1 | 0) != ($2 | 0)) {
|
|
$4 = HEAP32[$0 >> 2];
|
|
if (($4 | 0) >= 1) {
|
|
$5 = HEAPF32[$0 + 4 >> 2];
|
|
$8 = HEAP32[$0 + 44 >> 2];
|
|
while (1) {
|
|
$6 = ($3 << 3) + $1 | 0;
|
|
$9 = HEAPF32[$6 >> 2];
|
|
$7 = (HEAP16[($3 << 1) + $8 >> 1] << 3) + $2 | 0;
|
|
HEAPF32[$7 + 4 >> 2] = $5 * HEAPF32[$6 + 4 >> 2];
|
|
HEAPF32[$7 >> 2] = $5 * $9;
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
opus_fft_impl($0, $2);
|
|
return;
|
|
}
|
|
celt_fatal(42376, 42433, 580);
|
|
abort();
|
|
}
|
|
function ec_enc_patch_initial_bits($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0;
|
|
if ($2 >>> 0 < 9) {
|
|
$3 = 8 - $2 | 0;
|
|
$4 = (-1 << $2 ^ -1) << $3;
|
|
if (HEAP32[$0 + 24 >> 2]) {
|
|
$2 = HEAP32[$0 >> 2];
|
|
HEAP8[$2 | 0] = HEAPU8[$2 | 0] & ($4 ^ -1) | $1 << $3;
|
|
return;
|
|
}
|
|
$5 = HEAP32[$0 + 40 >> 2];
|
|
if (($5 | 0) >= 0) {
|
|
HEAP32[$0 + 40 >> 2] = ($4 ^ -1) & $5 | $1 << $3;
|
|
return;
|
|
}
|
|
if (HEAPU32[$0 + 28 >> 2] <= -2147483648 >>> $2 >>> 0) {
|
|
HEAP32[$0 + 32 >> 2] = HEAP32[$0 + 32 >> 2] & ($4 << 23 ^ -1) | $1 << 31 - $2;
|
|
return;
|
|
}
|
|
HEAP32[$0 + 44 >> 2] = -1;
|
|
return;
|
|
}
|
|
celt_fatal(7059, 7019, 217);
|
|
abort();
|
|
}
|
|
function init_caps($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $10 = 0, $11 = 0;
|
|
$4 = HEAP32[$0 + 8 >> 2];
|
|
if (($4 | 0) >= 1) {
|
|
$9 = (($2 << 1) + $3 | 0) - 1 | 0;
|
|
$10 = HEAP32[$0 + 104 >> 2];
|
|
$7 = HEAP32[$0 + 32 >> 2];
|
|
$6 = HEAPU16[$7 >> 1];
|
|
while (1) {
|
|
$11 = $6 << 16;
|
|
$8 = $5 + 1 | 0;
|
|
$6 = HEAP16[($8 << 1) + $7 >> 1];
|
|
HEAP32[($5 << 2) + $1 >> 2] = Math_imul(HEAPU8[(Math_imul($4, $9) + $5 | 0) + $10 | 0] - -64 | 0, Math_imul($6 - ($11 >> 16) << $2, $3)) >> 2;
|
|
$5 = $8;
|
|
$4 = HEAP32[$0 + 8 >> 2];
|
|
if (($5 | 0) < ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function opus_packet_pad($0, $1, $2) {
|
|
var $3 = 0, $4 = 0;
|
|
$3 = __stack_pointer - 304 | 0;
|
|
__stack_pointer = $3;
|
|
$4 = -1;
|
|
label$1 : {
|
|
if (($1 | 0) < 1) {
|
|
break label$1;
|
|
}
|
|
$4 = 0;
|
|
if (($1 | 0) == ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
$4 = -1;
|
|
if (($1 | 0) > ($2 | 0)) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$3 + 4 >> 2] = 0;
|
|
$4 = opus_repacketizer_cat_impl($3, memmove(($0 + $2 | 0) - $1 | 0, $0, $1), $1, 0);
|
|
if ($4) {
|
|
break label$1;
|
|
}
|
|
$1 = opus_repacketizer_out_range_impl($3, 0, HEAP32[$3 + 4 >> 2], $0, $2, 0, 1);
|
|
$4 = $1 & $1 >> 31;
|
|
}
|
|
__stack_pointer = $3 + 304 | 0;
|
|
return $4;
|
|
}
|
|
function resampling_factor($0) {
|
|
var $1 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
label$3 : {
|
|
label$4 : {
|
|
if (($0 | 0) <= 15999) {
|
|
if (($0 | 0) == 8e3) {
|
|
break label$4;
|
|
}
|
|
if (($0 | 0) != 12e3) {
|
|
break label$3;
|
|
}
|
|
return 4;
|
|
}
|
|
if (($0 | 0) == 16e3) {
|
|
break label$2;
|
|
}
|
|
$1 = 1;
|
|
if (($0 | 0) == 48e3) {
|
|
break label$1;
|
|
}
|
|
if (($0 | 0) != 24e3) {
|
|
break label$3;
|
|
}
|
|
return 2;
|
|
}
|
|
return 6;
|
|
}
|
|
celt_fatal(1659, 1679, 84);
|
|
abort();
|
|
}
|
|
$1 = 3;
|
|
}
|
|
return $1;
|
|
}
|
|
function silk_interpolate($0, $1, $2, $3, $4) {
|
|
var $5 = 0, $6 = 0, $7 = 0;
|
|
label$1 : {
|
|
if (($3 | 0) > -1) {
|
|
if (($3 | 0) > 4) {
|
|
break label$1;
|
|
}
|
|
if (($4 | 0) > 0) {
|
|
while (1) {
|
|
$6 = $5 << 1;
|
|
$7 = HEAPU16[$6 + $1 >> 1];
|
|
HEAP16[$0 + $6 >> 1] = (Math_imul(HEAPU16[$2 + $6 >> 1] - $7 << 16 >> 16, $3) >>> 2 | 0) + $7;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($4 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
celt_fatal(15552, 15584, 45);
|
|
abort();
|
|
}
|
|
celt_fatal(15603, 15584, 46);
|
|
abort();
|
|
}
|
|
function opus_custom_mode_create($0, $1, $2) {
|
|
var $3 = 0;
|
|
label$1 : {
|
|
label$2 : {
|
|
$3 = ($0 | 0) != 48e3;
|
|
if ((($1 | 0) == 960 ? !$3 : 0) | (($1 & 2147483647) == 480 ? !$3 : 0)) {
|
|
break label$2;
|
|
}
|
|
$0 = ($0 | 0) != 48e3;
|
|
if ((($1 & 1073741823) == 240 ? !$0 : 0) | (($1 & 536870911) == 120 ? !$0 : 0)) {
|
|
break label$2;
|
|
}
|
|
$1 = 0;
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = -1;
|
|
break label$1;
|
|
}
|
|
$1 = 17996;
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
HEAP32[$2 >> 2] = 0;
|
|
return 17996;
|
|
}
|
|
return $1;
|
|
}
|
|
function _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0;
|
|
$4 = $2 >>> 16 | 0;
|
|
$5 = $0 >>> 16 | 0;
|
|
$3 = (Math_imul($4, $5) + Math_imul($1, $2) | 0) + Math_imul($3, $0) | 0;
|
|
$2 = $2 & 65535;
|
|
$0 = $0 & 65535;
|
|
$1 = Math_imul($2, $0);
|
|
$2 = ($1 >>> 16 | 0) + Math_imul($2, $5) | 0;
|
|
$3 = $3 + ($2 >>> 16 | 0) | 0;
|
|
$2 = Math_imul($0, $4) + ($2 & 65535) | 0;
|
|
i64toi32_i32$HIGH_BITS = $3 + ($2 >>> 16 | 0) | 0;
|
|
return $1 & 65535 | $2 << 16;
|
|
}
|
|
function is_digital_silence($0, $1, $2, $3) {
|
|
var $4 = Math_fround(0), $5 = Math_fround(0), $6 = Math_fround(0);
|
|
$1 = Math_imul($1, $2);
|
|
if (($1 | 0) >= 1) {
|
|
$2 = 0;
|
|
while (1) {
|
|
$4 = HEAPF32[($2 << 2) + $0 >> 2];
|
|
$6 = $4 > $6 ? $6 : $4;
|
|
$5 = $4 < $5 ? $5 : $4;
|
|
$2 = $2 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$4 = Math_fround(-$6);
|
|
return Math_fround(Math_fround(1) / Math_fround(1 << $3)) >= ($4 < $5 ? $5 : $4);
|
|
}
|
|
function dlrealloc($0, $1) {
|
|
var $2 = 0, $3 = 0;
|
|
if (!$0) {
|
|
return dlmalloc($1);
|
|
}
|
|
if ($1 >>> 0 >= 4294967232) {
|
|
HEAP32[__errno_location() >> 2] = 48;
|
|
return 0;
|
|
}
|
|
$2 = try_realloc_chunk($0 - 8 | 0, $1 >>> 0 < 11 ? 16 : $1 + 11 & -8);
|
|
if ($2) {
|
|
return $2 + 8 | 0;
|
|
}
|
|
$2 = dlmalloc($1);
|
|
if (!$2) {
|
|
return 0;
|
|
}
|
|
$3 = HEAP32[$0 - 4 >> 2];
|
|
$3 = ($3 & 3 ? -4 : -8) + ($3 & -8) | 0;
|
|
memcpy($2, $0, $1 >>> 0 > $3 >>> 0 ? $3 : $1);
|
|
dlfree($0);
|
|
return $2;
|
|
}
|
|
function silk_bwexpander_FLP($0, $1, $2) {
|
|
var $3 = Math_fround(0), $4 = 0, $5 = 0;
|
|
$4 = $1 - 1 | 0;
|
|
label$1 : {
|
|
if (($1 | 0) < 2) {
|
|
$3 = $2;
|
|
break label$1;
|
|
}
|
|
$1 = 0;
|
|
$3 = $2;
|
|
while (1) {
|
|
$5 = ($1 << 2) + $0 | 0;
|
|
HEAPF32[$5 >> 2] = $3 * HEAPF32[$5 >> 2];
|
|
$3 = Math_fround($3 * $2);
|
|
$1 = $1 + 1 | 0;
|
|
if (($4 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
$1 = ($4 << 2) + $0 | 0;
|
|
HEAPF32[$1 >> 2] = $3 * HEAPF32[$1 >> 2];
|
|
}
|
|
function silk_log2lin($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0;
|
|
$1 = 0;
|
|
label$1 : {
|
|
if (($0 | 0) < 0) {
|
|
break label$1;
|
|
}
|
|
$1 = 2147483647;
|
|
if (($0 | 0) > 3966) {
|
|
break label$1;
|
|
}
|
|
$1 = $0 & 127;
|
|
$2 = $0 >>> 7 | 0;
|
|
$3 = 1 << $2;
|
|
$0 = ($0 | 0) <= 2047 ? (Math_imul(Math_imul(128 - $1 | 0, $1), -174) >> 16) + $1 << $2 >> 7 : Math_imul((Math_imul(Math_imul(128 - $1 | 0, $1), -174) >> 16) + $1 | 0, $3 >>> 7 | 0);
|
|
$1 = $3 + $0 | 0;
|
|
}
|
|
return $1;
|
|
}
|
|
function silk_sigm_Q15($0) {
|
|
var $1 = 0;
|
|
label$1 : {
|
|
if (($0 | 0) <= -1) {
|
|
$1 = 0;
|
|
if (($0 | 0) < -191) {
|
|
break label$1;
|
|
}
|
|
$0 = 0 - $0 | 0;
|
|
$1 = $0 >>> 3 & 536870908;
|
|
return HEAP32[$1 + 1024 >> 2] - Math_imul(HEAP16[$1 + 1056 >> 1], $0 & 31) | 0;
|
|
}
|
|
$1 = 32767;
|
|
if (($0 | 0) > 191) {
|
|
break label$1;
|
|
}
|
|
$1 = $0 >>> 3 & 536870908;
|
|
$1 = Math_imul(HEAP16[$1 + 1056 >> 1], $0 & 31) + HEAP32[$1 + 1088 >> 2] | 0;
|
|
}
|
|
return $1;
|
|
}
|
|
function pad($0, $1, $2, $3, $4) {
|
|
var $5 = 0;
|
|
$5 = __stack_pointer - 256 | 0;
|
|
__stack_pointer = $5;
|
|
if (!($4 & 73728 | ($2 | 0) <= ($3 | 0))) {
|
|
$2 = $2 - $3 | 0;
|
|
$3 = $2 >>> 0 < 256;
|
|
memset($5, $1 & 255, $3 ? $2 : 256);
|
|
if (!$3) {
|
|
while (1) {
|
|
out($0, $5, 256);
|
|
$2 = $2 - 256 | 0;
|
|
if ($2 >>> 0 > 255) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
out($0, $5, $2);
|
|
}
|
|
__stack_pointer = $5 + 256 | 0;
|
|
}
|
|
function __stdio_seek($0, $1, $2, $3) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
var $4 = 0;
|
|
$4 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $4;
|
|
$0 = __wasi_syscall_ret(legalfunc$__wasi_fd_seek(HEAP32[$0 + 60 >> 2], $1, $2, $3 & 255, $4 + 8 | 0));
|
|
__stack_pointer = $4 + 16 | 0;
|
|
$2 = HEAP32[$4 + 12 >> 2];
|
|
i64toi32_i32$HIGH_BITS = $0 ? -1 : $2;
|
|
$1 = HEAP32[$4 + 8 >> 2];
|
|
return ($0 ? -1 : $1) | 0;
|
|
}
|
|
function silk_A2NLSF_FLP($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0;
|
|
$3 = __stack_pointer + -64 | 0;
|
|
__stack_pointer = $3;
|
|
if (($2 | 0) >= 1) {
|
|
while (1) {
|
|
$5 = $4 << 2;
|
|
HEAP32[$5 + $3 >> 2] = lrintf(Math_fround(HEAPF32[$1 + $5 >> 2] * Math_fround(65536)));
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($2 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
silk_A2NLSF($0, $3, $2);
|
|
__stack_pointer = $3 - -64 | 0;
|
|
}
|
|
function silk_NLSF2A_FLP($0, $1, $2, $3) {
|
|
var $4 = 0;
|
|
$4 = __stack_pointer - 32 | 0;
|
|
__stack_pointer = $4;
|
|
silk_NLSF2A($4, $1, $2, $3);
|
|
if (($2 | 0) >= 1) {
|
|
$1 = 0;
|
|
while (1) {
|
|
HEAPF32[($1 << 2) + $0 >> 2] = Math_fround(HEAP16[($1 << 1) + $4 >> 1]) * Math_fround(.000244140625);
|
|
$1 = $1 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__stack_pointer = $4 + 32 | 0;
|
|
}
|
|
function sbrk($0) {
|
|
var $1 = 0, $2 = 0;
|
|
$1 = HEAP32[13136];
|
|
$2 = $0 + 3 & -4;
|
|
$0 = $1 + $2 | 0;
|
|
label$1 : {
|
|
if ($0 >>> 0 <= $1 >>> 0 ? ($2 | 0) >= 1 : 0) {
|
|
break label$1;
|
|
}
|
|
if (__wasm_memory_size() << 16 >>> 0 < $0 >>> 0) {
|
|
if (!(emscripten_resize_heap($0 | 0) | 0)) {
|
|
break label$1;
|
|
}
|
|
}
|
|
HEAP32[13136] = $0;
|
|
return $1;
|
|
}
|
|
HEAP32[__errno_location() >> 2] = 48;
|
|
return -1;
|
|
}
|
|
function __wasm_nearest_f32($0) {
|
|
var $1 = Math_fround(0), $2 = Math_fround(0);
|
|
$1 = Math_fround(Math_floor($0));
|
|
$2 = Math_fround($0 - $1);
|
|
if (!($2 < Math_fround(.5))) {
|
|
$0 = Math_fround(Math_ceil($0));
|
|
if ($2 > Math_fround(.5)) {
|
|
return $0;
|
|
}
|
|
$2 = Math_fround($1 * Math_fround(.5));
|
|
$1 = Math_fround($2 - Math_fround(Math_floor($2))) == Math_fround(0) ? $1 : $0;
|
|
}
|
|
return $1;
|
|
}
|
|
function __sin($0, $1, $2) {
|
|
var $3 = 0, $4 = 0, $5 = 0;
|
|
$3 = $0 * $0;
|
|
$5 = $3 * ($3 * $3) * ($3 * 1.58969099521155e-10 + -2.5050760253406863e-8) + ($3 * ($3 * 27557313707070068e-22 + -.0001984126982985795) + .00833333333332249);
|
|
$4 = $3 * $0;
|
|
if (!$2) {
|
|
return $4 * ($3 * $5 + -.16666666666666632) + $0;
|
|
}
|
|
return $0 - ($3 * ($1 * .5 - $4 * $5) - $1 + $4 * .16666666666666632);
|
|
}
|
|
function opus_packet_get_nb_frames($0, $1) {
|
|
var $2 = 0;
|
|
$2 = 1;
|
|
if (($1 | 0) < 1) {
|
|
return -1;
|
|
}
|
|
label$2 : {
|
|
label$3 : {
|
|
switch ((HEAPU8[$0 | 0] & 3) - 1 | 0) {
|
|
case 0:
|
|
case 1:
|
|
return 2;
|
|
case 2:
|
|
break label$3;
|
|
default:
|
|
break label$2;
|
|
}
|
|
}
|
|
$2 = -4;
|
|
if (($1 | 0) < 2) {
|
|
break label$2;
|
|
}
|
|
$2 = HEAPU8[$0 + 1 | 0] & 63;
|
|
}
|
|
return $2;
|
|
}
|
|
function dlcalloc($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0;
|
|
$2 = 0;
|
|
label$2 : {
|
|
if (!$0) {
|
|
break label$2;
|
|
}
|
|
$3 = __wasm_i64_mul($0, 0, $1, 0);
|
|
$4 = i64toi32_i32$HIGH_BITS;
|
|
$2 = $3;
|
|
if (($0 | $1) >>> 0 < 65536) {
|
|
break label$2;
|
|
}
|
|
$2 = $4 ? -1 : $3;
|
|
}
|
|
$3 = $2;
|
|
$0 = dlmalloc($3);
|
|
if (!(!$0 | !(HEAPU8[$0 - 4 | 0] & 3))) {
|
|
memset($0, 0, $3);
|
|
}
|
|
return $0;
|
|
}
|
|
function __towrite($0) {
|
|
var $1 = 0;
|
|
$1 = HEAPU8[$0 + 74 | 0];
|
|
HEAP8[$0 + 74 | 0] = $1 | $1 - 1;
|
|
$1 = HEAP32[$0 >> 2];
|
|
if ($1 & 8) {
|
|
HEAP32[$0 >> 2] = $1 | 32;
|
|
return -1;
|
|
}
|
|
HEAP32[$0 + 4 >> 2] = 0;
|
|
HEAP32[$0 + 8 >> 2] = 0;
|
|
$1 = HEAP32[$0 + 44 >> 2];
|
|
HEAP32[$0 + 28 >> 2] = $1;
|
|
HEAP32[$0 + 20 >> 2] = $1;
|
|
HEAP32[$0 + 16 >> 2] = HEAP32[$0 + 48 >> 2] + $1;
|
|
return 0;
|
|
}
|
|
function silk_lin2log($0) {
|
|
var $1 = 0, $2 = 0;
|
|
$1 = Math_clz32($0);
|
|
$2 = 24 - $1 | 0;
|
|
label$1 : {
|
|
if (!$2) {
|
|
break label$1;
|
|
}
|
|
if ($0 >>> 0 <= 127) {
|
|
$0 = $0 << 0 - $2 | $0 >>> 56 - $1;
|
|
break label$1;
|
|
}
|
|
$0 = $0 << $1 + 8 | $0 >>> $2;
|
|
}
|
|
$0 = $0 & 127;
|
|
return ($0 - ($1 << 7) + (Math_imul(Math_imul(128 - $0 | 0, $0), 179) >>> 16) | 0) + 3968 | 0;
|
|
}
|
|
function isqrt32($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0, $4 = 0, $5 = 0;
|
|
$2 = 31 - Math_clz32($0) >> 1;
|
|
$3 = 1 << $2;
|
|
while (1) {
|
|
$1 = ($4 << 1) + $3 << $2;
|
|
$5 = $1;
|
|
$1 = $0 >>> 0 < $1 >>> 0;
|
|
$0 = $0 - ($1 ? 0 : $5) | 0;
|
|
$4 = ($1 ? 0 : $3) + $4 | 0;
|
|
$1 = ($2 | 0) > 0;
|
|
$3 = $3 >>> 1 | 0;
|
|
$2 = $2 - 1 | 0;
|
|
if ($1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return $4;
|
|
}
|
|
function ec_enc_init($0, $1, $2) {
|
|
HEAP32[$0 + 24 >> 2] = 0;
|
|
HEAP32[$0 + 28 >> 2] = -2147483648;
|
|
HEAP32[$0 + 16 >> 2] = 0;
|
|
HEAP32[$0 + 20 >> 2] = 33;
|
|
HEAP32[$0 + 8 >> 2] = 0;
|
|
HEAP32[$0 + 12 >> 2] = 0;
|
|
HEAP32[$0 >> 2] = $1;
|
|
HEAP32[$0 + 32 >> 2] = 0;
|
|
HEAP32[$0 + 36 >> 2] = 0;
|
|
HEAP32[$0 + 40 >> 2] = -1;
|
|
HEAP32[$0 + 44 >> 2] = 0;
|
|
HEAP32[$0 + 4 >> 2] = $2;
|
|
}
|
|
function opus_packet_get_samples_per_frame($0, $1) {
|
|
$0 = HEAPU8[$0 | 0];
|
|
if ($0 & 128) {
|
|
return ($1 << ($0 >>> 3 & 3)) / 400 | 0;
|
|
}
|
|
if (($0 & 96) == 96) {
|
|
if ($0 & 8) {
|
|
return ($1 | 0) / 50 | 0;
|
|
}
|
|
return ($1 | 0) / 100 | 0;
|
|
}
|
|
$0 = $0 >>> 3 & 3;
|
|
if (($0 | 0) == 3) {
|
|
return (Math_imul($1, 60) | 0) / 1e3 | 0;
|
|
}
|
|
return ($1 << $0) / 100 | 0;
|
|
}
|
|
function __cos($0, $1) {
|
|
var $2 = 0, $3 = 0, $4 = 0, $5 = 0;
|
|
$2 = $0 * $0;
|
|
$3 = $2 * .5;
|
|
$4 = 1 - $3;
|
|
$5 = 1 - $4 - $3;
|
|
$3 = $2 * $2;
|
|
return $4 + ($5 + ($2 * ($2 * ($2 * ($2 * 2480158728947673e-20 + -.001388888888887411) + .0416666666666666) + $3 * $3 * ($2 * ($2 * -1.1359647557788195e-11 + 2.087572321298175e-9) + -2.7557314351390663e-7)) - $0 * $1));
|
|
}
|
|
function silk_autocorrelation_FLP($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0;
|
|
$4 = ($2 | 0) < ($3 | 0) ? $2 : $3;
|
|
if (($4 | 0) >= 1) {
|
|
$3 = 0;
|
|
while (1) {
|
|
$5 = $3 << 2;
|
|
HEAPF32[$5 + $0 >> 2] = silk_inner_product_FLP($1, $1 + $5 | 0, $2 - $3 | 0);
|
|
$3 = $3 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function silk_inner_prod_aligned_scale($0, $1, $2, $3) {
|
|
var $4 = 0, $5 = 0, $6 = 0;
|
|
if (($3 | 0) >= 1) {
|
|
while (1) {
|
|
$5 = $4 << 1;
|
|
$6 = (Math_imul(HEAP16[$5 + $1 >> 1], HEAP16[$0 + $5 >> 1]) >> $2) + $6 | 0;
|
|
$4 = $4 + 1 | 0;
|
|
if (($4 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $6;
|
|
}
|
|
function silk_corrVector_FLP($0, $1, $2, $3, $4) {
|
|
var $5 = 0;
|
|
if (($3 | 0) >= 1) {
|
|
$0 = (($3 << 2) + $0 | 0) - 4 | 0;
|
|
while (1) {
|
|
HEAPF32[($5 << 2) + $4 >> 2] = silk_inner_product_FLP($0, $1, $2);
|
|
$0 = $0 - 4 | 0;
|
|
$5 = $5 + 1 | 0;
|
|
if (($5 | 0) != ($3 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function getint($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0;
|
|
if (isdigit(HEAP8[HEAP32[$0 >> 2]])) {
|
|
while (1) {
|
|
$1 = HEAP32[$0 >> 2];
|
|
$3 = HEAP8[$1 | 0];
|
|
HEAP32[$0 >> 2] = $1 + 1;
|
|
$2 = (Math_imul($2, 10) + $3 | 0) - 48 | 0;
|
|
if (isdigit(HEAP8[$1 + 1 | 0])) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $2;
|
|
}
|
|
function ec_tell_frac($0) {
|
|
var $1 = 0, $2 = 0, $3 = 0;
|
|
$2 = HEAP32[$0 + 20 >> 2] << 3;
|
|
$0 = HEAP32[$0 + 28 >> 2];
|
|
$1 = Math_clz32($0);
|
|
$0 = $0 >>> 16 - $1 | 0;
|
|
$3 = $0;
|
|
$0 = ($0 >>> 12 | 0) - 8 | 0;
|
|
return ((($2 + ($1 << 3) | 0) - ($3 >>> 0 > HEAPU32[($0 << 2) + 32816 >> 2]) | 0) - $0 | 0) - 256 | 0;
|
|
}
|
|
function ec_enc_shrink($0, $1) {
|
|
var $2 = 0, $3 = 0;
|
|
$2 = HEAP32[$0 + 8 >> 2];
|
|
if ($2 + HEAP32[$0 + 24 >> 2] >>> 0 > $1 >>> 0) {
|
|
celt_fatal(7097, 7019, 238);
|
|
abort();
|
|
}
|
|
$3 = HEAP32[$0 >> 2];
|
|
memmove(($3 + $1 | 0) - $2 | 0, (HEAP32[$0 + 4 >> 2] + $3 | 0) - $2 | 0, $2);
|
|
HEAP32[$0 + 4 >> 2] = $1;
|
|
}
|
|
function silk_init_encoder($0, $1) {
|
|
$0 = memset($0, 0, 10064);
|
|
HEAP32[$0 + 5092 >> 2] = $1;
|
|
$1 = silk_lin2log(3932160);
|
|
HEAP32[$0 + 4664 >> 2] = 1;
|
|
$1 = ($1 << 8) - 524288 | 0;
|
|
HEAP32[$0 + 12 >> 2] = $1;
|
|
HEAP32[$0 + 8 >> 2] = $1;
|
|
return silk_VAD_Init($0 + 36 | 0);
|
|
}
|
|
function ec_decode($0, $1) {
|
|
var $2 = 0;
|
|
$2 = HEAPU32[$0 + 28 >> 2] / ($1 >>> 0) | 0;
|
|
HEAP32[$0 + 36 >> 2] = $2;
|
|
$0 = HEAPU32[$0 + 32 >> 2] / ($2 >>> 0) | 0;
|
|
$2 = ($0 ^ -1) + $1 | 0;
|
|
$0 = $0 + 1 | 0;
|
|
$1 = $0 - $1 | 0;
|
|
return $2 + ($0 >>> 0 < $1 >>> 0 ? 0 : $1) | 0;
|
|
}
|
|
function fmt_x($0, $1, $2, $3) {
|
|
if ($0 | $1) {
|
|
while (1) {
|
|
$2 = $2 - 1 | 0;
|
|
HEAP8[$2 | 0] = HEAPU8[($0 & 15) + 1600 | 0] | $3;
|
|
$0 = ($1 & 15) << 28 | $0 >>> 4;
|
|
$1 = $1 >>> 4 | 0;
|
|
if ($0 | $1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $2;
|
|
}
|
|
function fmt_o($0, $1, $2) {
|
|
if ($0 | $1) {
|
|
while (1) {
|
|
$2 = $2 - 1 | 0;
|
|
HEAP8[$2 | 0] = $0 & 7 | 48;
|
|
$0 = ($1 & 7) << 29 | $0 >>> 3;
|
|
$1 = $1 >>> 3 | 0;
|
|
if ($0 | $1) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $2;
|
|
}
|
|
function silk_gains_ID($0, $1) {
|
|
var $2 = 0, $3 = 0;
|
|
if (($1 | 0) >= 1) {
|
|
while (1) {
|
|
$3 = HEAP8[$0 + $2 | 0] + ($3 << 8) | 0;
|
|
$2 = $2 + 1 | 0;
|
|
if (($2 | 0) != ($1 | 0)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return $3;
|
|
}
|
|
function celt_fatal($0, $1, $2) {
|
|
var $3 = 0;
|
|
$3 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $3;
|
|
HEAP32[$3 + 8 >> 2] = $0;
|
|
HEAP32[$3 + 4 >> 2] = $2;
|
|
HEAP32[$3 >> 2] = $1;
|
|
fiprintf(HEAP32[278], 1616, $3);
|
|
abort();
|
|
abort();
|
|
}
|
|
function legalstub$dynCall_jiji($0, $1, $2, $3, $4) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
$0 = dynCall_jiji($0, $1, $2, $3, $4);
|
|
$2 = i64toi32_i32$HIGH_BITS;
|
|
setTempRet0($2 | 0);
|
|
return $0 | 0;
|
|
}
|
|
function speex_resampler_destroy($0) {
|
|
$0 = $0 | 0;
|
|
dlfree(HEAP32[$0 + 72 >> 2]);
|
|
dlfree(HEAP32[$0 + 76 >> 2]);
|
|
dlfree(HEAP32[$0 + 60 >> 2]);
|
|
dlfree(HEAP32[$0 + 68 >> 2]);
|
|
dlfree(HEAP32[$0 + 64 >> 2]);
|
|
dlfree($0);
|
|
}
|
|
function __DOUBLE_BITS($0) {
|
|
var $1 = 0, $2 = 0;
|
|
wasm2js_scratch_store_f64(+$0);
|
|
$1 = wasm2js_scratch_load_i32(1) | 0;
|
|
$2 = wasm2js_scratch_load_i32(0) | 0;
|
|
i64toi32_i32$HIGH_BITS = $1;
|
|
return $2;
|
|
}
|
|
function celt_encoder_get_size($0) {
|
|
var $1 = 0;
|
|
$1 = opus_custom_mode_create(48e3, 960, 0);
|
|
return Math_imul(((HEAP32[$1 + 4 >> 2] << 2) + (HEAP32[$1 + 8 >> 2] << 4) | 0) + 4096 | 0, $0) + 244 | 0;
|
|
}
|
|
function fiprintf($0, $1, $2) {
|
|
var $3 = 0;
|
|
$3 = __stack_pointer - 16 | 0;
|
|
__stack_pointer = $3;
|
|
HEAP32[$3 + 12 >> 2] = $2;
|
|
$2 = vfiprintf($0, $1, $2);
|
|
__stack_pointer = $3 + 16 | 0;
|
|
return $2;
|
|
}
|
|
function encode_size($0, $1) {
|
|
var $2 = 0;
|
|
if (($0 | 0) <= 251) {
|
|
HEAP8[$1 | 0] = $0;
|
|
return 1;
|
|
}
|
|
$2 = $0 | -4;
|
|
HEAP8[$1 | 0] = $2;
|
|
HEAP8[$1 + 1 | 0] = $0 - ($2 & 255) >>> 2;
|
|
return 2;
|
|
}
|
|
function speex_resampler_init($0, $1, $2, $3, $4) {
|
|
$0 = $0 | 0;
|
|
$1 = $1 | 0;
|
|
$2 = $2 | 0;
|
|
$3 = $3 | 0;
|
|
$4 = $4 | 0;
|
|
return speex_resampler_init_frac($0, $1, $2, $1, $2, $3, $4) | 0;
|
|
}
|
|
function __wasm_i64_udiv($0, $1, $2, $3) {
|
|
$3 = _ZN17compiler_builtins3int4udiv10divmod_u6417h6026910b5ed08e40E($0, $1, $2, $3);
|
|
return $3;
|
|
}
|
|
function __wasm_rotl_i32($0, $1) {
|
|
var $2 = 0;
|
|
$2 = $1 & 31;
|
|
$1 = 0 - $1 & 31;
|
|
return (-1 >>> $2 & $0) << $2 | (-1 << $1 & $0) >>> $1;
|
|
}
|
|
function lrintf($0) {
|
|
$0 = rintf($0);
|
|
if (Math_fround(Math_abs($0)) < Math_fround(2147483648)) {
|
|
return ~~$0;
|
|
}
|
|
return -2147483648;
|
|
}
|
|
function legalfunc$__wasi_fd_seek($0, $1, $2, $3, $4) {
|
|
return legalimport$__wasi_fd_seek($0 | 0, $1 | 0, $2 | 0, $3 | 0, $4 | 0) | 0;
|
|
}
|
|
function __wasm_i64_mul($0, $1, $2, $3) {
|
|
$3 = _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE($0, $1, $2, $3);
|
|
return $3;
|
|
}
|
|
function tonality_analysis_init($0, $1) {
|
|
HEAP32[$0 + 8 >> 2] = $1;
|
|
HEAP32[$0 >> 2] = 0;
|
|
memset($0 + 12 | 0, 0, 13992);
|
|
}
|
|
function stackAlloc($0) {
|
|
$0 = $0 | 0;
|
|
$0 = __stack_pointer - $0 & -16;
|
|
__stack_pointer = $0;
|
|
return $0 | 0;
|
|
}
|
|
function silk_resampler_private_up2_HQ_wrapper($0, $1, $2, $3) {
|
|
silk_resampler_private_up2_HQ($0, $1, $2, $3);
|
|
}
|
|
function __wasi_syscall_ret($0) {
|
|
if (!$0) {
|
|
return 0;
|
|
}
|
|
HEAP32[__errno_location() >> 2] = $0;
|
|
return -1;
|
|
}
|
|
function dynCall_jiji($0, $1, $2, $3, $4) {
|
|
$3 = FUNCTION_TABLE[$0 | 0]($1, $2, $3, $4) | 0;
|
|
return $3;
|
|
}
|
|
function __stdio_close($0) {
|
|
$0 = $0 | 0;
|
|
return __wasi_fd_close(dummy(HEAP32[$0 + 60 >> 2]) | 0) | 0;
|
|
}
|
|
function __wasm_ctz_i32($0) {
|
|
if ($0) {
|
|
return 31 - Math_clz32($0 - 1 ^ $0) | 0;
|
|
}
|
|
return 32;
|
|
}
|
|
|
|
|
|
|
|
function opus_repacketizer_cat($0, $1, $2) {
|
|
return opus_repacketizer_cat_impl($0, $1, $2, 0);
|
|
}
|
|
function out($0, $1, $2) {
|
|
if (!(HEAPU8[$0 | 0] & 32)) {
|
|
__fwritex($1, $2, $0);
|
|
}
|
|
}
|
|
function wctomb($0, $1) {
|
|
if (!$0) {
|
|
return 0;
|
|
}
|
|
return wcrtomb($0, $1, 0);
|
|
}
|
|
function vfiprintf($0, $1, $2) {
|
|
return __vfprintf_internal($0, $1, $2, 0, 0);
|
|
}
|
|
function silk_stereo_encode_mid_only($0, $1) {
|
|
ec_enc_icdf($0, $1, 5801, 8);
|
|
}
|
|
function opus_repacketizer_init($0) {
|
|
HEAP32[$0 + 4 >> 2] = 0;
|
|
return $0;
|
|
}
|
|
function silk_Get_Encoder_Size($0) {
|
|
HEAP32[$0 >> 2] = 20216;
|
|
return 0;
|
|
}
|
|
function tonality_analysis_reset($0) {
|
|
memset($0 + 12 | 0, 0, 13992);
|
|
}
|
|
function stackRestore($0) {
|
|
$0 = $0 | 0;
|
|
__stack_pointer = $0;
|
|
}
|
|
function opus_encoder_destroy($0) {
|
|
$0 = $0 | 0;
|
|
dlfree($0);
|
|
}
|
|
function rintf($0) {
|
|
return __wasm_nearest_f32($0);
|
|
}
|
|
function stackSave() {
|
|
return __stack_pointer | 0;
|
|
}
|
|
function isdigit($0) {
|
|
return $0 - 48 >>> 0 < 10;
|
|
}
|
|
function floor($0) {
|
|
return Math_floor($0);
|
|
}
|
|
function __errno_location() {
|
|
return 52924;
|
|
}
|
|
function __pthread_self() {
|
|
return 52696;
|
|
}
|
|
function __lockfile($0) {
|
|
return 1;
|
|
}
|
|
function dummy($0) {
|
|
return $0;
|
|
}
|
|
function __wasm_call_ctors() {}
|
|
function __unlockfile($0) {}
|
|
|
|
// EMSCRIPTEN_END_FUNCS
|
|
|
|
;
|
|
bufferView = HEAPU8;
|
|
initActiveSegments(env);
|
|
var FUNCTION_TABLE = Table([null, __stdio_close, __stdio_write, __stdio_seek, downmix_float, resampler_basic_direct_double, resampler_basic_direct_single, resampler_basic_interpolate_double, resampler_basic_interpolate_single, resampler_basic_zero]);
|
|
function __wasm_memory_size() {
|
|
return buffer.byteLength / 65536 | 0;
|
|
}
|
|
|
|
return {
|
|
"__wasm_call_ctors": __wasm_call_ctors,
|
|
"opus_encoder_create": opus_encoder_create,
|
|
"opus_encode_float": opus_encode_float,
|
|
"opus_encoder_ctl": opus_encoder_ctl,
|
|
"opus_encoder_destroy": opus_encoder_destroy,
|
|
"speex_resampler_init": speex_resampler_init,
|
|
"speex_resampler_destroy": speex_resampler_destroy,
|
|
"speex_resampler_process_interleaved_float": speex_resampler_process_interleaved_float,
|
|
"__errno_location": __errno_location,
|
|
"stackSave": stackSave,
|
|
"stackRestore": stackRestore,
|
|
"stackAlloc": stackAlloc,
|
|
"malloc": dlmalloc,
|
|
"free": dlfree,
|
|
"__indirect_function_table": FUNCTION_TABLE,
|
|
"dynCall_jiji": legalstub$dynCall_jiji
|
|
};
|
|
}
|
|
|
|
return asmFunc(asmLibraryArg);
|
|
}
|
|
// EMSCRIPTEN_END_ASM
|
|
|
|
|
|
|
|
|
|
)(asmLibraryArg);
|
|
},
|
|
|
|
instantiate: /** @suppress{checkTypes} */ function(binary, info) {
|
|
return {
|
|
then: function(ok) {
|
|
var module = new WebAssembly.Module(binary);
|
|
ok({
|
|
'instance': new WebAssembly.Instance(module)
|
|
});
|
|
}
|
|
};
|
|
},
|
|
|
|
RuntimeError: Error
|
|
};
|
|
|
|
// We don't need to actually download a wasm binary, mark it as present but empty.
|
|
wasmBinary = [];
|
|
|
|
// end include: wasm2js.js
|
|
if (typeof WebAssembly !== 'object') {
|
|
abort('no native wasm support detected');
|
|
}
|
|
|
|
// include: runtime_safe_heap.js
|
|
|
|
|
|
// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking.
|
|
// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties)
|
|
|
|
/** @param {number} ptr
|
|
@param {number} value
|
|
@param {string} type
|
|
@param {number|boolean=} noSafe */
|
|
function setValue(ptr, value, type, noSafe) {
|
|
type = type || 'i8';
|
|
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
|
|
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.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>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);
|
|
}
|
|
}
|
|
|
|
/** @param {number} ptr
|
|
@param {string} type
|
|
@param {number|boolean=} noSafe */
|
|
function getValue(ptr, type, noSafe) {
|
|
type = type || 'i8';
|
|
if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
|
|
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 getValue: ' + type);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// end include: runtime_safe_heap.js
|
|
// Wasm globals
|
|
|
|
var wasmMemory;
|
|
|
|
//========================================
|
|
// Runtime essentials
|
|
//========================================
|
|
|
|
// whether we are quitting the application. no code should run after this.
|
|
// set in exit() and abort()
|
|
var ABORT = false;
|
|
|
|
// set by exit() and abort(). Passed to 'onExit' handler.
|
|
// NOTE: This is also used as the process return code code in shell environments
|
|
// but only when noExitRuntime is false.
|
|
var EXITSTATUS;
|
|
|
|
/** @type {function(*, string=)} */
|
|
function assert(condition, text) {
|
|
if (!condition) {
|
|
abort('Assertion failed: ' + text);
|
|
}
|
|
}
|
|
|
|
// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
|
|
function getCFunc(ident) {
|
|
var func = Module['_' + ident]; // closure exported function
|
|
assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');
|
|
return func;
|
|
}
|
|
|
|
// C calling interface.
|
|
/** @param {string|null=} returnType
|
|
@param {Array=} argTypes
|
|
@param {Arguments|Array=} args
|
|
@param {Object=} opts */
|
|
function ccall(ident, returnType, argTypes, args, opts) {
|
|
// For fast lookup of conversion functions
|
|
var toC = {
|
|
'string': function(str) {
|
|
var ret = 0;
|
|
if (str !== null && str !== undefined && str !== 0) { // null string
|
|
// at most 4 bytes per UTF-8 code point, +1 for the trailing '\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;
|
|
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;
|
|
}
|
|
|
|
/** @param {string=} returnType
|
|
@param {Array=} argTypes
|
|
@param {Object=} opts */
|
|
function cwrap(ident, returnType, argTypes, opts) {
|
|
argTypes = argTypes || [];
|
|
// When the function takes numbers and returns a number, we can just return
|
|
// the original function
|
|
var numericArgs = argTypes.every(function(type){ return type === 'number'});
|
|
var numericRet = returnType !== 'string';
|
|
if (numericRet && numericArgs && !opts) {
|
|
return getCFunc(ident);
|
|
}
|
|
return function() {
|
|
return ccall(ident, returnType, argTypes, arguments, opts);
|
|
}
|
|
}
|
|
|
|
var ALLOC_NORMAL = 0; // Tries to use _malloc()
|
|
var ALLOC_STACK = 1; // Lives for the duration of the current function call
|
|
|
|
// allocate(): This is for internal use. You can use it yourself as well, but the interface
|
|
// is a little tricky (see docs right below). The reason is that it is optimized
|
|
// for multiple syntaxes to save space in generated code. So you should
|
|
// normally not use allocate(), and instead allocate memory using _malloc(),
|
|
// initialize it with setValue(), and so forth.
|
|
// @slab: An array of data.
|
|
// @allocator: How to allocate memory, see ALLOC_*
|
|
/** @type {function((Uint8Array|Array<number>), number)} */
|
|
function allocate(slab, allocator) {
|
|
var ret;
|
|
|
|
if (allocator == ALLOC_STACK) {
|
|
ret = stackAlloc(slab.length);
|
|
} else {
|
|
ret = _malloc(slab.length);
|
|
}
|
|
|
|
if (slab.subarray || slab.slice) {
|
|
HEAPU8.set(/** @type {!Uint8Array} */(slab), ret);
|
|
} else {
|
|
HEAPU8.set(new Uint8Array(slab), ret);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// include: runtime_strings.js
|
|
|
|
|
|
// runtime_strings.js: Strings related runtime functions that are part of both MINIMAL_RUNTIME and regular runtime.
|
|
|
|
// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
|
|
// a copy of that string as a Javascript String object.
|
|
|
|
var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;
|
|
|
|
/**
|
|
* @param {number} idx
|
|
* @param {number=} maxBytesToRead
|
|
* @return {string}
|
|
*/
|
|
function UTF8ArrayToString(heap, idx, maxBytesToRead) {
|
|
var endIdx = idx + maxBytesToRead;
|
|
var endPtr = idx;
|
|
// TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
|
|
// Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
|
|
// (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity)
|
|
while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
|
|
|
|
if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
|
|
return UTF8Decoder.decode(heap.subarray(idx, endPtr));
|
|
} else {
|
|
var str = '';
|
|
// If building with TextDecoder, we have already computed the string length above, so test loop end condition against that
|
|
while (idx < endPtr) {
|
|
// For UTF8 byte structure, see:
|
|
// http://en.wikipedia.org/wiki/UTF-8#Description
|
|
// https://www.ietf.org/rfc/rfc2279.txt
|
|
// https://tools.ietf.org/html/rfc3629
|
|
var u0 = heap[idx++];
|
|
if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
|
|
var u1 = heap[idx++] & 63;
|
|
if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
|
|
var u2 = heap[idx++] & 63;
|
|
if ((u0 & 0xF0) == 0xE0) {
|
|
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
|
|
} else {
|
|
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
|
|
}
|
|
|
|
if (u0 < 0x10000) {
|
|
str += String.fromCharCode(u0);
|
|
} else {
|
|
var ch = u0 - 0x10000;
|
|
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
|
|
}
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a
|
|
// copy of that string as a Javascript String object.
|
|
// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit
|
|
// this parameter to scan the string until the first \0 byte. If maxBytesToRead is
|
|
// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the
|
|
// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will
|
|
// not produce a string of exact length [ptr, ptr+maxBytesToRead[)
|
|
// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may
|
|
// throw JS JIT optimizations off, so it is worth to consider consistently using one
|
|
// style or the other.
|
|
/**
|
|
* @param {number} ptr
|
|
* @param {number=} maxBytesToRead
|
|
* @return {string}
|
|
*/
|
|
function UTF8ToString(ptr, maxBytesToRead) {
|
|
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
|
|
// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Parameters:
|
|
// str: the Javascript string to copy.
|
|
// heap: the array to copy to. Each index in this array is assumed to be one 8-byte element.
|
|
// outIdx: The starting offset in the array to begin the copying.
|
|
// maxBytesToWrite: The maximum number of bytes this function can write to the array.
|
|
// This count should include the null terminator,
|
|
// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
|
|
// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
|
|
if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
|
|
return 0;
|
|
|
|
var startIdx = outIdx;
|
|
var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
// For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
|
|
var u = str.charCodeAt(i); // possibly a lead surrogate
|
|
if (u >= 0xD800 && u <= 0xDFFF) {
|
|
var u1 = str.charCodeAt(++i);
|
|
u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);
|
|
}
|
|
if (u <= 0x7F) {
|
|
if (outIdx >= endIdx) break;
|
|
heap[outIdx++] = u;
|
|
} else if (u <= 0x7FF) {
|
|
if (outIdx + 1 >= endIdx) break;
|
|
heap[outIdx++] = 0xC0 | (u >> 6);
|
|
heap[outIdx++] = 0x80 | (u & 63);
|
|
} else if (u <= 0xFFFF) {
|
|
if (outIdx + 2 >= endIdx) break;
|
|
heap[outIdx++] = 0xE0 | (u >> 12);
|
|
heap[outIdx++] = 0x80 | ((u >> 6) & 63);
|
|
heap[outIdx++] = 0x80 | (u & 63);
|
|
} else {
|
|
if (outIdx + 3 >= endIdx) break;
|
|
heap[outIdx++] = 0xF0 | (u >> 18);
|
|
heap[outIdx++] = 0x80 | ((u >> 12) & 63);
|
|
heap[outIdx++] = 0x80 | ((u >> 6) & 63);
|
|
heap[outIdx++] = 0x80 | (u & 63);
|
|
}
|
|
}
|
|
// Null-terminate the pointer to the buffer.
|
|
heap[outIdx] = 0;
|
|
return outIdx - startIdx;
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF8(str, outPtr, maxBytesToWrite) {
|
|
return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);
|
|
}
|
|
|
|
// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
|
|
function lengthBytesUTF8(str) {
|
|
var len = 0;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
var u = str.charCodeAt(i); // possibly a lead surrogate
|
|
if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
|
|
if (u <= 0x7F) ++len;
|
|
else if (u <= 0x7FF) len += 2;
|
|
else if (u <= 0xFFFF) len += 3;
|
|
else len += 4;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
// end include: runtime_strings.js
|
|
// include: runtime_strings_extra.js
|
|
|
|
|
|
// runtime_strings_extra.js: Strings related runtime functions that are available only in regular runtime.
|
|
|
|
// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
|
|
// a copy of that string as a Javascript String object.
|
|
|
|
function AsciiToString(ptr) {
|
|
var str = '';
|
|
while (1) {
|
|
var ch = HEAPU8[((ptr++)>>0)];
|
|
if (!ch) return str;
|
|
str += String.fromCharCode(ch);
|
|
}
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.
|
|
|
|
function stringToAscii(str, outPtr) {
|
|
return writeAsciiToMemory(str, outPtr, false);
|
|
}
|
|
|
|
// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
|
|
// a copy of that string as a Javascript String object.
|
|
|
|
var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;
|
|
|
|
function UTF16ToString(ptr, maxBytesToRead) {
|
|
var endPtr = ptr;
|
|
// TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
|
|
// Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
|
|
var idx = endPtr >> 1;
|
|
var maxIdx = idx + maxBytesToRead / 2;
|
|
// If maxBytesToRead is not passed explicitly, it will be undefined, and this
|
|
// will always evaluate to true. This saves on code size.
|
|
while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
|
|
endPtr = idx << 1;
|
|
|
|
if (endPtr - ptr > 32 && UTF16Decoder) {
|
|
return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
|
|
} else {
|
|
var str = '';
|
|
|
|
// If maxBytesToRead is not passed explicitly, it will be undefined, and the for-loop's condition
|
|
// will always evaluate to true. The loop is then terminated on the first null char.
|
|
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
|
|
var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
|
|
if (codeUnit == 0) break;
|
|
// fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
|
|
str += String.fromCharCode(codeUnit);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Parameters:
|
|
// str: the Javascript string to copy.
|
|
// outPtr: Byte address in Emscripten HEAP where to write the string to.
|
|
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
|
|
// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
|
|
// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF16(str, outPtr, maxBytesToWrite) {
|
|
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
|
|
if (maxBytesToWrite === undefined) {
|
|
maxBytesToWrite = 0x7FFFFFFF;
|
|
}
|
|
if (maxBytesToWrite < 2) return 0;
|
|
maxBytesToWrite -= 2; // Null terminator.
|
|
var startPtr = outPtr;
|
|
var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;
|
|
for (var i = 0; i < numCharsToWrite; ++i) {
|
|
// charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
|
|
var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
|
|
HEAP16[((outPtr)>>1)] = codeUnit;
|
|
outPtr += 2;
|
|
}
|
|
// Null-terminate the pointer to the HEAP.
|
|
HEAP16[((outPtr)>>1)] = 0;
|
|
return outPtr - startPtr;
|
|
}
|
|
|
|
// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
|
|
|
|
function lengthBytesUTF16(str) {
|
|
return str.length*2;
|
|
}
|
|
|
|
function UTF32ToString(ptr, maxBytesToRead) {
|
|
var i = 0;
|
|
|
|
var str = '';
|
|
// If maxBytesToRead is not passed explicitly, it will be undefined, and this
|
|
// will always evaluate to true. This saves on code size.
|
|
while (!(i >= maxBytesToRead / 4)) {
|
|
var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
|
|
if (utf32 == 0) break;
|
|
++i;
|
|
// Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
if (utf32 >= 0x10000) {
|
|
var ch = utf32 - 0x10000;
|
|
str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
|
|
} else {
|
|
str += String.fromCharCode(utf32);
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
|
|
// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
|
|
// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
|
|
// Parameters:
|
|
// str: the Javascript string to copy.
|
|
// outPtr: Byte address in Emscripten HEAP where to write the string to.
|
|
// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
|
|
// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
|
|
// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
|
|
// Returns the number of bytes written, EXCLUDING the null terminator.
|
|
|
|
function stringToUTF32(str, outPtr, maxBytesToWrite) {
|
|
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
|
|
if (maxBytesToWrite === undefined) {
|
|
maxBytesToWrite = 0x7FFFFFFF;
|
|
}
|
|
if (maxBytesToWrite < 4) return 0;
|
|
var startPtr = outPtr;
|
|
var endPtr = startPtr + maxBytesToWrite - 4;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
|
|
if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
|
|
var trailSurrogate = str.charCodeAt(++i);
|
|
codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
|
|
}
|
|
HEAP32[((outPtr)>>2)] = codeUnit;
|
|
outPtr += 4;
|
|
if (outPtr + 4 > endPtr) break;
|
|
}
|
|
// Null-terminate the pointer to the HEAP.
|
|
HEAP32[((outPtr)>>2)] = 0;
|
|
return outPtr - startPtr;
|
|
}
|
|
|
|
// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
|
|
|
|
function lengthBytesUTF32(str) {
|
|
var len = 0;
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
|
|
// See http://unicode.org/faq/utf_bom.html#utf16-3
|
|
var codeUnit = str.charCodeAt(i);
|
|
if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.
|
|
len += 4;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
// Allocate heap space for a JS string, and write it there.
|
|
// It is the responsibility of the caller to free() that memory.
|
|
function allocateUTF8(str) {
|
|
var size = lengthBytesUTF8(str) + 1;
|
|
var ret = _malloc(size);
|
|
if (ret) stringToUTF8Array(str, HEAP8, ret, size);
|
|
return ret;
|
|
}
|
|
|
|
// Allocate stack space for a JS string, and write it there.
|
|
function allocateUTF8OnStack(str) {
|
|
var size = lengthBytesUTF8(str) + 1;
|
|
var ret = stackAlloc(size);
|
|
stringToUTF8Array(str, HEAP8, ret, size);
|
|
return ret;
|
|
}
|
|
|
|
// Deprecated: This function should not be called because it is unsafe and does not provide
|
|
// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
|
|
// function stringToUTF8Array() instead, which takes in a maximum length that can be used
|
|
// to be secure from out of bounds writes.
|
|
/** @deprecated
|
|
@param {boolean=} dontAddNull */
|
|
function writeStringToMemory(string, buffer, dontAddNull) {
|
|
warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!');
|
|
|
|
var /** @type {number} */ lastChar, /** @type {number} */ end;
|
|
if (dontAddNull) {
|
|
// stringToUTF8Array always appends null. If we don't want to do that, remember the
|
|
// character that existed at the location where the null will be placed, and restore
|
|
// that after the write (below).
|
|
end = buffer + lengthBytesUTF8(string);
|
|
lastChar = HEAP8[end];
|
|
}
|
|
stringToUTF8(string, buffer, Infinity);
|
|
if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.
|
|
}
|
|
|
|
function writeArrayToMemory(array, buffer) {
|
|
HEAP8.set(array, buffer);
|
|
}
|
|
|
|
/** @param {boolean=} dontAddNull */
|
|
function writeAsciiToMemory(str, buffer, dontAddNull) {
|
|
for (var i = 0; i < str.length; ++i) {
|
|
HEAP8[((buffer++)>>0)] = str.charCodeAt(i);
|
|
}
|
|
// Null-terminate the pointer to the HEAP.
|
|
if (!dontAddNull) HEAP8[((buffer)>>0)] = 0;
|
|
}
|
|
|
|
// end include: runtime_strings_extra.js
|
|
// Memory management
|
|
|
|
function alignUp(x, multiple) {
|
|
if (x % multiple > 0) {
|
|
x += multiple - (x % multiple);
|
|
}
|
|
return x;
|
|
}
|
|
|
|
var HEAP,
|
|
/** @type {ArrayBuffer} */
|
|
buffer,
|
|
/** @type {Int8Array} */
|
|
HEAP8,
|
|
/** @type {Uint8Array} */
|
|
HEAPU8,
|
|
/** @type {Int16Array} */
|
|
HEAP16,
|
|
/** @type {Uint16Array} */
|
|
HEAPU16,
|
|
/** @type {Int32Array} */
|
|
HEAP32,
|
|
/** @type {Uint32Array} */
|
|
HEAPU32,
|
|
/** @type {Float32Array} */
|
|
HEAPF32,
|
|
/** @type {Float64Array} */
|
|
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;
|
|
|
|
var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 16777216;
|
|
|
|
// In non-standalone/normal mode, we create the memory here.
|
|
// include: runtime_init_memory.js
|
|
|
|
|
|
// Create the wasm memory. (Note: this only applies if IMPORTED_MEMORY is defined)
|
|
|
|
if (Module['wasmMemory']) {
|
|
wasmMemory = Module['wasmMemory'];
|
|
} else
|
|
{
|
|
wasmMemory = new WebAssembly.Memory({
|
|
'initial': INITIAL_MEMORY / 65536
|
|
,
|
|
'maximum': INITIAL_MEMORY / 65536
|
|
});
|
|
}
|
|
|
|
if (wasmMemory) {
|
|
buffer = wasmMemory.buffer;
|
|
}
|
|
|
|
// If the user provides an incorrect length, just use that length instead rather than providing the user to
|
|
// specifically provide the memory length with Module['INITIAL_MEMORY'].
|
|
INITIAL_MEMORY = buffer.byteLength;
|
|
updateGlobalBufferAndViews(buffer);
|
|
|
|
// end include: runtime_init_memory.js
|
|
|
|
// include: runtime_init_table.js
|
|
// In regular non-RELOCATABLE mode the table is exported
|
|
// from the wasm module and this will be assigned once
|
|
// the exports are available.
|
|
var wasmTable;
|
|
|
|
// end include: runtime_init_table.js
|
|
// include: runtime_stack_check.js
|
|
|
|
|
|
// end include: runtime_stack_check.js
|
|
// include: runtime_assertions.js
|
|
|
|
|
|
// end include: runtime_assertions.js
|
|
var __ATPRERUN__ = []; // functions called before the runtime is initialized
|
|
var __ATINIT__ = []; // functions called during startup
|
|
var __ATMAIN__ = []; // functions called when main() is to be run
|
|
var __ATEXIT__ = []; // functions called during shutdown
|
|
var __ATPOSTRUN__ = []; // functions called after the main() is called
|
|
|
|
var runtimeInitialized = false;
|
|
var runtimeExited = false;
|
|
|
|
__ATINIT__.push({ func: function() { ___wasm_call_ctors() } });
|
|
|
|
function preRun() {
|
|
|
|
if (Module['preRun']) {
|
|
if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
|
|
while (Module['preRun'].length) {
|
|
addOnPreRun(Module['preRun'].shift());
|
|
}
|
|
}
|
|
|
|
callRuntimeCallbacks(__ATPRERUN__);
|
|
}
|
|
|
|
function initRuntime() {
|
|
runtimeInitialized = true;
|
|
|
|
callRuntimeCallbacks(__ATINIT__);
|
|
}
|
|
|
|
function preMain() {
|
|
|
|
callRuntimeCallbacks(__ATMAIN__);
|
|
}
|
|
|
|
function exitRuntime() {
|
|
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);
|
|
}
|
|
|
|
function addOnInit(cb) {
|
|
__ATINIT__.unshift(cb);
|
|
}
|
|
|
|
function addOnPreMain(cb) {
|
|
__ATMAIN__.unshift(cb);
|
|
}
|
|
|
|
function addOnExit(cb) {
|
|
}
|
|
|
|
function addOnPostRun(cb) {
|
|
__ATPOSTRUN__.unshift(cb);
|
|
}
|
|
|
|
// include: runtime_math.js
|
|
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
|
|
|
|
// end include: runtime_math.js
|
|
// A counter of dependencies for calling run(). If we need to
|
|
// do asynchronous work before running, increment this and
|
|
// decrement it. Incrementing must happen in a place like
|
|
// Module.preRun (used by emcc to add file preloading).
|
|
// Note that you can add dependencies in preRun, even though
|
|
// it happens right before run - run will be postponed until
|
|
// the dependencies are met.
|
|
var runDependencies = 0;
|
|
var runDependencyWatcher = null;
|
|
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
|
|
|
|
function getUniqueRunDependency(id) {
|
|
return id;
|
|
}
|
|
|
|
function addRunDependency(id) {
|
|
runDependencies++;
|
|
|
|
if (Module['monitorRunDependencies']) {
|
|
Module['monitorRunDependencies'](runDependencies);
|
|
}
|
|
|
|
}
|
|
|
|
function removeRunDependency(id) {
|
|
runDependencies--;
|
|
|
|
if (Module['monitorRunDependencies']) {
|
|
Module['monitorRunDependencies'](runDependencies);
|
|
}
|
|
|
|
if (runDependencies == 0) {
|
|
if (runDependencyWatcher !== null) {
|
|
clearInterval(runDependencyWatcher);
|
|
runDependencyWatcher = null;
|
|
}
|
|
if (dependenciesFulfilled) {
|
|
var callback = dependenciesFulfilled;
|
|
dependenciesFulfilled = null;
|
|
callback(); // can add another dependenciesFulfilled
|
|
}
|
|
}
|
|
}
|
|
|
|
Module["preloadedImages"] = {}; // maps url to image data
|
|
Module["preloadedAudios"] = {}; // maps url to audio data
|
|
|
|
/** @param {string|number=} what */
|
|
function abort(what) {
|
|
if (Module['onAbort']) {
|
|
Module['onAbort'](what);
|
|
}
|
|
|
|
what += '';
|
|
err(what);
|
|
|
|
ABORT = true;
|
|
EXITSTATUS = 1;
|
|
|
|
what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';
|
|
|
|
// Use a wasm runtime error, because a JS error might be seen as a foreign
|
|
// exception, which means we'd run destructors on it. We need the error to
|
|
// simply make the program stop.
|
|
var e = new WebAssembly.RuntimeError(what);
|
|
|
|
// Throw the error whether or not MODULARIZE is set because abort is used
|
|
// in code paths apart from instantiation where an exception is expected
|
|
// to be thrown when abort is called.
|
|
throw e;
|
|
}
|
|
|
|
// {{MEM_INITIALIZER}}
|
|
|
|
// include: memoryprofiler.js
|
|
|
|
|
|
// end include: memoryprofiler.js
|
|
// include: URIUtils.js
|
|
|
|
|
|
function hasPrefix(str, prefix) {
|
|
return String.prototype.startsWith ?
|
|
str.startsWith(prefix) :
|
|
str.indexOf(prefix) === 0;
|
|
}
|
|
|
|
// Prefix of data URIs emitted by SINGLE_FILE and related options.
|
|
var dataURIPrefix = 'data:application/octet-stream;base64,';
|
|
|
|
// Indicates whether filename is a base64 data URI.
|
|
function isDataURI(filename) {
|
|
return hasPrefix(filename, dataURIPrefix);
|
|
}
|
|
|
|
var fileURIPrefix = "file://";
|
|
|
|
// Indicates whether filename is delivered via file protocol (as opposed to http/https)
|
|
function isFileURI(filename) {
|
|
return hasPrefix(filename, fileURIPrefix);
|
|
}
|
|
|
|
// end include: URIUtils.js
|
|
var wasmBinaryFile = '<<< WASM_BINARY_FILE >>>';
|
|
if (!isDataURI(wasmBinaryFile)) {
|
|
wasmBinaryFile = locateFile(wasmBinaryFile);
|
|
}
|
|
|
|
function getBinary(file) {
|
|
try {
|
|
if (file == wasmBinaryFile && wasmBinary) {
|
|
return new Uint8Array(wasmBinary);
|
|
}
|
|
var binary = tryParseAsDataURI(file);
|
|
if (binary) {
|
|
return binary;
|
|
}
|
|
if (readBinary) {
|
|
return readBinary(file);
|
|
} else {
|
|
throw "sync fetching of the wasm failed: you can preload it to Module['wasmBinary'] manually, or emcc.py will do that for you when generating HTML (but not JS)";
|
|
}
|
|
}
|
|
catch (err) {
|
|
abort(err);
|
|
}
|
|
}
|
|
|
|
function getBinaryPromise() {
|
|
// If we don't have the binary yet, try to to load it asynchronously.
|
|
// Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
|
|
// See https://github.com/github/fetch/pull/92#issuecomment-140665932
|
|
// Cordova or Electron apps are typically loaded from a file:// url.
|
|
// So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
|
|
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
|
|
if (typeof fetch === 'function'
|
|
&& !isFileURI(wasmBinaryFile)
|
|
) {
|
|
return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {
|
|
if (!response['ok']) {
|
|
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
|
|
}
|
|
return response['arrayBuffer']();
|
|
}).catch(function () {
|
|
return getBinary(wasmBinaryFile);
|
|
});
|
|
}
|
|
else {
|
|
if (readAsync) {
|
|
// fetch is not available or url is file => try XHR (readAsync uses XHR internally)
|
|
return new Promise(function(resolve, reject) {
|
|
readAsync(wasmBinaryFile, function(response) { resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))) }, reject)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Otherwise, getBinary should be able to get it synchronously
|
|
return Promise.resolve().then(function() { return getBinary(wasmBinaryFile); });
|
|
}
|
|
|
|
function instantiateSync(file, info) {
|
|
var instance;
|
|
var module;
|
|
var binary;
|
|
try {
|
|
binary = getBinary(file);
|
|
module = new WebAssembly.Module(binary);
|
|
instance = new WebAssembly.Instance(module, info);
|
|
} catch (e) {
|
|
var str = e.toString();
|
|
err('failed to compile wasm module: ' + str);
|
|
if (str.indexOf('imported Memory') >= 0 ||
|
|
str.indexOf('memory import') >= 0) {
|
|
err('Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time).');
|
|
}
|
|
throw e;
|
|
}
|
|
return [instance, module];
|
|
}
|
|
|
|
// Create the wasm instance.
|
|
// Receives the wasm imports, returns the exports.
|
|
function createWasm() {
|
|
// prepare imports
|
|
var info = {
|
|
'env': asmLibraryArg,
|
|
'wasi_snapshot_preview1': asmLibraryArg,
|
|
};
|
|
// Load the wasm module and create an instance of using native support in the JS engine.
|
|
// handle a generated wasm instance, receiving its exports and
|
|
// performing other necessary setup
|
|
/** @param {WebAssembly.Module=} module*/
|
|
function receiveInstance(instance, module) {
|
|
var exports = instance.exports;
|
|
|
|
Module['asm'] = exports;
|
|
|
|
wasmTable = Module['asm']['__indirect_function_table'];
|
|
|
|
removeRunDependency('wasm-instantiate');
|
|
}
|
|
// we can't run yet (except in a pthread, where we have a custom sync instantiator)
|
|
addRunDependency('wasm-instantiate');
|
|
|
|
function receiveInstantiatedSource(output) {
|
|
// 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.
|
|
// receiveInstance() will swap in the exports (to Module.asm) so they can be called
|
|
// TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
|
|
// When the regression is fixed, can restore the above USE_PTHREADS-enabled path.
|
|
receiveInstance(output['instance']);
|
|
}
|
|
|
|
function instantiateArrayBuffer(receiver) {
|
|
return getBinaryPromise().then(function(binary) {
|
|
return WebAssembly.instantiate(binary, info);
|
|
}).then(receiver, function(reason) {
|
|
err('failed to asynchronously prepare wasm: ' + reason);
|
|
|
|
abort(reason);
|
|
});
|
|
}
|
|
|
|
// Prefer streaming instantiation if available.
|
|
|
|
// User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
|
|
// to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel
|
|
// to any other async startup actions they are performing.
|
|
if (Module['instantiateWasm']) {
|
|
try {
|
|
var exports = Module['instantiateWasm'](info, receiveInstance);
|
|
return exports;
|
|
} catch(e) {
|
|
err('Module.instantiateWasm callback failed with error: ' + e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var result = instantiateSync(wasmBinaryFile, info);
|
|
receiveInstance(result[0], result[1]);
|
|
return Module['asm']; // exports were assigned here
|
|
}
|
|
|
|
// Globals used by JS i64 conversions (see makeSetValue)
|
|
var tempDouble;
|
|
var tempI64;
|
|
|
|
// === Body ===
|
|
|
|
var ASM_CONSTS = {
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function callRuntimeCallbacks(callbacks) {
|
|
while(callbacks.length > 0) {
|
|
var callback = callbacks.shift();
|
|
if (typeof callback == 'function') {
|
|
callback(Module); // Pass the module as the first argument.
|
|
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) {
|
|
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 + ']');
|
|
});
|
|
}
|
|
|
|
function jsStackTrace() {
|
|
var error = new Error();
|
|
if (!error.stack) {
|
|
// IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
|
|
// so try that as a special-case.
|
|
try {
|
|
throw new Error();
|
|
} catch(e) {
|
|
error = e;
|
|
}
|
|
if (!error.stack) {
|
|
return '(no stack trace available)';
|
|
}
|
|
}
|
|
return error.stack.toString();
|
|
}
|
|
|
|
function stackTrace() {
|
|
var js = jsStackTrace();
|
|
if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']();
|
|
return demangleAll(js);
|
|
}
|
|
|
|
function _abort() {
|
|
abort();
|
|
}
|
|
|
|
function _emscripten_memcpy_big(dest, src, num) {
|
|
HEAPU8.copyWithin(dest, src, src + num);
|
|
}
|
|
|
|
function _emscripten_get_heap_size() {
|
|
return HEAPU8.length;
|
|
}
|
|
|
|
function abortOnCannotGrowMemory(requestedSize) {
|
|
abort('OOM');
|
|
}
|
|
function _emscripten_resize_heap(requestedSize) {
|
|
abortOnCannotGrowMemory(requestedSize);
|
|
}
|
|
|
|
var SYSCALLS={mappings:{},buffers:[null,[],[]],printChar:function(stream, curr) {
|
|
var buffer = SYSCALLS.buffers[stream];
|
|
if (curr === 0 || curr === 10) {
|
|
(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
|
|
buffer.length = 0;
|
|
} else {
|
|
buffer.push(curr);
|
|
}
|
|
},varargs:undefined,get:function() {
|
|
SYSCALLS.varargs += 4;
|
|
var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
|
|
return ret;
|
|
},getStr:function(ptr) {
|
|
var ret = UTF8ToString(ptr);
|
|
return ret;
|
|
},get64:function(low, high) {
|
|
return low;
|
|
}};
|
|
function _fd_close(fd) {
|
|
return 0;
|
|
}
|
|
|
|
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
|
|
}
|
|
|
|
function flush_NO_FILESYSTEM() {
|
|
// flush anything remaining in the buffers during shutdown
|
|
if (typeof _fflush !== 'undefined') _fflush(0);
|
|
var buffers = SYSCALLS.buffers;
|
|
if (buffers[1].length) SYSCALLS.printChar(1, 10);
|
|
if (buffers[2].length) SYSCALLS.printChar(2, 10);
|
|
}
|
|
function _fd_write(fd, iov, iovcnt, pnum) {
|
|
// hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
|
|
var num = 0;
|
|
for (var i = 0; i < iovcnt; i++) {
|
|
var ptr = HEAP32[(((iov)+(i*8))>>2)];
|
|
var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
|
|
for (var j = 0; j < len; j++) {
|
|
SYSCALLS.printChar(fd, HEAPU8[ptr+j]);
|
|
}
|
|
num += len;
|
|
}
|
|
HEAP32[((pnum)>>2)] = num
|
|
return 0;
|
|
}
|
|
|
|
function _setTempRet0($i) {
|
|
setTempRet0(($i) | 0);
|
|
}
|
|
var ASSERTIONS = false;
|
|
|
|
|
|
|
|
/** @type {function(string, boolean=, number=)} */
|
|
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 > 0xFF) {
|
|
if (ASSERTIONS) {
|
|
assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.');
|
|
}
|
|
chr &= 0xFF;
|
|
}
|
|
ret.push(String.fromCharCode(chr));
|
|
}
|
|
return ret.join('');
|
|
}
|
|
|
|
|
|
// Copied from https://github.com/strophe/strophejs/blob/e06d027/src/polyfills.js#L149
|
|
|
|
// This code was written by Tyler Akins and has been placed in the
|
|
// public domain. It would be nice if you left this header intact.
|
|
// Base64 code from Tyler Akins -- http://rumkin.com
|
|
|
|
/**
|
|
* Decodes a base64 string.
|
|
* @param {string} input The string to decode.
|
|
*/
|
|
var decodeBase64 = typeof atob === 'function' ? atob : function (input) {
|
|
var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
|
|
|
var output = '';
|
|
var chr1, chr2, chr3;
|
|
var enc1, enc2, enc3, enc4;
|
|
var i = 0;
|
|
// remove all characters that are not A-Z, a-z, 0-9, +, /, or =
|
|
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
|
|
do {
|
|
enc1 = keyStr.indexOf(input.charAt(i++));
|
|
enc2 = keyStr.indexOf(input.charAt(i++));
|
|
enc3 = keyStr.indexOf(input.charAt(i++));
|
|
enc4 = keyStr.indexOf(input.charAt(i++));
|
|
|
|
chr1 = (enc1 << 2) | (enc2 >> 4);
|
|
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
|
|
chr3 = ((enc3 & 3) << 6) | enc4;
|
|
|
|
output = output + String.fromCharCode(chr1);
|
|
|
|
if (enc3 !== 64) {
|
|
output = output + String.fromCharCode(chr2);
|
|
}
|
|
if (enc4 !== 64) {
|
|
output = output + String.fromCharCode(chr3);
|
|
}
|
|
} while (i < input.length);
|
|
return output;
|
|
};
|
|
|
|
// Converts a string of base64 into a byte array.
|
|
// Throws error on invalid input.
|
|
function intArrayFromBase64(s) {
|
|
if (typeof ENVIRONMENT_IS_NODE === 'boolean' && ENVIRONMENT_IS_NODE) {
|
|
var buf;
|
|
try {
|
|
// TODO: Update Node.js externs, Closure does not recognize the following Buffer.from()
|
|
/**@suppress{checkTypes}*/
|
|
buf = Buffer.from(s, 'base64');
|
|
} catch (_) {
|
|
buf = new Buffer(s, 'base64');
|
|
}
|
|
return new Uint8Array(buf['buffer'], buf['byteOffset'], buf['byteLength']);
|
|
}
|
|
|
|
try {
|
|
var decoded = decodeBase64(s);
|
|
var bytes = new Uint8Array(decoded.length);
|
|
for (var i = 0 ; i < decoded.length ; ++i) {
|
|
bytes[i] = decoded.charCodeAt(i);
|
|
}
|
|
return bytes;
|
|
} catch (_) {
|
|
throw new Error('Converting base64 string to bytes failed.');
|
|
}
|
|
}
|
|
|
|
// If filename is a base64 data URI, parses and returns data (Buffer on node,
|
|
// Uint8Array otherwise). If filename is not a base64 data URI, returns undefined.
|
|
function tryParseAsDataURI(filename) {
|
|
if (!isDataURI(filename)) {
|
|
return;
|
|
}
|
|
|
|
return intArrayFromBase64(filename.slice(dataURIPrefix.length));
|
|
}
|
|
|
|
|
|
var asmLibraryArg = {
|
|
"abort": _abort,
|
|
"emscripten_memcpy_big": _emscripten_memcpy_big,
|
|
"emscripten_resize_heap": _emscripten_resize_heap,
|
|
"fd_close": _fd_close,
|
|
"fd_seek": _fd_seek,
|
|
"fd_write": _fd_write,
|
|
"getTempRet0": getTempRet0,
|
|
"memory": wasmMemory,
|
|
"setTempRet0": setTempRet0
|
|
};
|
|
var asm = createWasm();
|
|
/** @type {function(...*):?} */
|
|
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = asm["__wasm_call_ctors"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _opus_encoder_create = Module["_opus_encoder_create"] = asm["opus_encoder_create"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _opus_encode_float = Module["_opus_encode_float"] = asm["opus_encode_float"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _opus_encoder_ctl = Module["_opus_encoder_ctl"] = asm["opus_encoder_ctl"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _opus_encoder_destroy = Module["_opus_encoder_destroy"] = asm["opus_encoder_destroy"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _speex_resampler_init = Module["_speex_resampler_init"] = asm["speex_resampler_init"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _speex_resampler_destroy = Module["_speex_resampler_destroy"] = asm["speex_resampler_destroy"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _speex_resampler_process_interleaved_float = Module["_speex_resampler_process_interleaved_float"] = asm["speex_resampler_process_interleaved_float"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var ___errno_location = Module["___errno_location"] = asm["__errno_location"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var stackSave = Module["stackSave"] = asm["stackSave"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var stackRestore = Module["stackRestore"] = asm["stackRestore"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var stackAlloc = Module["stackAlloc"] = asm["stackAlloc"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _malloc = Module["_malloc"] = asm["malloc"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var _free = Module["_free"] = asm["free"]
|
|
|
|
/** @type {function(...*):?} */
|
|
var dynCall_jiji = Module["dynCall_jiji"] = asm["dynCall_jiji"]
|
|
|
|
|
|
|
|
|
|
|
|
// === Auto-generated postamble setup entry stuff ===
|
|
|
|
|
|
|
|
var calledRun;
|
|
|
|
/**
|
|
* @constructor
|
|
* @this {ExitStatus}
|
|
*/
|
|
function ExitStatus(status) {
|
|
this.name = "ExitStatus";
|
|
this.message = "Program terminated with exit(" + status + ")";
|
|
this.status = status;
|
|
}
|
|
|
|
var calledMain = false;
|
|
|
|
dependenciesFulfilled = function runCaller() {
|
|
// If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
|
|
if (!calledRun) run();
|
|
if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
|
|
};
|
|
|
|
/** @type {function(Array=)} */
|
|
function run(args) {
|
|
args = args || arguments_;
|
|
|
|
if (runDependencies > 0) {
|
|
return;
|
|
}
|
|
|
|
preRun();
|
|
|
|
// a preRun added a dependency, run will be called later
|
|
if (runDependencies > 0) {
|
|
return;
|
|
}
|
|
|
|
function doRun() {
|
|
// run may have just been called through dependencies being fulfilled just in this very frame,
|
|
// or while the async setStatus time below was happening
|
|
if (calledRun) return;
|
|
calledRun = true;
|
|
Module['calledRun'] = true;
|
|
|
|
if (ABORT) return;
|
|
|
|
initRuntime();
|
|
|
|
preMain();
|
|
|
|
if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
|
|
|
|
postRun();
|
|
}
|
|
|
|
if (Module['setStatus']) {
|
|
Module['setStatus']('Running...');
|
|
setTimeout(function() {
|
|
setTimeout(function() {
|
|
Module['setStatus']('');
|
|
}, 1);
|
|
doRun();
|
|
}, 1);
|
|
} else
|
|
{
|
|
doRun();
|
|
}
|
|
}
|
|
Module['run'] = run;
|
|
|
|
/** @param {boolean|number=} implicit */
|
|
function exit(status, implicit) {
|
|
|
|
// if this is just main exit-ing implicitly, and the status is 0, then we
|
|
// don't need to do anything here and can just leave. if the status is
|
|
// non-zero, though, then we need to report it.
|
|
// (we may have warned about this earlier, if a situation justifies doing so)
|
|
if (implicit && noExitRuntime && status === 0) {
|
|
return;
|
|
}
|
|
|
|
if (noExitRuntime) {
|
|
} else {
|
|
|
|
EXITSTATUS = status;
|
|
|
|
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()();
|
|
}
|
|
}
|
|
|
|
run();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return Module;
|
|
}, 'OpusEncoderLib'));//END: UMD wrapper
|
|
|