From 992f6c767a71f399f4644a6a9382a0c208358cd2 Mon Sep 17 00:00:00 2001 From: Hajime Hoshi Date: Tue, 3 Jul 2018 21:09:12 +0900 Subject: [PATCH] audio/vorbis: Use stb_vorbis.c on browsers This change adds a Ogg/Vorbis decoder stb_vorbis.c usage that is compiled by Emscripten as WebAssembly. Fixes #623 --- audio/vorbis/internal/stb/.gitignore | 4 + audio/vorbis/internal/stb/build.sh | 2 + audio/vorbis/internal/stb/decode.go | 47 + audio/vorbis/internal/stb/decode.js | 80 + audio/vorbis/internal/stb/decodejs_file_js.go | 6 + audio/vorbis/internal/stb/generate.go | 20 + audio/vorbis/internal/stb/genwasmjs.go | 43 + audio/vorbis/internal/stb/stb_vorbis.c | 5464 +++++++++++++++++ audio/vorbis/internal/stb/stbvorbis.js | 2042 ++++++ .../internal/stb/stbvorbisjs_file_js.go | 6 + audio/vorbis/internal/stb/wasm.js | 4 + audio/vorbis/internal/stb/wasmjs_file_js.go | 6 + audio/vorbis/vorbis.go | 14 +- audio/vorbis/vorbis_js.go | 72 + audio/vorbis/vorbis_notjs.go | 27 + 15 files changed, 7832 insertions(+), 5 deletions(-) create mode 100644 audio/vorbis/internal/stb/.gitignore create mode 100755 audio/vorbis/internal/stb/build.sh create mode 100644 audio/vorbis/internal/stb/decode.go create mode 100644 audio/vorbis/internal/stb/decode.js create mode 100644 audio/vorbis/internal/stb/decodejs_file_js.go create mode 100644 audio/vorbis/internal/stb/generate.go create mode 100644 audio/vorbis/internal/stb/genwasmjs.go create mode 100644 audio/vorbis/internal/stb/stb_vorbis.c create mode 100644 audio/vorbis/internal/stb/stbvorbis.js create mode 100644 audio/vorbis/internal/stb/stbvorbisjs_file_js.go create mode 100644 audio/vorbis/internal/stb/wasm.js create mode 100644 audio/vorbis/internal/stb/wasmjs_file_js.go create mode 100644 audio/vorbis/vorbis_js.go create mode 100644 audio/vorbis/vorbis_notjs.go diff --git a/audio/vorbis/internal/stb/.gitignore b/audio/vorbis/internal/stb/.gitignore new file mode 100644 index 000000000..dcb360688 --- /dev/null +++ b/audio/vorbis/internal/stb/.gitignore @@ -0,0 +1,4 @@ +*.wasm +*.wasm.map +*.wast + diff --git a/audio/vorbis/internal/stb/build.sh b/audio/vorbis/internal/stb/build.sh new file mode 100755 index 000000000..a0a0faa60 --- /dev/null +++ b/audio/vorbis/internal/stb/build.sh @@ -0,0 +1,2 @@ +emcc -Os -o stbvorbis.js -g -DSTB_VORBIS_NO_STDIO -s WASM=1 -s EXPORTED_FUNCTIONS='["_stb_vorbis_decode_memory"]' -s EXTRA_EXPORTED_RUNTIME_METHODS='["ccall","cwrap"]' -s ALLOW_MEMORY_GROWTH=1 stb_vorbis.c +go run genwasmjs.go < stbvorbis.wasm > wasm.js diff --git a/audio/vorbis/internal/stb/decode.go b/audio/vorbis/internal/stb/decode.go new file mode 100644 index 000000000..2b63ea496 --- /dev/null +++ b/audio/vorbis/internal/stb/decode.go @@ -0,0 +1,47 @@ +// Copyright 2018 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package stb + +import ( + "fmt" + + "github.com/gopherjs/gopherwasm/js" +) + +func init() { + // Eval wasm.js first to set the Wasm binary to Module. + js.Global().Get("window").Call("eval", string(wasm_js)) + + js.Global().Get("window").Call("eval", string(stbvorbis_js)) + js.Global().Get("window").Call("eval", string(decode_js)) + + ch := make(chan struct{}) + js.Global().Get("_ebiten").Call("initializeVorbisDecoder", js.NewCallback(func([]js.Value) { + close(ch) + })) + <-ch +} + +func DecodeVorbis(buf []byte) ([]int16, int, int, error) { + r := js.Global().Get("_ebiten").Call("decodeVorbis", buf) + if r == js.Null() { + return nil, 0, 0, fmt.Errorf("audio/vorbis/internal/stb: decode failed") + } + data := make([]int16, r.Get("data").Get("length").Int()) + // TODO: Use js.TypeArrayOf + arr := js.ValueOf(data) + arr.Call("set", r.Get("data")) + return data, r.Get("channels").Int(), r.Get("sampleRate").Int(), nil +} diff --git a/audio/vorbis/internal/stb/decode.js b/audio/vorbis/internal/stb/decode.js new file mode 100644 index 000000000..d14e2462e --- /dev/null +++ b/audio/vorbis/internal/stb/decode.js @@ -0,0 +1,80 @@ +// Copyright 2018 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +var _ebiten = {}; + +(() => { + var decodeMemory = null; + var vorbisDecoderInitialized = null; + + _ebiten.initializeVorbisDecoder = (callback) => { + Module.run(); + vorbisDecoderInitialized = callback; + }; + + Module.onRuntimeInitialized = () => { + decodeMemory = Module.cwrap('stb_vorbis_decode_memory', 'number', ['number', 'number', 'number', 'number', 'number']); + if (vorbisDecoderInitialized) { + vorbisDecoderInitialized(); + } + } + + function arrayToHeap(typedArray){ + const ptr = Module._malloc(typedArray.byteLength); + const heapBytes = new Uint8Array(Module.HEAPU8.buffer, ptr, typedArray.byteLength); + heapBytes.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength)); + return heapBytes; + } + + function ptrToInt32(ptr) { + const a = new Int32Array(Module.HEAPU8.buffer, ptr, 1); + return a[0]; + } + + function ptrToFloat32(ptr) { + const a = new Float32Array(Module.HEAPU8.buffer, ptr, 1); + return a[0]; + } + + function ptrToInt16s(ptr, length) { + const buf = new ArrayBuffer(length * Int16Array.BYTES_PER_ELEMENT); + const copied = new Int16Array(buf); + copied.set(new Int16Array(Module.HEAPU8.buffer, ptr, length)); + return copied; + } + + _ebiten.decodeVorbis = (buf) => { + const copiedBuf = arrayToHeap(buf); + const channelsPtr = Module._malloc(4); + const sampleRatePtr = Module._malloc(4); + const outputPtr = Module._malloc(4); + const length = decodeMemory(copiedBuf.byteOffset, copiedBuf.length, channelsPtr, sampleRatePtr, outputPtr); + if (length < 0) { + return null; + } + const channels = ptrToInt32(channelsPtr); + const result = { + data: ptrToInt16s(ptrToInt32(outputPtr), length * channels), + channels: channels, + sampleRate: ptrToInt32(sampleRatePtr), + }; + + Module._free(copiedBuf.byteOffset); + Module._free(channelsPtr); + Module._free(sampleRatePtr); + Module._free(ptrToInt32(outputPtr)); + Module._free(outputPtr); + return result; + }; +})(); diff --git a/audio/vorbis/internal/stb/decodejs_file_js.go b/audio/vorbis/internal/stb/decodejs_file_js.go new file mode 100644 index 000000000..a816fbd6b --- /dev/null +++ b/audio/vorbis/internal/stb/decodejs_file_js.go @@ -0,0 +1,6 @@ +// Code generated by file2byteslice. DO NOT EDIT. +// (gofmt is fine after generating) + +package stb + +var decode_js = []byte("// Copyright 2018 The Ebiten Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nvar _ebiten = {};\n\n(() => {\n var decodeMemory = null;\n var vorbisDecoderInitialized = null;\n\n _ebiten.initializeVorbisDecoder = (callback) => {\n Module.run();\n vorbisDecoderInitialized = callback;\n };\n\n Module.onRuntimeInitialized = () => {\n decodeMemory = Module.cwrap('stb_vorbis_decode_memory', 'number', ['number', 'number', 'number', 'number', 'number']);\n if (vorbisDecoderInitialized) {\n vorbisDecoderInitialized();\n }\n }\n\n function arrayToHeap(typedArray){\n const ptr = Module._malloc(typedArray.byteLength);\n const heapBytes = new Uint8Array(Module.HEAPU8.buffer, ptr, typedArray.byteLength);\n heapBytes.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength));\n return heapBytes;\n }\n\n function ptrToInt32(ptr) {\n const a = new Int32Array(Module.HEAPU8.buffer, ptr, 1);\n return a[0];\n }\n\n function ptrToFloat32(ptr) {\n const a = new Float32Array(Module.HEAPU8.buffer, ptr, 1);\n return a[0];\n }\n\n function ptrToInt16s(ptr, length) {\n const buf = new ArrayBuffer(length * Int16Array.BYTES_PER_ELEMENT);\n const copied = new Int16Array(buf);\n copied.set(new Int16Array(Module.HEAPU8.buffer, ptr, length));\n return copied;\n }\n\n _ebiten.decodeVorbis = (buf) => {\n const copiedBuf = arrayToHeap(buf);\n const channelsPtr = Module._malloc(4);\n const sampleRatePtr = Module._malloc(4);\n const outputPtr = Module._malloc(4);\n const length = decodeMemory(copiedBuf.byteOffset, copiedBuf.length, channelsPtr, sampleRatePtr, outputPtr);\n if (length < 0) {\n return null;\n }\n const channels = ptrToInt32(channelsPtr);\n const result = {\n data: ptrToInt16s(ptrToInt32(outputPtr), length * channels),\n channels: channels,\n sampleRate: ptrToInt32(sampleRatePtr),\n };\n\n Module._free(copiedBuf.byteOffset);\n Module._free(channelsPtr);\n Module._free(sampleRatePtr);\n Module._free(ptrToInt32(outputPtr));\n Module._free(outputPtr);\n return result;\n };\n})();\n") diff --git a/audio/vorbis/internal/stb/generate.go b/audio/vorbis/internal/stb/generate.go new file mode 100644 index 000000000..3c75cd884 --- /dev/null +++ b/audio/vorbis/internal/stb/generate.go @@ -0,0 +1,20 @@ +// Copyright 2018 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package stb + +//go:generate bash build.sh +//go:generate file2byteslice -package=stb -input=decode.js -output=decodejs_file_js.go -var=decode_js +//go:generate file2byteslice -package=stb -input=stbvorbis.js -output=stbvorbisjs_file_js.go -var=stbvorbis_js +//go:generate file2byteslice -package=stb -input=wasm.js -output=wasmjs_file_js.go -var=wasm_js diff --git a/audio/vorbis/internal/stb/genwasmjs.go b/audio/vorbis/internal/stb/genwasmjs.go new file mode 100644 index 000000000..f121dd796 --- /dev/null +++ b/audio/vorbis/internal/stb/genwasmjs.go @@ -0,0 +1,43 @@ +// Copyright 2018 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build ignore + +package main + +import ( + "encoding/base64" + "fmt" + "io/ioutil" + "os" +) + +func run() error { + bin, err := ioutil.ReadAll(os.Stdin) + if err != nil { + return err + } + + fmt.Println("// Code generated by genwasmjs.go. DO NOT EDIT.") + fmt.Println("") + fmt.Println("var Module = typeof Module !== 'undefined' ? Module : {};") + fmt.Printf("Module['wasmBinary'] = Uint8Array.from(atob(%q), c => c.charCodeAt(0));\n", base64.StdEncoding.EncodeToString(bin)) + return nil +} + +func main() { + if err := run(); err != nil { + panic(err) + } +} diff --git a/audio/vorbis/internal/stb/stb_vorbis.c b/audio/vorbis/internal/stb/stb_vorbis.c new file mode 100644 index 000000000..305e951e1 --- /dev/null +++ b/audio/vorbis/internal/stb/stb_vorbis.c @@ -0,0 +1,5464 @@ +// +build ignore + +// Ogg Vorbis audio decoder - v1.14 - public domain +// http://nothings.org/stb_vorbis/ +// +// Original version written by Sean Barrett in 2007. +// +// Originally sponsored by RAD Game Tools. Seeking implementation +// sponsored by Phillip Bennefall, Marc Andersen, Aaron Baker, +// Elias Software, Aras Pranckevicius, and Sean Barrett. +// +// LICENSE +// +// See end of file for license information. +// +// Limitations: +// +// - floor 0 not supported (used in old ogg vorbis files pre-2004) +// - lossless sample-truncation at beginning ignored +// - cannot concatenate multiple vorbis streams +// - sample positions are 32-bit, limiting seekable 192Khz +// files to around 6 hours (Ogg supports 64-bit) +// +// Feature contributors: +// Dougall Johnson (sample-exact seeking) +// +// Bugfix/warning contributors: +// Terje Mathisen Niklas Frykholm Andy Hill +// Casey Muratori John Bolton Gargaj +// Laurent Gomila Marc LeBlanc Ronny Chevalier +// Bernhard Wodo Evan Balster alxprd@github +// Tom Beaumont Ingo Leitgeb Nicolas Guillemot +// Phillip Bennefall Rohit Thiago Goulart +// manxorist@github saga musix github:infatum +// Timur Gagiev +// +// Partial history: +// 1.14 - 2018-02-11 - delete bogus dealloca usage +// 1.13 - 2018-01-29 - fix truncation of last frame (hopefully) +// 1.12 - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files +// 1.11 - 2017-07-23 - fix MinGW compilation +// 1.10 - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory +// 1.09 - 2016-04-04 - back out 'truncation of last frame' fix from previous version +// 1.08 - 2016-04-02 - warnings; setup memory leaks; truncation of last frame +// 1.07 - 2015-01-16 - fixes for crashes on invalid files; warning fixes; const +// 1.06 - 2015-08-31 - full, correct support for seeking API (Dougall Johnson) +// some crash fixes when out of memory or with corrupt files +// fix some inappropriately signed shifts +// 1.05 - 2015-04-19 - don't define __forceinline if it's redundant +// 1.04 - 2014-08-27 - fix missing const-correct case in API +// 1.03 - 2014-08-07 - warning fixes +// 1.02 - 2014-07-09 - declare qsort comparison as explicitly _cdecl in Windows +// 1.01 - 2014-06-18 - fix stb_vorbis_get_samples_float (interleaved was correct) +// 1.0 - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in >2-channel; +// (API change) report sample rate for decode-full-file funcs +// +// See end of file for full version history. + + +////////////////////////////////////////////////////////////////////////////// +// +// HEADER BEGINS HERE +// + +#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H +#define STB_VORBIS_INCLUDE_STB_VORBIS_H + +#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO) +#define STB_VORBIS_NO_STDIO 1 +#endif + +#ifndef STB_VORBIS_NO_STDIO +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/////////// THREAD SAFETY + +// Individual stb_vorbis* handles are not thread-safe; you cannot decode from +// them from multiple threads at the same time. However, you can have multiple +// stb_vorbis* handles and decode from them independently in multiple thrads. + + +/////////// MEMORY ALLOCATION + +// normally stb_vorbis uses malloc() to allocate memory at startup, +// and alloca() to allocate temporary memory during a frame on the +// stack. (Memory consumption will depend on the amount of setup +// data in the file and how you set the compile flags for speed +// vs. size. In my test files the maximal-size usage is ~150KB.) +// +// You can modify the wrapper functions in the source (setup_malloc, +// setup_temp_malloc, temp_malloc) to change this behavior, or you +// can use a simpler allocation model: you pass in a buffer from +// which stb_vorbis will allocate _all_ its memory (including the +// temp memory). "open" may fail with a VORBIS_outofmem if you +// do not pass in enough data; there is no way to determine how +// much you do need except to succeed (at which point you can +// query get_info to find the exact amount required. yes I know +// this is lame). +// +// If you pass in a non-NULL buffer of the type below, allocation +// will occur from it as described above. Otherwise just pass NULL +// to use malloc()/alloca() + +typedef struct +{ + char *alloc_buffer; + int alloc_buffer_length_in_bytes; +} stb_vorbis_alloc; + + +/////////// FUNCTIONS USEABLE WITH ALL INPUT MODES + +typedef struct stb_vorbis stb_vorbis; + +typedef struct +{ + unsigned int sample_rate; + int channels; + + unsigned int setup_memory_required; + unsigned int setup_temp_memory_required; + unsigned int temp_memory_required; + + int max_frame_size; +} stb_vorbis_info; + +// get general information about the file +extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f); + +// get the last error detected (clears it, too) +extern int stb_vorbis_get_error(stb_vorbis *f); + +// close an ogg vorbis file and free all memory in use +extern void stb_vorbis_close(stb_vorbis *f); + +// this function returns the offset (in samples) from the beginning of the +// file that will be returned by the next decode, if it is known, or -1 +// otherwise. after a flush_pushdata() call, this may take a while before +// it becomes valid again. +// NOT WORKING YET after a seek with PULLDATA API +extern int stb_vorbis_get_sample_offset(stb_vorbis *f); + +// returns the current seek point within the file, or offset from the beginning +// of the memory buffer. In pushdata mode it returns 0. +extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f); + +/////////// PUSHDATA API + +#ifndef STB_VORBIS_NO_PUSHDATA_API + +// this API allows you to get blocks of data from any source and hand +// them to stb_vorbis. you have to buffer them; stb_vorbis will tell +// you how much it used, and you have to give it the rest next time; +// and stb_vorbis may not have enough data to work with and you will +// need to give it the same data again PLUS more. Note that the Vorbis +// specification does not bound the size of an individual frame. + +extern stb_vorbis *stb_vorbis_open_pushdata( + const unsigned char * datablock, int datablock_length_in_bytes, + int *datablock_memory_consumed_in_bytes, + int *error, + const stb_vorbis_alloc *alloc_buffer); +// create a vorbis decoder by passing in the initial data block containing +// the ogg&vorbis headers (you don't need to do parse them, just provide +// the first N bytes of the file--you're told if it's not enough, see below) +// on success, returns an stb_vorbis *, does not set error, returns the amount of +// data parsed/consumed on this call in *datablock_memory_consumed_in_bytes; +// on failure, returns NULL on error and sets *error, does not change *datablock_memory_consumed +// if returns NULL and *error is VORBIS_need_more_data, then the input block was +// incomplete and you need to pass in a larger block from the start of the file + +extern int stb_vorbis_decode_frame_pushdata( + stb_vorbis *f, + const unsigned char *datablock, int datablock_length_in_bytes, + int *channels, // place to write number of float * buffers + float ***output, // place to write float ** array of float * buffers + int *samples // place to write number of output samples + ); +// decode a frame of audio sample data if possible from the passed-in data block +// +// return value: number of bytes we used from datablock +// +// possible cases: +// 0 bytes used, 0 samples output (need more data) +// N bytes used, 0 samples output (resynching the stream, keep going) +// N bytes used, M samples output (one frame of data) +// note that after opening a file, you will ALWAYS get one N-bytes,0-sample +// frame, because Vorbis always "discards" the first frame. +// +// Note that on resynch, stb_vorbis will rarely consume all of the buffer, +// instead only datablock_length_in_bytes-3 or less. This is because it wants +// to avoid missing parts of a page header if they cross a datablock boundary, +// without writing state-machiney code to record a partial detection. +// +// The number of channels returned are stored in *channels (which can be +// NULL--it is always the same as the number of channels reported by +// get_info). *output will contain an array of float* buffers, one per +// channel. In other words, (*output)[0][0] contains the first sample from +// the first channel, and (*output)[1][0] contains the first sample from +// the second channel. + +extern void stb_vorbis_flush_pushdata(stb_vorbis *f); +// inform stb_vorbis that your next datablock will not be contiguous with +// previous ones (e.g. you've seeked in the data); future attempts to decode +// frames will cause stb_vorbis to resynchronize (as noted above), and +// once it sees a valid Ogg page (typically 4-8KB, as large as 64KB), it +// will begin decoding the _next_ frame. +// +// if you want to seek using pushdata, you need to seek in your file, then +// call stb_vorbis_flush_pushdata(), then start calling decoding, then once +// decoding is returning you data, call stb_vorbis_get_sample_offset, and +// if you don't like the result, seek your file again and repeat. +#endif + + +////////// PULLING INPUT API + +#ifndef STB_VORBIS_NO_PULLDATA_API +// This API assumes stb_vorbis is allowed to pull data from a source-- +// either a block of memory containing the _entire_ vorbis stream, or a +// FILE * that you or it create, or possibly some other reading mechanism +// if you go modify the source to replace the FILE * case with some kind +// of callback to your code. (But if you don't support seeking, you may +// just want to go ahead and use pushdata.) + +#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION) +extern int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output); +#endif +#if !defined(STB_VORBIS_NO_INTEGER_CONVERSION) +extern int stb_vorbis_decode_memory(const unsigned char *mem, int len, int *channels, int *sample_rate, short **output); +#endif +// decode an entire file and output the data interleaved into a malloc()ed +// buffer stored in *output. The return value is the number of samples +// decoded, or -1 if the file could not be opened or was not an ogg vorbis file. +// When you're done with it, just free() the pointer returned in *output. + +extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from an ogg vorbis stream in memory (note +// this must be the entire stream!). on failure, returns NULL and sets *error + +#ifndef STB_VORBIS_NO_STDIO +extern stb_vorbis * stb_vorbis_open_filename(const char *filename, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from a filename via fopen(). on failure, +// returns NULL and sets *error (possibly to VORBIS_file_open_failure). + +extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from an open FILE *, looking for a stream at +// the _current_ seek point (ftell). on failure, returns NULL and sets *error. +// note that stb_vorbis must "own" this stream; if you seek it in between +// calls to stb_vorbis, it will become confused. Morever, if you attempt to +// perform stb_vorbis_seek_*() operations on this file, it will assume it +// owns the _entire_ rest of the file after the start point. Use the next +// function, stb_vorbis_open_file_section(), to limit it. + +extern stb_vorbis * stb_vorbis_open_file_section(FILE *f, int close_handle_on_close, + int *error, const stb_vorbis_alloc *alloc_buffer, unsigned int len); +// create an ogg vorbis decoder from an open FILE *, looking for a stream at +// the _current_ seek point (ftell); the stream will be of length 'len' bytes. +// on failure, returns NULL and sets *error. note that stb_vorbis must "own" +// this stream; if you seek it in between calls to stb_vorbis, it will become +// confused. +#endif + +extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number); +extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number); +// these functions seek in the Vorbis file to (approximately) 'sample_number'. +// after calling seek_frame(), the next call to get_frame_*() will include +// the specified sample. after calling stb_vorbis_seek(), the next call to +// stb_vorbis_get_samples_* will start with the specified sample. If you +// do not need to seek to EXACTLY the target sample when using get_samples_*, +// you can also use seek_frame(). + +extern int stb_vorbis_seek_start(stb_vorbis *f); +// this function is equivalent to stb_vorbis_seek(f,0) + +extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f); +extern float stb_vorbis_stream_length_in_seconds(stb_vorbis *f); +// these functions return the total length of the vorbis stream + +extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output); +// decode the next frame and return the number of samples. the number of +// channels returned are stored in *channels (which can be NULL--it is always +// the same as the number of channels reported by get_info). *output will +// contain an array of float* buffers, one per channel. These outputs will +// be overwritten on the next call to stb_vorbis_get_frame_*. +// +// You generally should not intermix calls to stb_vorbis_get_frame_*() +// and stb_vorbis_get_samples_*(), since the latter calls the former. + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +extern int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts); +extern int stb_vorbis_get_frame_short (stb_vorbis *f, int num_c, short **buffer, int num_samples); +#endif +// decode the next frame and return the number of *samples* per channel. +// Note that for interleaved data, you pass in the number of shorts (the +// size of your array), but the return value is the number of samples per +// channel, not the total number of samples. +// +// The data is coerced to the number of channels you request according to the +// channel coercion rules (see below). You must pass in the size of your +// buffer(s) so that stb_vorbis will not overwrite the end of the buffer. +// The maximum buffer size needed can be gotten from get_info(); however, +// the Vorbis I specification implies an absolute maximum of 4096 samples +// per channel. + +// Channel coercion rules: +// Let M be the number of channels requested, and N the number of channels present, +// and Cn be the nth channel; let stereo L be the sum of all L and center channels, +// and stereo R be the sum of all R and center channels (channel assignment from the +// vorbis spec). +// M N output +// 1 k sum(Ck) for all k +// 2 * stereo L, stereo R +// k l k > l, the first l channels, then 0s +// k l k <= l, the first k channels +// Note that this is not _good_ surround etc. mixing at all! It's just so +// you get something useful. + +extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats); +extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples); +// gets num_samples samples, not necessarily on a frame boundary--this requires +// buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES. +// Returns the number of samples stored per channel; it may be less than requested +// at the end of the file. If there are no more samples in the file, returns 0. + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +extern int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts); +extern int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int num_samples); +#endif +// gets num_samples samples, not necessarily on a frame boundary--this requires +// buffering so you have to supply the buffers. Applies the coercion rules above +// to produce 'channels' channels. Returns the number of samples stored per channel; +// it may be less than requested at the end of the file. If there are no more +// samples in the file, returns 0. + +#endif + +//////// ERROR CODES + +enum STBVorbisError +{ + VORBIS__no_error, + + VORBIS_need_more_data=1, // not a real error + + VORBIS_invalid_api_mixing, // can't mix API modes + VORBIS_outofmem, // not enough memory + VORBIS_feature_not_supported, // uses floor 0 + VORBIS_too_many_channels, // STB_VORBIS_MAX_CHANNELS is too small + VORBIS_file_open_failure, // fopen() failed + VORBIS_seek_without_length, // can't seek in unknown-length file + + VORBIS_unexpected_eof=10, // file is truncated? + VORBIS_seek_invalid, // seek past EOF + + // decoding errors (corrupt/invalid stream) -- you probably + // don't care about the exact details of these + + // vorbis errors: + VORBIS_invalid_setup=20, + VORBIS_invalid_stream, + + // ogg errors: + VORBIS_missing_capture_pattern=30, + VORBIS_invalid_stream_structure_version, + VORBIS_continued_packet_flag_invalid, + VORBIS_incorrect_stream_serial_number, + VORBIS_invalid_first_page, + VORBIS_bad_packet_type, + VORBIS_cant_find_last_page, + VORBIS_seek_failed +}; + + +#ifdef __cplusplus +} +#endif + +#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H +// +// HEADER ENDS HERE +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef STB_VORBIS_HEADER_ONLY + +// global configuration settings (e.g. set these in the project/makefile), +// or just set them in this file at the top (although ideally the first few +// should be visible when the header file is compiled too, although it's not +// crucial) + +// STB_VORBIS_NO_PUSHDATA_API +// does not compile the code for the various stb_vorbis_*_pushdata() +// functions +// #define STB_VORBIS_NO_PUSHDATA_API + +// STB_VORBIS_NO_PULLDATA_API +// does not compile the code for the non-pushdata APIs +// #define STB_VORBIS_NO_PULLDATA_API + +// STB_VORBIS_NO_STDIO +// does not compile the code for the APIs that use FILE *s internally +// or externally (implied by STB_VORBIS_NO_PULLDATA_API) +// #define STB_VORBIS_NO_STDIO + +// STB_VORBIS_NO_INTEGER_CONVERSION +// does not compile the code for converting audio sample data from +// float to integer (implied by STB_VORBIS_NO_PULLDATA_API) +// #define STB_VORBIS_NO_INTEGER_CONVERSION + +// STB_VORBIS_NO_FAST_SCALED_FLOAT +// does not use a fast float-to-int trick to accelerate float-to-int on +// most platforms which requires endianness be defined correctly. +//#define STB_VORBIS_NO_FAST_SCALED_FLOAT + + +// STB_VORBIS_MAX_CHANNELS [number] +// globally define this to the maximum number of channels you need. +// The spec does not put a restriction on channels except that +// the count is stored in a byte, so 255 is the hard limit. +// Reducing this saves about 16 bytes per value, so using 16 saves +// (255-16)*16 or around 4KB. Plus anything other memory usage +// I forgot to account for. Can probably go as low as 8 (7.1 audio), +// 6 (5.1 audio), or 2 (stereo only). +#ifndef STB_VORBIS_MAX_CHANNELS +#define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone? +#endif + +// STB_VORBIS_PUSHDATA_CRC_COUNT [number] +// after a flush_pushdata(), stb_vorbis begins scanning for the +// next valid page, without backtracking. when it finds something +// that looks like a page, it streams through it and verifies its +// CRC32. Should that validation fail, it keeps scanning. But it's +// possible that _while_ streaming through to check the CRC32 of +// one candidate page, it sees another candidate page. This #define +// determines how many "overlapping" candidate pages it can search +// at once. Note that "real" pages are typically ~4KB to ~8KB, whereas +// garbage pages could be as big as 64KB, but probably average ~16KB. +// So don't hose ourselves by scanning an apparent 64KB page and +// missing a ton of real ones in the interim; so minimum of 2 +#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT +#define STB_VORBIS_PUSHDATA_CRC_COUNT 4 +#endif + +// STB_VORBIS_FAST_HUFFMAN_LENGTH [number] +// sets the log size of the huffman-acceleration table. Maximum +// supported value is 24. with larger numbers, more decodings are O(1), +// but the table size is larger so worse cache missing, so you'll have +// to probe (and try multiple ogg vorbis files) to find the sweet spot. +#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH +#define STB_VORBIS_FAST_HUFFMAN_LENGTH 10 +#endif + +// STB_VORBIS_FAST_BINARY_LENGTH [number] +// sets the log size of the binary-search acceleration table. this +// is used in similar fashion to the fast-huffman size to set initial +// parameters for the binary search + +// STB_VORBIS_FAST_HUFFMAN_INT +// The fast huffman tables are much more efficient if they can be +// stored as 16-bit results instead of 32-bit results. This restricts +// the codebooks to having only 65535 possible outcomes, though. +// (At least, accelerated by the huffman table.) +#ifndef STB_VORBIS_FAST_HUFFMAN_INT +#define STB_VORBIS_FAST_HUFFMAN_SHORT +#endif + +// STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH +// If the 'fast huffman' search doesn't succeed, then stb_vorbis falls +// back on binary searching for the correct one. This requires storing +// extra tables with the huffman codes in sorted order. Defining this +// symbol trades off space for speed by forcing a linear search in the +// non-fast case, except for "sparse" codebooks. +// #define STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH + +// STB_VORBIS_DIVIDES_IN_RESIDUE +// stb_vorbis precomputes the result of the scalar residue decoding +// that would otherwise require a divide per chunk. you can trade off +// space for time by defining this symbol. +// #define STB_VORBIS_DIVIDES_IN_RESIDUE + +// STB_VORBIS_DIVIDES_IN_CODEBOOK +// vorbis VQ codebooks can be encoded two ways: with every case explicitly +// stored, or with all elements being chosen from a small range of values, +// and all values possible in all elements. By default, stb_vorbis expands +// this latter kind out to look like the former kind for ease of decoding, +// because otherwise an integer divide-per-vector-element is required to +// unpack the index. If you define STB_VORBIS_DIVIDES_IN_CODEBOOK, you can +// trade off storage for speed. +//#define STB_VORBIS_DIVIDES_IN_CODEBOOK + +#ifdef STB_VORBIS_CODEBOOK_SHORTS +#error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats" +#endif + +// STB_VORBIS_DIVIDE_TABLE +// this replaces small integer divides in the floor decode loop with +// table lookups. made less than 1% difference, so disabled by default. + +// STB_VORBIS_NO_INLINE_DECODE +// disables the inlining of the scalar codebook fast-huffman decode. +// might save a little codespace; useful for debugging +// #define STB_VORBIS_NO_INLINE_DECODE + +// STB_VORBIS_NO_DEFER_FLOOR +// Normally we only decode the floor without synthesizing the actual +// full curve. We can instead synthesize the curve immediately. This +// requires more memory and is very likely slower, so I don't think +// you'd ever want to do it except for debugging. +// #define STB_VORBIS_NO_DEFER_FLOOR + + + + +////////////////////////////////////////////////////////////////////////////// + +#ifdef STB_VORBIS_NO_PULLDATA_API + #define STB_VORBIS_NO_INTEGER_CONVERSION + #define STB_VORBIS_NO_STDIO +#endif + +#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO) + #define STB_VORBIS_NO_STDIO 1 +#endif + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT + + // only need endianness for fast-float-to-int, which we don't + // use for pushdata + + #ifndef STB_VORBIS_BIG_ENDIAN + #define STB_VORBIS_ENDIAN 0 + #else + #define STB_VORBIS_ENDIAN 1 + #endif + +#endif +#endif + + +#ifndef STB_VORBIS_NO_STDIO +#include +#endif + +#ifndef STB_VORBIS_NO_CRT + #include + #include + #include + #include + + // find definition of alloca if it's not in stdlib.h: + #if defined(_MSC_VER) || defined(__MINGW32__) + #include + #endif + #if defined(__linux__) || defined(__linux) || defined(__EMSCRIPTEN__) + #include + #endif +#else // STB_VORBIS_NO_CRT + #define NULL 0 + #define malloc(s) 0 + #define free(s) ((void) 0) + #define realloc(s) 0 +#endif // STB_VORBIS_NO_CRT + +#include + +#ifdef __MINGW32__ + // eff you mingw: + // "fixed": + // http://sourceforge.net/p/mingw-w64/mailman/message/32882927/ + // "no that broke the build, reverted, who cares about C": + // http://sourceforge.net/p/mingw-w64/mailman/message/32890381/ + #ifdef __forceinline + #undef __forceinline + #endif + #define __forceinline + #define alloca __builtin_alloca +#elif !defined(_MSC_VER) + #if __GNUC__ + #define __forceinline inline + #else + #define __forceinline + #endif +#endif + +#if STB_VORBIS_MAX_CHANNELS > 256 +#error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range" +#endif + +#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24 +#error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range" +#endif + + +#if 0 +#include +#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1]) +#else +#define CHECK(f) ((void) 0) +#endif + +#define MAX_BLOCKSIZE_LOG 13 // from specification +#define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG) + + +typedef unsigned char uint8; +typedef signed char int8; +typedef unsigned short uint16; +typedef signed short int16; +typedef unsigned int uint32; +typedef signed int int32; + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +typedef float codetype; + +// @NOTE +// +// Some arrays below are tagged "//varies", which means it's actually +// a variable-sized piece of data, but rather than malloc I assume it's +// small enough it's better to just allocate it all together with the +// main thing +// +// Most of the variables are specified with the smallest size I could pack +// them into. It might give better performance to make them all full-sized +// integers. It should be safe to freely rearrange the structures or change +// the sizes larger--nothing relies on silently truncating etc., nor the +// order of variables. + +#define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH) +#define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1) + +typedef struct +{ + int dimensions, entries; + uint8 *codeword_lengths; + float minimum_value; + float delta_value; + uint8 value_bits; + uint8 lookup_type; + uint8 sequence_p; + uint8 sparse; + uint32 lookup_values; + codetype *multiplicands; + uint32 *codewords; + #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT + int16 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]; + #else + int32 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]; + #endif + uint32 *sorted_codewords; + int *sorted_values; + int sorted_entries; +} Codebook; + +typedef struct +{ + uint8 order; + uint16 rate; + uint16 bark_map_size; + uint8 amplitude_bits; + uint8 amplitude_offset; + uint8 number_of_books; + uint8 book_list[16]; // varies +} Floor0; + +typedef struct +{ + uint8 partitions; + uint8 partition_class_list[32]; // varies + uint8 class_dimensions[16]; // varies + uint8 class_subclasses[16]; // varies + uint8 class_masterbooks[16]; // varies + int16 subclass_books[16][8]; // varies + uint16 Xlist[31*8+2]; // varies + uint8 sorted_order[31*8+2]; + uint8 neighbors[31*8+2][2]; + uint8 floor1_multiplier; + uint8 rangebits; + int values; +} Floor1; + +typedef union +{ + Floor0 floor0; + Floor1 floor1; +} Floor; + +typedef struct +{ + uint32 begin, end; + uint32 part_size; + uint8 classifications; + uint8 classbook; + uint8 **classdata; + int16 (*residue_books)[8]; +} Residue; + +typedef struct +{ + uint8 magnitude; + uint8 angle; + uint8 mux; +} MappingChannel; + +typedef struct +{ + uint16 coupling_steps; + MappingChannel *chan; + uint8 submaps; + uint8 submap_floor[15]; // varies + uint8 submap_residue[15]; // varies +} Mapping; + +typedef struct +{ + uint8 blockflag; + uint8 mapping; + uint16 windowtype; + uint16 transformtype; +} Mode; + +typedef struct +{ + uint32 goal_crc; // expected crc if match + int bytes_left; // bytes left in packet + uint32 crc_so_far; // running crc + int bytes_done; // bytes processed in _current_ chunk + uint32 sample_loc; // granule pos encoded in page +} CRCscan; + +typedef struct +{ + uint32 page_start, page_end; + uint32 last_decoded_sample; +} ProbedPage; + +struct stb_vorbis +{ + // user-accessible info + unsigned int sample_rate; + int channels; + + unsigned int setup_memory_required; + unsigned int temp_memory_required; + unsigned int setup_temp_memory_required; + + // input config +#ifndef STB_VORBIS_NO_STDIO + FILE *f; + uint32 f_start; + int close_on_free; +#endif + + uint8 *stream; + uint8 *stream_start; + uint8 *stream_end; + + uint32 stream_len; + + uint8 push_mode; + + uint32 first_audio_page_offset; + + ProbedPage p_first, p_last; + + // memory management + stb_vorbis_alloc alloc; + int setup_offset; + int temp_offset; + + // run-time results + int eof; + enum STBVorbisError error; + + // user-useful data + + // header info + int blocksize[2]; + int blocksize_0, blocksize_1; + int codebook_count; + Codebook *codebooks; + int floor_count; + uint16 floor_types[64]; // varies + Floor *floor_config; + int residue_count; + uint16 residue_types[64]; // varies + Residue *residue_config; + int mapping_count; + Mapping *mapping; + int mode_count; + Mode mode_config[64]; // varies + + uint32 total_samples; + + // decode buffer + float *channel_buffers[STB_VORBIS_MAX_CHANNELS]; + float *outputs [STB_VORBIS_MAX_CHANNELS]; + + float *previous_window[STB_VORBIS_MAX_CHANNELS]; + int previous_length; + + #ifndef STB_VORBIS_NO_DEFER_FLOOR + int16 *finalY[STB_VORBIS_MAX_CHANNELS]; + #else + float *floor_buffers[STB_VORBIS_MAX_CHANNELS]; + #endif + + uint32 current_loc; // sample location of next frame to decode + int current_loc_valid; + + // per-blocksize precomputed data + + // twiddle factors + float *A[2],*B[2],*C[2]; + float *window[2]; + uint16 *bit_reverse[2]; + + // current page/packet/segment streaming info + uint32 serial; // stream serial number for verification + int last_page; + int segment_count; + uint8 segments[255]; + uint8 page_flag; + uint8 bytes_in_seg; + uint8 first_decode; + int next_seg; + int last_seg; // flag that we're on the last segment + int last_seg_which; // what was the segment number of the last seg? + uint32 acc; + int valid_bits; + int packet_bytes; + int end_seg_with_known_loc; + uint32 known_loc_for_packet; + int discard_samples_deferred; + uint32 samples_output; + + // push mode scanning + int page_crc_tests; // only in push_mode: number of tests active; -1 if not searching +#ifndef STB_VORBIS_NO_PUSHDATA_API + CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT]; +#endif + + // sample-access + int channel_buffer_start; + int channel_buffer_end; +}; + +#if defined(STB_VORBIS_NO_PUSHDATA_API) + #define IS_PUSH_MODE(f) FALSE +#elif defined(STB_VORBIS_NO_PULLDATA_API) + #define IS_PUSH_MODE(f) TRUE +#else + #define IS_PUSH_MODE(f) ((f)->push_mode) +#endif + +typedef struct stb_vorbis vorb; + +static int error(vorb *f, enum STBVorbisError e) +{ + f->error = e; + if (!f->eof && e != VORBIS_need_more_data) { + f->error=e; // breakpoint for debugging + } + return 0; +} + + +// these functions are used for allocating temporary memory +// while decoding. if you can afford the stack space, use +// alloca(); otherwise, provide a temp buffer and it will +// allocate out of those. + +#define array_size_required(count,size) (count*(sizeof(void *)+(size))) + +#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size)) +#define temp_free(f,p) 0 +#define temp_alloc_save(f) ((f)->temp_offset) +#define temp_alloc_restore(f,p) ((f)->temp_offset = (p)) + +#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size) + +// given a sufficiently large block of memory, make an array of pointers to subblocks of it +static void *make_block_array(void *mem, int count, int size) +{ + int i; + void ** p = (void **) mem; + char *q = (char *) (p + count); + for (i=0; i < count; ++i) { + p[i] = q; + q += size; + } + return p; +} + +static void *setup_malloc(vorb *f, int sz) +{ + sz = (sz+3) & ~3; + f->setup_memory_required += sz; + if (f->alloc.alloc_buffer) { + void *p = (char *) f->alloc.alloc_buffer + f->setup_offset; + if (f->setup_offset + sz > f->temp_offset) return NULL; + f->setup_offset += sz; + return p; + } + return sz ? malloc(sz) : NULL; +} + +static void setup_free(vorb *f, void *p) +{ + if (f->alloc.alloc_buffer) return; // do nothing; setup mem is a stack + free(p); +} + +static void *setup_temp_malloc(vorb *f, int sz) +{ + sz = (sz+3) & ~3; + if (f->alloc.alloc_buffer) { + if (f->temp_offset - sz < f->setup_offset) return NULL; + f->temp_offset -= sz; + return (char *) f->alloc.alloc_buffer + f->temp_offset; + } + return malloc(sz); +} + +static void setup_temp_free(vorb *f, void *p, int sz) +{ + if (f->alloc.alloc_buffer) { + f->temp_offset += (sz+3)&~3; + return; + } + free(p); +} + +#define CRC32_POLY 0x04c11db7 // from spec + +static uint32 crc_table[256]; +static void crc32_init(void) +{ + int i,j; + uint32 s; + for(i=0; i < 256; i++) { + for (s=(uint32) i << 24, j=0; j < 8; ++j) + s = (s << 1) ^ (s >= (1U<<31) ? CRC32_POLY : 0); + crc_table[i] = s; + } +} + +static __forceinline uint32 crc32_update(uint32 crc, uint8 byte) +{ + return (crc << 8) ^ crc_table[byte ^ (crc >> 24)]; +} + + +// used in setup, and for huffman that doesn't go fast path +static unsigned int bit_reverse(unsigned int n) +{ + n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1); + n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2); + n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4); + n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8); + return (n >> 16) | (n << 16); +} + +static float square(float x) +{ + return x*x; +} + +// this is a weird definition of log2() for which log2(1) = 1, log2(2) = 2, log2(4) = 3 +// as required by the specification. fast(?) implementation from stb.h +// @OPTIMIZE: called multiple times per-packet with "constants"; move to setup +static int ilog(int32 n) +{ + static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 }; + + if (n < 0) return 0; // signed n returns 0 + + // 2 compares if n < 16, 3 compares otherwise (4 if signed or n > 1<<29) + if (n < (1 << 14)) + if (n < (1 << 4)) return 0 + log2_4[n ]; + else if (n < (1 << 9)) return 5 + log2_4[n >> 5]; + else return 10 + log2_4[n >> 10]; + else if (n < (1 << 24)) + if (n < (1 << 19)) return 15 + log2_4[n >> 15]; + else return 20 + log2_4[n >> 20]; + else if (n < (1 << 29)) return 25 + log2_4[n >> 25]; + else return 30 + log2_4[n >> 30]; +} + +#ifndef M_PI + #define M_PI 3.14159265358979323846264f // from CRC +#endif + +// code length assigned to a value with no huffman encoding +#define NO_CODE 255 + +/////////////////////// LEAF SETUP FUNCTIONS ////////////////////////// +// +// these functions are only called at setup, and only a few times +// per file + +static float float32_unpack(uint32 x) +{ + // from the specification + uint32 mantissa = x & 0x1fffff; + uint32 sign = x & 0x80000000; + uint32 exp = (x & 0x7fe00000) >> 21; + double res = sign ? -(double)mantissa : (double)mantissa; + return (float) ldexp((float)res, exp-788); +} + + +// zlib & jpeg huffman tables assume that the output symbols +// can either be arbitrarily arranged, or have monotonically +// increasing frequencies--they rely on the lengths being sorted; +// this makes for a very simple generation algorithm. +// vorbis allows a huffman table with non-sorted lengths. This +// requires a more sophisticated construction, since symbols in +// order do not map to huffman codes "in order". +static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values) +{ + if (!c->sparse) { + c->codewords [symbol] = huff_code; + } else { + c->codewords [count] = huff_code; + c->codeword_lengths[count] = len; + values [count] = symbol; + } +} + +static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values) +{ + int i,k,m=0; + uint32 available[32]; + + memset(available, 0, sizeof(available)); + // find the first entry + for (k=0; k < n; ++k) if (len[k] < NO_CODE) break; + if (k == n) { assert(c->sorted_entries == 0); return TRUE; } + // add to the list + add_entry(c, 0, k, m++, len[k], values); + // add all available leaves + for (i=1; i <= len[k]; ++i) + available[i] = 1U << (32-i); + // note that the above code treats the first case specially, + // but it's really the same as the following code, so they + // could probably be combined (except the initial code is 0, + // and I use 0 in available[] to mean 'empty') + for (i=k+1; i < n; ++i) { + uint32 res; + int z = len[i], y; + if (z == NO_CODE) continue; + // find lowest available leaf (should always be earliest, + // which is what the specification calls for) + // note that this property, and the fact we can never have + // more than one free leaf at a given level, isn't totally + // trivial to prove, but it seems true and the assert never + // fires, so! + while (z > 0 && !available[z]) --z; + if (z == 0) { return FALSE; } + res = available[z]; + assert(z >= 0 && z < 32); + available[z] = 0; + add_entry(c, bit_reverse(res), i, m++, len[i], values); + // propogate availability up the tree + if (z != len[i]) { + assert(len[i] >= 0 && len[i] < 32); + for (y=len[i]; y > z; --y) { + assert(available[y] == 0); + available[y] = res + (1 << (32-y)); + } + } + } + return TRUE; +} + +// accelerated huffman table allows fast O(1) match of all symbols +// of length <= STB_VORBIS_FAST_HUFFMAN_LENGTH +static void compute_accelerated_huffman(Codebook *c) +{ + int i, len; + for (i=0; i < FAST_HUFFMAN_TABLE_SIZE; ++i) + c->fast_huffman[i] = -1; + + len = c->sparse ? c->sorted_entries : c->entries; + #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT + if (len > 32767) len = 32767; // largest possible value we can encode! + #endif + for (i=0; i < len; ++i) { + if (c->codeword_lengths[i] <= STB_VORBIS_FAST_HUFFMAN_LENGTH) { + uint32 z = c->sparse ? bit_reverse(c->sorted_codewords[i]) : c->codewords[i]; + // set table entries for all bit combinations in the higher bits + while (z < FAST_HUFFMAN_TABLE_SIZE) { + c->fast_huffman[z] = i; + z += 1 << c->codeword_lengths[i]; + } + } + } +} + +#ifdef _MSC_VER +#define STBV_CDECL __cdecl +#else +#define STBV_CDECL +#endif + +static int STBV_CDECL uint32_compare(const void *p, const void *q) +{ + uint32 x = * (uint32 *) p; + uint32 y = * (uint32 *) q; + return x < y ? -1 : x > y; +} + +static int include_in_sort(Codebook *c, uint8 len) +{ + if (c->sparse) { assert(len != NO_CODE); return TRUE; } + if (len == NO_CODE) return FALSE; + if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH) return TRUE; + return FALSE; +} + +// if the fast table above doesn't work, we want to binary +// search them... need to reverse the bits +static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values) +{ + int i, len; + // build a list of all the entries + // OPTIMIZATION: don't include the short ones, since they'll be caught by FAST_HUFFMAN. + // this is kind of a frivolous optimization--I don't see any performance improvement, + // but it's like 4 extra lines of code, so. + if (!c->sparse) { + int k = 0; + for (i=0; i < c->entries; ++i) + if (include_in_sort(c, lengths[i])) + c->sorted_codewords[k++] = bit_reverse(c->codewords[i]); + assert(k == c->sorted_entries); + } else { + for (i=0; i < c->sorted_entries; ++i) + c->sorted_codewords[i] = bit_reverse(c->codewords[i]); + } + + qsort(c->sorted_codewords, c->sorted_entries, sizeof(c->sorted_codewords[0]), uint32_compare); + c->sorted_codewords[c->sorted_entries] = 0xffffffff; + + len = c->sparse ? c->sorted_entries : c->entries; + // now we need to indicate how they correspond; we could either + // #1: sort a different data structure that says who they correspond to + // #2: for each sorted entry, search the original list to find who corresponds + // #3: for each original entry, find the sorted entry + // #1 requires extra storage, #2 is slow, #3 can use binary search! + for (i=0; i < len; ++i) { + int huff_len = c->sparse ? lengths[values[i]] : lengths[i]; + if (include_in_sort(c,huff_len)) { + uint32 code = bit_reverse(c->codewords[i]); + int x=0, n=c->sorted_entries; + while (n > 1) { + // invariant: sc[x] <= code < sc[x+n] + int m = x + (n >> 1); + if (c->sorted_codewords[m] <= code) { + x = m; + n -= (n>>1); + } else { + n >>= 1; + } + } + assert(c->sorted_codewords[x] == code); + if (c->sparse) { + c->sorted_values[x] = values[i]; + c->codeword_lengths[x] = huff_len; + } else { + c->sorted_values[x] = i; + } + } + } +} + +// only run while parsing the header (3 times) +static int vorbis_validate(uint8 *data) +{ + static uint8 vorbis[6] = { 'v', 'o', 'r', 'b', 'i', 's' }; + return memcmp(data, vorbis, 6) == 0; +} + +// called from setup only, once per code book +// (formula implied by specification) +static int lookup1_values(int entries, int dim) +{ + int r = (int) floor(exp((float) log((float) entries) / dim)); + if ((int) floor(pow((float) r+1, dim)) <= entries) // (int) cast for MinGW warning; + ++r; // floor() to avoid _ftol() when non-CRT + assert(pow((float) r+1, dim) > entries); + assert((int) floor(pow((float) r, dim)) <= entries); // (int),floor() as above + return r; +} + +// called twice per file +static void compute_twiddle_factors(int n, float *A, float *B, float *C) +{ + int n4 = n >> 2, n8 = n >> 3; + int k,k2; + + for (k=k2=0; k < n4; ++k,k2+=2) { + A[k2 ] = (float) cos(4*k*M_PI/n); + A[k2+1] = (float) -sin(4*k*M_PI/n); + B[k2 ] = (float) cos((k2+1)*M_PI/n/2) * 0.5f; + B[k2+1] = (float) sin((k2+1)*M_PI/n/2) * 0.5f; + } + for (k=k2=0; k < n8; ++k,k2+=2) { + C[k2 ] = (float) cos(2*(k2+1)*M_PI/n); + C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n); + } +} + +static void compute_window(int n, float *window) +{ + int n2 = n >> 1, i; + for (i=0; i < n2; ++i) + window[i] = (float) sin(0.5 * M_PI * square((float) sin((i - 0 + 0.5) / n2 * 0.5 * M_PI))); +} + +static void compute_bitreverse(int n, uint16 *rev) +{ + int ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + int i, n8 = n >> 3; + for (i=0; i < n8; ++i) + rev[i] = (bit_reverse(i) >> (32-ld+3)) << 2; +} + +static int init_blocksize(vorb *f, int b, int n) +{ + int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3; + f->A[b] = (float *) setup_malloc(f, sizeof(float) * n2); + f->B[b] = (float *) setup_malloc(f, sizeof(float) * n2); + f->C[b] = (float *) setup_malloc(f, sizeof(float) * n4); + if (!f->A[b] || !f->B[b] || !f->C[b]) return error(f, VORBIS_outofmem); + compute_twiddle_factors(n, f->A[b], f->B[b], f->C[b]); + f->window[b] = (float *) setup_malloc(f, sizeof(float) * n2); + if (!f->window[b]) return error(f, VORBIS_outofmem); + compute_window(n, f->window[b]); + f->bit_reverse[b] = (uint16 *) setup_malloc(f, sizeof(uint16) * n8); + if (!f->bit_reverse[b]) return error(f, VORBIS_outofmem); + compute_bitreverse(n, f->bit_reverse[b]); + return TRUE; +} + +static void neighbors(uint16 *x, int n, int *plow, int *phigh) +{ + int low = -1; + int high = 65536; + int i; + for (i=0; i < n; ++i) { + if (x[i] > low && x[i] < x[n]) { *plow = i; low = x[i]; } + if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; } + } +} + +// this has been repurposed so y is now the original index instead of y +typedef struct +{ + uint16 x,id; +} stbv__floor_ordering; + +static int STBV_CDECL point_compare(const void *p, const void *q) +{ + stbv__floor_ordering *a = (stbv__floor_ordering *) p; + stbv__floor_ordering *b = (stbv__floor_ordering *) q; + return a->x < b->x ? -1 : a->x > b->x; +} + +// +/////////////////////// END LEAF SETUP FUNCTIONS ////////////////////////// + + +#if defined(STB_VORBIS_NO_STDIO) + #define USE_MEMORY(z) TRUE +#else + #define USE_MEMORY(z) ((z)->stream) +#endif + +static uint8 get8(vorb *z) +{ + if (USE_MEMORY(z)) { + if (z->stream >= z->stream_end) { z->eof = TRUE; return 0; } + return *z->stream++; + } + + #ifndef STB_VORBIS_NO_STDIO + { + int c = fgetc(z->f); + if (c == EOF) { z->eof = TRUE; return 0; } + return c; + } + #endif +} + +static uint32 get32(vorb *f) +{ + uint32 x; + x = get8(f); + x += get8(f) << 8; + x += get8(f) << 16; + x += (uint32) get8(f) << 24; + return x; +} + +static int getn(vorb *z, uint8 *data, int n) +{ + if (USE_MEMORY(z)) { + if (z->stream+n > z->stream_end) { z->eof = 1; return 0; } + memcpy(data, z->stream, n); + z->stream += n; + return 1; + } + + #ifndef STB_VORBIS_NO_STDIO + if (fread(data, n, 1, z->f) == 1) + return 1; + else { + z->eof = 1; + return 0; + } + #endif +} + +static void skip(vorb *z, int n) +{ + if (USE_MEMORY(z)) { + z->stream += n; + if (z->stream >= z->stream_end) z->eof = 1; + return; + } + #ifndef STB_VORBIS_NO_STDIO + { + long x = ftell(z->f); + fseek(z->f, x+n, SEEK_SET); + } + #endif +} + +static int set_file_offset(stb_vorbis *f, unsigned int loc) +{ + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (f->push_mode) return 0; + #endif + f->eof = 0; + if (USE_MEMORY(f)) { + if (f->stream_start + loc >= f->stream_end || f->stream_start + loc < f->stream_start) { + f->stream = f->stream_end; + f->eof = 1; + return 0; + } else { + f->stream = f->stream_start + loc; + return 1; + } + } + #ifndef STB_VORBIS_NO_STDIO + if (loc + f->f_start < loc || loc >= 0x80000000) { + loc = 0x7fffffff; + f->eof = 1; + } else { + loc += f->f_start; + } + if (!fseek(f->f, loc, SEEK_SET)) + return 1; + f->eof = 1; + fseek(f->f, f->f_start, SEEK_END); + return 0; + #endif +} + + +static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 }; + +static int capture_pattern(vorb *f) +{ + if (0x4f != get8(f)) return FALSE; + if (0x67 != get8(f)) return FALSE; + if (0x67 != get8(f)) return FALSE; + if (0x53 != get8(f)) return FALSE; + return TRUE; +} + +#define PAGEFLAG_continued_packet 1 +#define PAGEFLAG_first_page 2 +#define PAGEFLAG_last_page 4 + +static int start_page_no_capturepattern(vorb *f) +{ + uint32 loc0,loc1,n; + // stream structure version + if (0 != get8(f)) return error(f, VORBIS_invalid_stream_structure_version); + // header flag + f->page_flag = get8(f); + // absolute granule position + loc0 = get32(f); + loc1 = get32(f); + // @TODO: validate loc0,loc1 as valid positions? + // stream serial number -- vorbis doesn't interleave, so discard + get32(f); + //if (f->serial != get32(f)) return error(f, VORBIS_incorrect_stream_serial_number); + // page sequence number + n = get32(f); + f->last_page = n; + // CRC32 + get32(f); + // page_segments + f->segment_count = get8(f); + if (!getn(f, f->segments, f->segment_count)) + return error(f, VORBIS_unexpected_eof); + // assume we _don't_ know any the sample position of any segments + f->end_seg_with_known_loc = -2; + if (loc0 != ~0U || loc1 != ~0U) { + int i; + // determine which packet is the last one that will complete + for (i=f->segment_count-1; i >= 0; --i) + if (f->segments[i] < 255) + break; + // 'i' is now the index of the _last_ segment of a packet that ends + if (i >= 0) { + f->end_seg_with_known_loc = i; + f->known_loc_for_packet = loc0; + } + } + if (f->first_decode) { + int i,len; + ProbedPage p; + len = 0; + for (i=0; i < f->segment_count; ++i) + len += f->segments[i]; + len += 27 + f->segment_count; + p.page_start = f->first_audio_page_offset; + p.page_end = p.page_start + len; + p.last_decoded_sample = loc0; + f->p_first = p; + } + f->next_seg = 0; + return TRUE; +} + +static int start_page(vorb *f) +{ + if (!capture_pattern(f)) return error(f, VORBIS_missing_capture_pattern); + return start_page_no_capturepattern(f); +} + +static int start_packet(vorb *f) +{ + while (f->next_seg == -1) { + if (!start_page(f)) return FALSE; + if (f->page_flag & PAGEFLAG_continued_packet) + return error(f, VORBIS_continued_packet_flag_invalid); + } + f->last_seg = FALSE; + f->valid_bits = 0; + f->packet_bytes = 0; + f->bytes_in_seg = 0; + // f->next_seg is now valid + return TRUE; +} + +static int maybe_start_packet(vorb *f) +{ + if (f->next_seg == -1) { + int x = get8(f); + if (f->eof) return FALSE; // EOF at page boundary is not an error! + if (0x4f != x ) return error(f, VORBIS_missing_capture_pattern); + if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (0x53 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (!start_page_no_capturepattern(f)) return FALSE; + if (f->page_flag & PAGEFLAG_continued_packet) { + // set up enough state that we can read this packet if we want, + // e.g. during recovery + f->last_seg = FALSE; + f->bytes_in_seg = 0; + return error(f, VORBIS_continued_packet_flag_invalid); + } + } + return start_packet(f); +} + +static int next_segment(vorb *f) +{ + int len; + if (f->last_seg) return 0; + if (f->next_seg == -1) { + f->last_seg_which = f->segment_count-1; // in case start_page fails + if (!start_page(f)) { f->last_seg = 1; return 0; } + if (!(f->page_flag & PAGEFLAG_continued_packet)) return error(f, VORBIS_continued_packet_flag_invalid); + } + len = f->segments[f->next_seg++]; + if (len < 255) { + f->last_seg = TRUE; + f->last_seg_which = f->next_seg-1; + } + if (f->next_seg >= f->segment_count) + f->next_seg = -1; + assert(f->bytes_in_seg == 0); + f->bytes_in_seg = len; + return len; +} + +#define EOP (-1) +#define INVALID_BITS (-1) + +static int get8_packet_raw(vorb *f) +{ + if (!f->bytes_in_seg) { // CLANG! + if (f->last_seg) return EOP; + else if (!next_segment(f)) return EOP; + } + assert(f->bytes_in_seg > 0); + --f->bytes_in_seg; + ++f->packet_bytes; + return get8(f); +} + +static int get8_packet(vorb *f) +{ + int x = get8_packet_raw(f); + f->valid_bits = 0; + return x; +} + +static void flush_packet(vorb *f) +{ + while (get8_packet_raw(f) != EOP); +} + +// @OPTIMIZE: this is the secondary bit decoder, so it's probably not as important +// as the huffman decoder? +static uint32 get_bits(vorb *f, int n) +{ + uint32 z; + + if (f->valid_bits < 0) return 0; + if (f->valid_bits < n) { + if (n > 24) { + // the accumulator technique below would not work correctly in this case + z = get_bits(f, 24); + z += get_bits(f, n-24) << 24; + return z; + } + if (f->valid_bits == 0) f->acc = 0; + while (f->valid_bits < n) { + int z = get8_packet_raw(f); + if (z == EOP) { + f->valid_bits = INVALID_BITS; + return 0; + } + f->acc += z << f->valid_bits; + f->valid_bits += 8; + } + } + if (f->valid_bits < 0) return 0; + z = f->acc & ((1 << n)-1); + f->acc >>= n; + f->valid_bits -= n; + return z; +} + +// @OPTIMIZE: primary accumulator for huffman +// expand the buffer to as many bits as possible without reading off end of packet +// it might be nice to allow f->valid_bits and f->acc to be stored in registers, +// e.g. cache them locally and decode locally +static __forceinline void prep_huffman(vorb *f) +{ + if (f->valid_bits <= 24) { + if (f->valid_bits == 0) f->acc = 0; + do { + int z; + if (f->last_seg && !f->bytes_in_seg) return; + z = get8_packet_raw(f); + if (z == EOP) return; + f->acc += (unsigned) z << f->valid_bits; + f->valid_bits += 8; + } while (f->valid_bits <= 24); + } +} + +enum +{ + VORBIS_packet_id = 1, + VORBIS_packet_comment = 3, + VORBIS_packet_setup = 5 +}; + +static int codebook_decode_scalar_raw(vorb *f, Codebook *c) +{ + int i; + prep_huffman(f); + + if (c->codewords == NULL && c->sorted_codewords == NULL) + return -1; + + // cases to use binary search: sorted_codewords && !c->codewords + // sorted_codewords && c->entries > 8 + if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords) { + // binary search + uint32 code = bit_reverse(f->acc); + int x=0, n=c->sorted_entries, len; + + while (n > 1) { + // invariant: sc[x] <= code < sc[x+n] + int m = x + (n >> 1); + if (c->sorted_codewords[m] <= code) { + x = m; + n -= (n>>1); + } else { + n >>= 1; + } + } + // x is now the sorted index + if (!c->sparse) x = c->sorted_values[x]; + // x is now sorted index if sparse, or symbol otherwise + len = c->codeword_lengths[x]; + if (f->valid_bits >= len) { + f->acc >>= len; + f->valid_bits -= len; + return x; + } + + f->valid_bits = 0; + return -1; + } + + // if small, linear search + assert(!c->sparse); + for (i=0; i < c->entries; ++i) { + if (c->codeword_lengths[i] == NO_CODE) continue; + if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1))) { + if (f->valid_bits >= c->codeword_lengths[i]) { + f->acc >>= c->codeword_lengths[i]; + f->valid_bits -= c->codeword_lengths[i]; + return i; + } + f->valid_bits = 0; + return -1; + } + } + + error(f, VORBIS_invalid_stream); + f->valid_bits = 0; + return -1; +} + +#ifndef STB_VORBIS_NO_INLINE_DECODE + +#define DECODE_RAW(var, f,c) \ + if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) \ + prep_huffman(f); \ + var = f->acc & FAST_HUFFMAN_TABLE_MASK; \ + var = c->fast_huffman[var]; \ + if (var >= 0) { \ + int n = c->codeword_lengths[var]; \ + f->acc >>= n; \ + f->valid_bits -= n; \ + if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \ + } else { \ + var = codebook_decode_scalar_raw(f,c); \ + } + +#else + +static int codebook_decode_scalar(vorb *f, Codebook *c) +{ + int i; + if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) + prep_huffman(f); + // fast huffman table lookup + i = f->acc & FAST_HUFFMAN_TABLE_MASK; + i = c->fast_huffman[i]; + if (i >= 0) { + f->acc >>= c->codeword_lengths[i]; + f->valid_bits -= c->codeword_lengths[i]; + if (f->valid_bits < 0) { f->valid_bits = 0; return -1; } + return i; + } + return codebook_decode_scalar_raw(f,c); +} + +#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c); + +#endif + +#define DECODE(var,f,c) \ + DECODE_RAW(var,f,c) \ + if (c->sparse) var = c->sorted_values[var]; + +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c) +#else + #define DECODE_VQ(var,f,c) DECODE(var,f,c) +#endif + + + + + + +// CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case +// where we avoid one addition +#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off]) +#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off]) +#define CODEBOOK_ELEMENT_BASE(c) (0) + +static int codebook_decode_start(vorb *f, Codebook *c) +{ + int z = -1; + + // type 0 is only legal in a scalar context + if (c->lookup_type == 0) + error(f, VORBIS_invalid_stream); + else { + DECODE_VQ(z,f,c); + if (c->sparse) assert(z < c->sorted_entries); + if (z < 0) { // check for EOP + if (!f->bytes_in_seg) + if (f->last_seg) + return z; + error(f, VORBIS_invalid_stream); + } + } + return z; +} + +static int codebook_decode(vorb *f, Codebook *c, float *output, int len) +{ + int i,z = codebook_decode_start(f,c); + if (z < 0) return FALSE; + if (len > c->dimensions) len = c->dimensions; + +#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + float last = CODEBOOK_ELEMENT_BASE(c); + int div = 1; + for (i=0; i < len; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + output[i] += val; + if (c->sequence_p) last = val + c->minimum_value; + div *= c->lookup_values; + } + return TRUE; + } +#endif + + z *= c->dimensions; + if (c->sequence_p) { + float last = CODEBOOK_ELEMENT_BASE(c); + for (i=0; i < len; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + output[i] += val; + last = val + c->minimum_value; + } + } else { + float last = CODEBOOK_ELEMENT_BASE(c); + for (i=0; i < len; ++i) { + output[i] += CODEBOOK_ELEMENT_FAST(c,z+i) + last; + } + } + + return TRUE; +} + +static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step) +{ + int i,z = codebook_decode_start(f,c); + float last = CODEBOOK_ELEMENT_BASE(c); + if (z < 0) return FALSE; + if (len > c->dimensions) len = c->dimensions; + +#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int div = 1; + for (i=0; i < len; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + output[i*step] += val; + if (c->sequence_p) last = val; + div *= c->lookup_values; + } + return TRUE; + } +#endif + + z *= c->dimensions; + for (i=0; i < len; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + output[i*step] += val; + if (c->sequence_p) last = val; + } + + return TRUE; +} + +static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode) +{ + int c_inter = *c_inter_p; + int p_inter = *p_inter_p; + int i,z, effective = c->dimensions; + + // type 0 is only legal in a scalar context + if (c->lookup_type == 0) return error(f, VORBIS_invalid_stream); + + while (total_decode > 0) { + float last = CODEBOOK_ELEMENT_BASE(c); + DECODE_VQ(z,f,c); + #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + assert(!c->sparse || z < c->sorted_entries); + #endif + if (z < 0) { + if (!f->bytes_in_seg) + if (f->last_seg) return FALSE; + return error(f, VORBIS_invalid_stream); + } + + // if this will take us off the end of the buffers, stop short! + // we check by computing the length of the virtual interleaved + // buffer (len*ch), our current offset within it (p_inter*ch)+(c_inter), + // and the length we'll be using (effective) + if (c_inter + p_inter*ch + effective > len * ch) { + effective = len*ch - (p_inter*ch - c_inter); + } + + #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int div = 1; + for (i=0; i < effective; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + if (c->sequence_p) last = val; + div *= c->lookup_values; + } + } else + #endif + { + z *= c->dimensions; + if (c->sequence_p) { + for (i=0; i < effective; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + last = val; + } + } else { + for (i=0; i < effective; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + } + } + } + + total_decode -= effective; + } + *c_inter_p = c_inter; + *p_inter_p = p_inter; + return TRUE; +} + +static int predict_point(int x, int x0, int x1, int y0, int y1) +{ + int dy = y1 - y0; + int adx = x1 - x0; + // @OPTIMIZE: force int division to round in the right direction... is this necessary on x86? + int err = abs(dy) * (x - x0); + int off = err / adx; + return dy < 0 ? y0 - off : y0 + off; +} + +// the following table is block-copied from the specification +static float inverse_db_table[256] = +{ + 1.0649863e-07f, 1.1341951e-07f, 1.2079015e-07f, 1.2863978e-07f, + 1.3699951e-07f, 1.4590251e-07f, 1.5538408e-07f, 1.6548181e-07f, + 1.7623575e-07f, 1.8768855e-07f, 1.9988561e-07f, 2.1287530e-07f, + 2.2670913e-07f, 2.4144197e-07f, 2.5713223e-07f, 2.7384213e-07f, + 2.9163793e-07f, 3.1059021e-07f, 3.3077411e-07f, 3.5226968e-07f, + 3.7516214e-07f, 3.9954229e-07f, 4.2550680e-07f, 4.5315863e-07f, + 4.8260743e-07f, 5.1396998e-07f, 5.4737065e-07f, 5.8294187e-07f, + 6.2082472e-07f, 6.6116941e-07f, 7.0413592e-07f, 7.4989464e-07f, + 7.9862701e-07f, 8.5052630e-07f, 9.0579828e-07f, 9.6466216e-07f, + 1.0273513e-06f, 1.0941144e-06f, 1.1652161e-06f, 1.2409384e-06f, + 1.3215816e-06f, 1.4074654e-06f, 1.4989305e-06f, 1.5963394e-06f, + 1.7000785e-06f, 1.8105592e-06f, 1.9282195e-06f, 2.0535261e-06f, + 2.1869758e-06f, 2.3290978e-06f, 2.4804557e-06f, 2.6416497e-06f, + 2.8133190e-06f, 2.9961443e-06f, 3.1908506e-06f, 3.3982101e-06f, + 3.6190449e-06f, 3.8542308e-06f, 4.1047004e-06f, 4.3714470e-06f, + 4.6555282e-06f, 4.9580707e-06f, 5.2802740e-06f, 5.6234160e-06f, + 5.9888572e-06f, 6.3780469e-06f, 6.7925283e-06f, 7.2339451e-06f, + 7.7040476e-06f, 8.2047000e-06f, 8.7378876e-06f, 9.3057248e-06f, + 9.9104632e-06f, 1.0554501e-05f, 1.1240392e-05f, 1.1970856e-05f, + 1.2748789e-05f, 1.3577278e-05f, 1.4459606e-05f, 1.5399272e-05f, + 1.6400004e-05f, 1.7465768e-05f, 1.8600792e-05f, 1.9809576e-05f, + 2.1096914e-05f, 2.2467911e-05f, 2.3928002e-05f, 2.5482978e-05f, + 2.7139006e-05f, 2.8902651e-05f, 3.0780908e-05f, 3.2781225e-05f, + 3.4911534e-05f, 3.7180282e-05f, 3.9596466e-05f, 4.2169667e-05f, + 4.4910090e-05f, 4.7828601e-05f, 5.0936773e-05f, 5.4246931e-05f, + 5.7772202e-05f, 6.1526565e-05f, 6.5524908e-05f, 6.9783085e-05f, + 7.4317983e-05f, 7.9147585e-05f, 8.4291040e-05f, 8.9768747e-05f, + 9.5602426e-05f, 0.00010181521f, 0.00010843174f, 0.00011547824f, + 0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f, + 0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f, + 0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f, + 0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f, + 0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f, + 0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f, + 0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f, + 0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f, + 0.00092223983f, 0.00098217216f, 0.0010459992f, 0.0011139742f, + 0.0011863665f, 0.0012634633f, 0.0013455702f, 0.0014330129f, + 0.0015261382f, 0.0016253153f, 0.0017309374f, 0.0018434235f, + 0.0019632195f, 0.0020908006f, 0.0022266726f, 0.0023713743f, + 0.0025254795f, 0.0026895994f, 0.0028643847f, 0.0030505286f, + 0.0032487691f, 0.0034598925f, 0.0036847358f, 0.0039241906f, + 0.0041792066f, 0.0044507950f, 0.0047400328f, 0.0050480668f, + 0.0053761186f, 0.0057254891f, 0.0060975636f, 0.0064938176f, + 0.0069158225f, 0.0073652516f, 0.0078438871f, 0.0083536271f, + 0.0088964928f, 0.009474637f, 0.010090352f, 0.010746080f, + 0.011444421f, 0.012188144f, 0.012980198f, 0.013823725f, + 0.014722068f, 0.015678791f, 0.016697687f, 0.017782797f, + 0.018938423f, 0.020169149f, 0.021479854f, 0.022875735f, + 0.024362330f, 0.025945531f, 0.027631618f, 0.029427276f, + 0.031339626f, 0.033376252f, 0.035545228f, 0.037855157f, + 0.040315199f, 0.042935108f, 0.045725273f, 0.048696758f, + 0.051861348f, 0.055231591f, 0.058820850f, 0.062643361f, + 0.066714279f, 0.071049749f, 0.075666962f, 0.080584227f, + 0.085821044f, 0.091398179f, 0.097337747f, 0.10366330f, + 0.11039993f, 0.11757434f, 0.12521498f, 0.13335215f, + 0.14201813f, 0.15124727f, 0.16107617f, 0.17154380f, + 0.18269168f, 0.19456402f, 0.20720788f, 0.22067342f, + 0.23501402f, 0.25028656f, 0.26655159f, 0.28387361f, + 0.30232132f, 0.32196786f, 0.34289114f, 0.36517414f, + 0.38890521f, 0.41417847f, 0.44109412f, 0.46975890f, + 0.50028648f, 0.53279791f, 0.56742212f, 0.60429640f, + 0.64356699f, 0.68538959f, 0.72993007f, 0.77736504f, + 0.82788260f, 0.88168307f, 0.9389798f, 1.0f +}; + + +// @OPTIMIZE: if you want to replace this bresenham line-drawing routine, +// note that you must produce bit-identical output to decode correctly; +// this specific sequence of operations is specified in the spec (it's +// drawing integer-quantized frequency-space lines that the encoder +// expects to be exactly the same) +// ... also, isn't the whole point of Bresenham's algorithm to NOT +// have to divide in the setup? sigh. +#ifndef STB_VORBIS_NO_DEFER_FLOOR +#define LINE_OP(a,b) a *= b +#else +#define LINE_OP(a,b) a = b +#endif + +#ifdef STB_VORBIS_DIVIDE_TABLE +#define DIVTAB_NUMER 32 +#define DIVTAB_DENOM 64 +int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB +#endif + +static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n) +{ + int dy = y1 - y0; + int adx = x1 - x0; + int ady = abs(dy); + int base; + int x=x0,y=y0; + int err = 0; + int sy; + +#ifdef STB_VORBIS_DIVIDE_TABLE + if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) { + if (dy < 0) { + base = -integer_divide_table[ady][adx]; + sy = base-1; + } else { + base = integer_divide_table[ady][adx]; + sy = base+1; + } + } else { + base = dy / adx; + if (dy < 0) + sy = base - 1; + else + sy = base+1; + } +#else + base = dy / adx; + if (dy < 0) + sy = base - 1; + else + sy = base+1; +#endif + ady -= abs(base) * adx; + if (x1 > n) x1 = n; + if (x < x1) { + LINE_OP(output[x], inverse_db_table[y]); + for (++x; x < x1; ++x) { + err += ady; + if (err >= adx) { + err -= adx; + y += sy; + } else + y += base; + LINE_OP(output[x], inverse_db_table[y]); + } + } +} + +static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype) +{ + int k; + if (rtype == 0) { + int step = n / book->dimensions; + for (k=0; k < step; ++k) + if (!codebook_decode_step(f, book, target+offset+k, n-offset-k, step)) + return FALSE; + } else { + for (k=0; k < n; ) { + if (!codebook_decode(f, book, target+offset, n-k)) + return FALSE; + k += book->dimensions; + offset += book->dimensions; + } + } + return TRUE; +} + +// n is 1/2 of the blocksize -- +// specification: "Correct per-vector decode length is [n]/2" +static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode) +{ + int i,j,pass; + Residue *r = f->residue_config + rn; + int rtype = f->residue_types[rn]; + int c = r->classbook; + int classwords = f->codebooks[c].dimensions; + unsigned int actual_size = rtype == 2 ? n*2 : n; + unsigned int limit_r_begin = (r->begin < actual_size ? r->begin : actual_size); + unsigned int limit_r_end = (r->end < actual_size ? r->end : actual_size); + int n_read = limit_r_end - limit_r_begin; + int part_read = n_read / r->part_size; + int temp_alloc_point = temp_alloc_save(f); + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + uint8 ***part_classdata = (uint8 ***) temp_block_array(f,f->channels, part_read * sizeof(**part_classdata)); + #else + int **classifications = (int **) temp_block_array(f,f->channels, part_read * sizeof(**classifications)); + #endif + + CHECK(f); + + for (i=0; i < ch; ++i) + if (!do_not_decode[i]) + memset(residue_buffers[i], 0, sizeof(float) * n); + + if (rtype == 2 && ch != 1) { + for (j=0; j < ch; ++j) + if (!do_not_decode[j]) + break; + if (j == ch) + goto done; + + for (pass=0; pass < 8; ++pass) { + int pcount = 0, class_set = 0; + if (ch == 2) { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = (z & 1), p_inter = z>>1; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + #else + // saves 1% + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + #endif + } else { + z += r->part_size; + c_inter = z & 1; + p_inter = z >> 1; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } else if (ch == 1) { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = 0, p_inter = z; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + } else { + z += r->part_size; + c_inter = 0; + p_inter = z; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } else { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = z % ch, p_inter = z/ch; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + } else { + z += r->part_size; + c_inter = z % ch; + p_inter = z / ch; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } + } + goto done; + } + CHECK(f); + + for (pass=0; pass < 8; ++pass) { + int pcount = 0, class_set=0; + while (pcount < part_read) { + if (pass == 0) { + for (j=0; j < ch; ++j) { + if (!do_not_decode[j]) { + Codebook *c = f->codebooks+r->classbook; + int temp; + DECODE(temp,f,c); + if (temp == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[j][class_set] = r->classdata[temp]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[j][i+pcount] = temp % r->classifications; + temp /= r->classifications; + } + #endif + } + } + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + for (j=0; j < ch; ++j) { + if (!do_not_decode[j]) { + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[j][class_set][i]; + #else + int c = classifications[j][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + float *target = residue_buffers[j]; + int offset = r->begin + pcount * r->part_size; + int n = r->part_size; + Codebook *book = f->codebooks + b; + if (!residue_decode(f, book, target, offset, n, rtype)) + goto done; + } + } + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } + done: + CHECK(f); + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + temp_free(f,part_classdata); + #else + temp_free(f,classifications); + #endif + temp_alloc_restore(f,temp_alloc_point); +} + + +#if 0 +// slow way for debugging +void inverse_mdct_slow(float *buffer, int n) +{ + int i,j; + int n2 = n >> 1; + float *x = (float *) malloc(sizeof(*x) * n2); + memcpy(x, buffer, sizeof(*x) * n2); + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n2; ++j) + // formula from paper: + //acc += n/4.0f * x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1)); + // formula from wikipedia + //acc += 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5)); + // these are equivalent, except the formula from the paper inverts the multiplier! + // however, what actually works is NO MULTIPLIER!?! + //acc += 64 * 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5)); + acc += x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1)); + buffer[i] = acc; + } + free(x); +} +#elif 0 +// same as above, but just barely able to run in real time on modern machines +void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype) +{ + float mcos[16384]; + int i,j; + int n2 = n >> 1, nmask = (n << 2) -1; + float *x = (float *) malloc(sizeof(*x) * n2); + memcpy(x, buffer, sizeof(*x) * n2); + for (i=0; i < 4*n; ++i) + mcos[i] = (float) cos(M_PI / 2 * i / n); + + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n2; ++j) + acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask]; + buffer[i] = acc; + } + free(x); +} +#elif 0 +// transform to use a slow dct-iv; this is STILL basically trivial, +// but only requires half as many ops +void dct_iv_slow(float *buffer, int n) +{ + float mcos[16384]; + float x[2048]; + int i,j; + int n2 = n >> 1, nmask = (n << 3) - 1; + memcpy(x, buffer, sizeof(*x) * n); + for (i=0; i < 8*n; ++i) + mcos[i] = (float) cos(M_PI / 4 * i / n); + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n; ++j) + acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask]; + buffer[i] = acc; + } +} + +void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype) +{ + int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4; + float temp[4096]; + + memcpy(temp, buffer, n2 * sizeof(float)); + dct_iv_slow(temp, n2); // returns -c'-d, a-b' + + for (i=0; i < n4 ; ++i) buffer[i] = temp[i+n4]; // a-b' + for ( ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1]; // b-a', c+d' + for ( ; i < n ; ++i) buffer[i] = -temp[i - n3_4]; // c'+d +} +#endif + +#ifndef LIBVORBIS_MDCT +#define LIBVORBIS_MDCT 0 +#endif + +#if LIBVORBIS_MDCT +// directly call the vorbis MDCT using an interface documented +// by Jeff Roberts... useful for performance comparison +typedef struct +{ + int n; + int log2n; + + float *trig; + int *bitrev; + + float scale; +} mdct_lookup; + +extern void mdct_init(mdct_lookup *lookup, int n); +extern void mdct_clear(mdct_lookup *l); +extern void mdct_backward(mdct_lookup *init, float *in, float *out); + +mdct_lookup M1,M2; + +void inverse_mdct(float *buffer, int n, vorb *f, int blocktype) +{ + mdct_lookup *M; + if (M1.n == n) M = &M1; + else if (M2.n == n) M = &M2; + else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; } + else { + if (M2.n) __asm int 3; + mdct_init(&M2, n); + M = &M2; + } + + mdct_backward(M, buffer, buffer); +} +#endif + + +// the following were split out into separate functions while optimizing; +// they could be pushed back up but eh. __forceinline showed no change; +// they're probably already being inlined. +static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A) +{ + float *ee0 = e + i_off; + float *ee2 = ee0 + k_off; + int i; + + assert((n & 3) == 0); + for (i=(n>>2); i > 0; --i) { + float k00_20, k01_21; + k00_20 = ee0[ 0] - ee2[ 0]; + k01_21 = ee0[-1] - ee2[-1]; + ee0[ 0] += ee2[ 0];//ee0[ 0] = ee0[ 0] + ee2[ 0]; + ee0[-1] += ee2[-1];//ee0[-1] = ee0[-1] + ee2[-1]; + ee2[ 0] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-1] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-2] - ee2[-2]; + k01_21 = ee0[-3] - ee2[-3]; + ee0[-2] += ee2[-2];//ee0[-2] = ee0[-2] + ee2[-2]; + ee0[-3] += ee2[-3];//ee0[-3] = ee0[-3] + ee2[-3]; + ee2[-2] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-3] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-4] - ee2[-4]; + k01_21 = ee0[-5] - ee2[-5]; + ee0[-4] += ee2[-4];//ee0[-4] = ee0[-4] + ee2[-4]; + ee0[-5] += ee2[-5];//ee0[-5] = ee0[-5] + ee2[-5]; + ee2[-4] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-5] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-6] - ee2[-6]; + k01_21 = ee0[-7] - ee2[-7]; + ee0[-6] += ee2[-6];//ee0[-6] = ee0[-6] + ee2[-6]; + ee0[-7] += ee2[-7];//ee0[-7] = ee0[-7] + ee2[-7]; + ee2[-6] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-7] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + ee0 -= 8; + ee2 -= 8; + } +} + +static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1) +{ + int i; + float k00_20, k01_21; + + float *e0 = e + d0; + float *e2 = e0 + k_off; + + for (i=lim >> 2; i > 0; --i) { + k00_20 = e0[-0] - e2[-0]; + k01_21 = e0[-1] - e2[-1]; + e0[-0] += e2[-0];//e0[-0] = e0[-0] + e2[-0]; + e0[-1] += e2[-1];//e0[-1] = e0[-1] + e2[-1]; + e2[-0] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-1] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-2] - e2[-2]; + k01_21 = e0[-3] - e2[-3]; + e0[-2] += e2[-2];//e0[-2] = e0[-2] + e2[-2]; + e0[-3] += e2[-3];//e0[-3] = e0[-3] + e2[-3]; + e2[-2] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-3] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-4] - e2[-4]; + k01_21 = e0[-5] - e2[-5]; + e0[-4] += e2[-4];//e0[-4] = e0[-4] + e2[-4]; + e0[-5] += e2[-5];//e0[-5] = e0[-5] + e2[-5]; + e2[-4] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-5] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-6] - e2[-6]; + k01_21 = e0[-7] - e2[-7]; + e0[-6] += e2[-6];//e0[-6] = e0[-6] + e2[-6]; + e0[-7] += e2[-7];//e0[-7] = e0[-7] + e2[-7]; + e2[-6] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-7] = (k01_21)*A[0] + (k00_20) * A[1]; + + e0 -= 8; + e2 -= 8; + + A += k1; + } +} + +static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0) +{ + int i; + float A0 = A[0]; + float A1 = A[0+1]; + float A2 = A[0+a_off]; + float A3 = A[0+a_off+1]; + float A4 = A[0+a_off*2+0]; + float A5 = A[0+a_off*2+1]; + float A6 = A[0+a_off*3+0]; + float A7 = A[0+a_off*3+1]; + + float k00,k11; + + float *ee0 = e +i_off; + float *ee2 = ee0+k_off; + + for (i=n; i > 0; --i) { + k00 = ee0[ 0] - ee2[ 0]; + k11 = ee0[-1] - ee2[-1]; + ee0[ 0] = ee0[ 0] + ee2[ 0]; + ee0[-1] = ee0[-1] + ee2[-1]; + ee2[ 0] = (k00) * A0 - (k11) * A1; + ee2[-1] = (k11) * A0 + (k00) * A1; + + k00 = ee0[-2] - ee2[-2]; + k11 = ee0[-3] - ee2[-3]; + ee0[-2] = ee0[-2] + ee2[-2]; + ee0[-3] = ee0[-3] + ee2[-3]; + ee2[-2] = (k00) * A2 - (k11) * A3; + ee2[-3] = (k11) * A2 + (k00) * A3; + + k00 = ee0[-4] - ee2[-4]; + k11 = ee0[-5] - ee2[-5]; + ee0[-4] = ee0[-4] + ee2[-4]; + ee0[-5] = ee0[-5] + ee2[-5]; + ee2[-4] = (k00) * A4 - (k11) * A5; + ee2[-5] = (k11) * A4 + (k00) * A5; + + k00 = ee0[-6] - ee2[-6]; + k11 = ee0[-7] - ee2[-7]; + ee0[-6] = ee0[-6] + ee2[-6]; + ee0[-7] = ee0[-7] + ee2[-7]; + ee2[-6] = (k00) * A6 - (k11) * A7; + ee2[-7] = (k11) * A6 + (k00) * A7; + + ee0 -= k0; + ee2 -= k0; + } +} + +static __forceinline void iter_54(float *z) +{ + float k00,k11,k22,k33; + float y0,y1,y2,y3; + + k00 = z[ 0] - z[-4]; + y0 = z[ 0] + z[-4]; + y2 = z[-2] + z[-6]; + k22 = z[-2] - z[-6]; + + z[-0] = y0 + y2; // z0 + z4 + z2 + z6 + z[-2] = y0 - y2; // z0 + z4 - z2 - z6 + + // done with y0,y2 + + k33 = z[-3] - z[-7]; + + z[-4] = k00 + k33; // z0 - z4 + z3 - z7 + z[-6] = k00 - k33; // z0 - z4 - z3 + z7 + + // done with k33 + + k11 = z[-1] - z[-5]; + y1 = z[-1] + z[-5]; + y3 = z[-3] + z[-7]; + + z[-1] = y1 + y3; // z1 + z5 + z3 + z7 + z[-3] = y1 - y3; // z1 + z5 - z3 - z7 + z[-5] = k11 - k22; // z1 - z5 + z2 - z6 + z[-7] = k11 + k22; // z1 - z5 - z2 + z6 +} + +static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n) +{ + int a_off = base_n >> 3; + float A2 = A[0+a_off]; + float *z = e + i_off; + float *base = z - 16 * n; + + while (z > base) { + float k00,k11; + + k00 = z[-0] - z[-8]; + k11 = z[-1] - z[-9]; + z[-0] = z[-0] + z[-8]; + z[-1] = z[-1] + z[-9]; + z[-8] = k00; + z[-9] = k11 ; + + k00 = z[ -2] - z[-10]; + k11 = z[ -3] - z[-11]; + z[ -2] = z[ -2] + z[-10]; + z[ -3] = z[ -3] + z[-11]; + z[-10] = (k00+k11) * A2; + z[-11] = (k11-k00) * A2; + + k00 = z[-12] - z[ -4]; // reverse to avoid a unary negation + k11 = z[ -5] - z[-13]; + z[ -4] = z[ -4] + z[-12]; + z[ -5] = z[ -5] + z[-13]; + z[-12] = k11; + z[-13] = k00; + + k00 = z[-14] - z[ -6]; // reverse to avoid a unary negation + k11 = z[ -7] - z[-15]; + z[ -6] = z[ -6] + z[-14]; + z[ -7] = z[ -7] + z[-15]; + z[-14] = (k00+k11) * A2; + z[-15] = (k00-k11) * A2; + + iter_54(z); + iter_54(z-8); + z -= 16; + } +} + +static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype) +{ + int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l; + int ld; + // @OPTIMIZE: reduce register pressure by using fewer variables? + int save_point = temp_alloc_save(f); + float *buf2 = (float *) temp_alloc(f, n2 * sizeof(*buf2)); + float *u=NULL,*v=NULL; + // twiddle factors + float *A = f->A[blocktype]; + + // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio" + // See notes about bugs in that paper in less-optimal implementation 'inverse_mdct_old' after this function. + + // kernel from paper + + + // merged: + // copy and reflect spectral data + // step 0 + + // note that it turns out that the items added together during + // this step are, in fact, being added to themselves (as reflected + // by step 0). inexplicable inefficiency! this became obvious + // once I combined the passes. + + // so there's a missing 'times 2' here (for adding X to itself). + // this propogates through linearly to the end, where the numbers + // are 1/2 too small, and need to be compensated for. + + { + float *d,*e, *AA, *e_stop; + d = &buf2[n2-2]; + AA = A; + e = &buffer[0]; + e_stop = &buffer[n2]; + while (e != e_stop) { + d[1] = (e[0] * AA[0] - e[2]*AA[1]); + d[0] = (e[0] * AA[1] + e[2]*AA[0]); + d -= 2; + AA += 2; + e += 4; + } + + e = &buffer[n2-3]; + while (d >= buf2) { + d[1] = (-e[2] * AA[0] - -e[0]*AA[1]); + d[0] = (-e[2] * AA[1] + -e[0]*AA[0]); + d -= 2; + AA += 2; + e -= 4; + } + } + + // now we use symbolic names for these, so that we can + // possibly swap their meaning as we change which operations + // are in place + + u = buffer; + v = buf2; + + // step 2 (paper output is w, now u) + // this could be in place, but the data ends up in the wrong + // place... _somebody_'s got to swap it, so this is nominated + { + float *AA = &A[n2-8]; + float *d0,*d1, *e0, *e1; + + e0 = &v[n4]; + e1 = &v[0]; + + d0 = &u[n4]; + d1 = &u[0]; + + while (AA >= A) { + float v40_20, v41_21; + + v41_21 = e0[1] - e1[1]; + v40_20 = e0[0] - e1[0]; + d0[1] = e0[1] + e1[1]; + d0[0] = e0[0] + e1[0]; + d1[1] = v41_21*AA[4] - v40_20*AA[5]; + d1[0] = v40_20*AA[4] + v41_21*AA[5]; + + v41_21 = e0[3] - e1[3]; + v40_20 = e0[2] - e1[2]; + d0[3] = e0[3] + e1[3]; + d0[2] = e0[2] + e1[2]; + d1[3] = v41_21*AA[0] - v40_20*AA[1]; + d1[2] = v40_20*AA[0] + v41_21*AA[1]; + + AA -= 8; + + d0 += 4; + d1 += 4; + e0 += 4; + e1 += 4; + } + } + + // step 3 + ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + + // optimized step 3: + + // the original step3 loop can be nested r inside s or s inside r; + // it's written originally as s inside r, but this is dumb when r + // iterates many times, and s few. So I have two copies of it and + // switch between them halfway. + + // this is iteration 0 of step 3 + imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*0, -(n >> 3), A); + imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*1, -(n >> 3), A); + + // this is iteration 1 of step 3 + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*0, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*1, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*2, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*3, -(n >> 4), A, 16); + + l=2; + for (; l < (ld-3)>>1; ++l) { + int k0 = n >> (l+2), k0_2 = k0>>1; + int lim = 1 << (l+1); + int i; + for (i=0; i < lim; ++i) + imdct_step3_inner_r_loop(n >> (l+4), u, n2-1 - k0*i, -k0_2, A, 1 << (l+3)); + } + + for (; l < ld-6; ++l) { + int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1; + int rlim = n >> (l+6), r; + int lim = 1 << (l+1); + int i_off; + float *A0 = A; + i_off = n2-1; + for (r=rlim; r > 0; --r) { + imdct_step3_inner_s_loop(lim, u, i_off, -k0_2, A0, k1, k0); + A0 += k1*4; + i_off -= 8; + } + } + + // iterations with count: + // ld-6,-5,-4 all interleaved together + // the big win comes from getting rid of needless flops + // due to the constants on pass 5 & 4 being all 1 and 0; + // combining them to be simultaneous to improve cache made little difference + imdct_step3_inner_s_loop_ld654(n >> 5, u, n2-1, A, n); + + // output is u + + // step 4, 5, and 6 + // cannot be in-place because of step 5 + { + uint16 *bitrev = f->bit_reverse[blocktype]; + // weirdly, I'd have thought reading sequentially and writing + // erratically would have been better than vice-versa, but in + // fact that's not what my testing showed. (That is, with + // j = bitreverse(i), do you read i and write j, or read j and write i.) + + float *d0 = &v[n4-4]; + float *d1 = &v[n2-4]; + while (d0 >= v) { + int k4; + + k4 = bitrev[0]; + d1[3] = u[k4+0]; + d1[2] = u[k4+1]; + d0[3] = u[k4+2]; + d0[2] = u[k4+3]; + + k4 = bitrev[1]; + d1[1] = u[k4+0]; + d1[0] = u[k4+1]; + d0[1] = u[k4+2]; + d0[0] = u[k4+3]; + + d0 -= 4; + d1 -= 4; + bitrev += 2; + } + } + // (paper output is u, now v) + + + // data must be in buf2 + assert(v == buf2); + + // step 7 (paper output is v, now v) + // this is now in place + { + float *C = f->C[blocktype]; + float *d, *e; + + d = v; + e = v + n2 - 4; + + while (d < e) { + float a02,a11,b0,b1,b2,b3; + + a02 = d[0] - e[2]; + a11 = d[1] + e[3]; + + b0 = C[1]*a02 + C[0]*a11; + b1 = C[1]*a11 - C[0]*a02; + + b2 = d[0] + e[ 2]; + b3 = d[1] - e[ 3]; + + d[0] = b2 + b0; + d[1] = b3 + b1; + e[2] = b2 - b0; + e[3] = b1 - b3; + + a02 = d[2] - e[0]; + a11 = d[3] + e[1]; + + b0 = C[3]*a02 + C[2]*a11; + b1 = C[3]*a11 - C[2]*a02; + + b2 = d[2] + e[ 0]; + b3 = d[3] - e[ 1]; + + d[2] = b2 + b0; + d[3] = b3 + b1; + e[0] = b2 - b0; + e[1] = b1 - b3; + + C += 4; + d += 4; + e -= 4; + } + } + + // data must be in buf2 + + + // step 8+decode (paper output is X, now buffer) + // this generates pairs of data a la 8 and pushes them directly through + // the decode kernel (pushing rather than pulling) to avoid having + // to make another pass later + + // this cannot POSSIBLY be in place, so we refer to the buffers directly + + { + float *d0,*d1,*d2,*d3; + + float *B = f->B[blocktype] + n2 - 8; + float *e = buf2 + n2 - 8; + d0 = &buffer[0]; + d1 = &buffer[n2-4]; + d2 = &buffer[n2]; + d3 = &buffer[n-4]; + while (e >= v) { + float p0,p1,p2,p3; + + p3 = e[6]*B[7] - e[7]*B[6]; + p2 = -e[6]*B[6] - e[7]*B[7]; + + d0[0] = p3; + d1[3] = - p3; + d2[0] = p2; + d3[3] = p2; + + p1 = e[4]*B[5] - e[5]*B[4]; + p0 = -e[4]*B[4] - e[5]*B[5]; + + d0[1] = p1; + d1[2] = - p1; + d2[1] = p0; + d3[2] = p0; + + p3 = e[2]*B[3] - e[3]*B[2]; + p2 = -e[2]*B[2] - e[3]*B[3]; + + d0[2] = p3; + d1[1] = - p3; + d2[2] = p2; + d3[1] = p2; + + p1 = e[0]*B[1] - e[1]*B[0]; + p0 = -e[0]*B[0] - e[1]*B[1]; + + d0[3] = p1; + d1[0] = - p1; + d2[3] = p0; + d3[0] = p0; + + B -= 8; + e -= 8; + d0 += 4; + d2 += 4; + d1 -= 4; + d3 -= 4; + } + } + + temp_free(f,buf2); + temp_alloc_restore(f,save_point); +} + +#if 0 +// this is the original version of the above code, if you want to optimize it from scratch +void inverse_mdct_naive(float *buffer, int n) +{ + float s; + float A[1 << 12], B[1 << 12], C[1 << 11]; + int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l; + int n3_4 = n - n4, ld; + // how can they claim this only uses N words?! + // oh, because they're only used sparsely, whoops + float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13]; + // set up twiddle factors + + for (k=k2=0; k < n4; ++k,k2+=2) { + A[k2 ] = (float) cos(4*k*M_PI/n); + A[k2+1] = (float) -sin(4*k*M_PI/n); + B[k2 ] = (float) cos((k2+1)*M_PI/n/2); + B[k2+1] = (float) sin((k2+1)*M_PI/n/2); + } + for (k=k2=0; k < n8; ++k,k2+=2) { + C[k2 ] = (float) cos(2*(k2+1)*M_PI/n); + C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n); + } + + // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio" + // Note there are bugs in that pseudocode, presumably due to them attempting + // to rename the arrays nicely rather than representing the way their actual + // implementation bounces buffers back and forth. As a result, even in the + // "some formulars corrected" version, a direct implementation fails. These + // are noted below as "paper bug". + + // copy and reflect spectral data + for (k=0; k < n2; ++k) u[k] = buffer[k]; + for ( ; k < n ; ++k) u[k] = -buffer[n - k - 1]; + // kernel from paper + // step 1 + for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) { + v[n-k4-1] = (u[k4] - u[n-k4-1]) * A[k2] - (u[k4+2] - u[n-k4-3])*A[k2+1]; + v[n-k4-3] = (u[k4] - u[n-k4-1]) * A[k2+1] + (u[k4+2] - u[n-k4-3])*A[k2]; + } + // step 2 + for (k=k4=0; k < n8; k+=1, k4+=4) { + w[n2+3+k4] = v[n2+3+k4] + v[k4+3]; + w[n2+1+k4] = v[n2+1+k4] + v[k4+1]; + w[k4+3] = (v[n2+3+k4] - v[k4+3])*A[n2-4-k4] - (v[n2+1+k4]-v[k4+1])*A[n2-3-k4]; + w[k4+1] = (v[n2+1+k4] - v[k4+1])*A[n2-4-k4] + (v[n2+3+k4]-v[k4+3])*A[n2-3-k4]; + } + // step 3 + ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + for (l=0; l < ld-3; ++l) { + int k0 = n >> (l+2), k1 = 1 << (l+3); + int rlim = n >> (l+4), r4, r; + int s2lim = 1 << (l+2), s2; + for (r=r4=0; r < rlim; r4+=4,++r) { + for (s2=0; s2 < s2lim; s2+=2) { + u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4]; + u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4]; + u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1] + - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1+1]; + u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1] + + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1+1]; + } + } + if (l+1 < ld-3) { + // paper bug: ping-ponging of u&w here is omitted + memcpy(w, u, sizeof(u)); + } + } + + // step 4 + for (i=0; i < n8; ++i) { + int j = bit_reverse(i) >> (32-ld+3); + assert(j < n8); + if (i == j) { + // paper bug: original code probably swapped in place; if copying, + // need to directly copy in this case + int i8 = i << 3; + v[i8+1] = u[i8+1]; + v[i8+3] = u[i8+3]; + v[i8+5] = u[i8+5]; + v[i8+7] = u[i8+7]; + } else if (i < j) { + int i8 = i << 3, j8 = j << 3; + v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1]; + v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3]; + v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5]; + v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7]; + } + } + // step 5 + for (k=0; k < n2; ++k) { + w[k] = v[k*2+1]; + } + // step 6 + for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) { + u[n-1-k2] = w[k4]; + u[n-2-k2] = w[k4+1]; + u[n3_4 - 1 - k2] = w[k4+2]; + u[n3_4 - 2 - k2] = w[k4+3]; + } + // step 7 + for (k=k2=0; k < n8; ++k, k2 += 2) { + v[n2 + k2 ] = ( u[n2 + k2] + u[n-2-k2] + C[k2+1]*(u[n2+k2]-u[n-2-k2]) + C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2; + v[n-2 - k2] = ( u[n2 + k2] + u[n-2-k2] - C[k2+1]*(u[n2+k2]-u[n-2-k2]) - C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2; + v[n2+1+ k2] = ( u[n2+1+k2] - u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2; + v[n-1 - k2] = (-u[n2+1+k2] + u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2; + } + // step 8 + for (k=k2=0; k < n4; ++k,k2 += 2) { + X[k] = v[k2+n2]*B[k2 ] + v[k2+1+n2]*B[k2+1]; + X[n2-1-k] = v[k2+n2]*B[k2+1] - v[k2+1+n2]*B[k2 ]; + } + + // decode kernel to output + // determined the following value experimentally + // (by first figuring out what made inverse_mdct_slow work); then matching that here + // (probably vorbis encoder premultiplies by n or n/2, to save it on the decoder?) + s = 0.5; // theoretically would be n4 + + // [[[ note! the s value of 0.5 is compensated for by the B[] in the current code, + // so it needs to use the "old" B values to behave correctly, or else + // set s to 1.0 ]]] + for (i=0; i < n4 ; ++i) buffer[i] = s * X[i+n4]; + for ( ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1]; + for ( ; i < n ; ++i) buffer[i] = -s * X[i - n3_4]; +} +#endif + +static float *get_window(vorb *f, int len) +{ + len <<= 1; + if (len == f->blocksize_0) return f->window[0]; + if (len == f->blocksize_1) return f->window[1]; + assert(0); + return NULL; +} + +#ifndef STB_VORBIS_NO_DEFER_FLOOR +typedef int16 YTYPE; +#else +typedef int YTYPE; +#endif +static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag) +{ + int n2 = n >> 1; + int s = map->chan[i].mux, floor; + floor = map->submap_floor[s]; + if (f->floor_types[floor] == 0) { + return error(f, VORBIS_invalid_stream); + } else { + Floor1 *g = &f->floor_config[floor].floor1; + int j,q; + int lx = 0, ly = finalY[0] * g->floor1_multiplier; + for (q=1; q < g->values; ++q) { + j = g->sorted_order[q]; + #ifndef STB_VORBIS_NO_DEFER_FLOOR + if (finalY[j] >= 0) + #else + if (step2_flag[j]) + #endif + { + int hy = finalY[j] * g->floor1_multiplier; + int hx = g->Xlist[j]; + if (lx != hx) + draw_line(target, lx,ly, hx,hy, n2); + CHECK(f); + lx = hx, ly = hy; + } + } + if (lx < n2) { + // optimization of: draw_line(target, lx,ly, n,ly, n2); + for (j=lx; j < n2; ++j) + LINE_OP(target[j], inverse_db_table[ly]); + CHECK(f); + } + } + return TRUE; +} + +// The meaning of "left" and "right" +// +// For a given frame: +// we compute samples from 0..n +// window_center is n/2 +// we'll window and mix the samples from left_start to left_end with data from the previous frame +// all of the samples from left_end to right_start can be output without mixing; however, +// this interval is 0-length except when transitioning between short and long frames +// all of the samples from right_start to right_end need to be mixed with the next frame, +// which we don't have, so those get saved in a buffer +// frame N's right_end-right_start, the number of samples to mix with the next frame, +// has to be the same as frame N+1's left_end-left_start (which they are by +// construction) + +static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode) +{ + Mode *m; + int i, n, prev, next, window_center; + f->channel_buffer_start = f->channel_buffer_end = 0; + + retry: + if (f->eof) return FALSE; + if (!maybe_start_packet(f)) + return FALSE; + // check packet type + if (get_bits(f,1) != 0) { + if (IS_PUSH_MODE(f)) + return error(f,VORBIS_bad_packet_type); + while (EOP != get8_packet(f)); + goto retry; + } + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + + i = get_bits(f, ilog(f->mode_count-1)); + if (i == EOP) return FALSE; + if (i >= f->mode_count) return FALSE; + *mode = i; + m = f->mode_config + i; + if (m->blockflag) { + n = f->blocksize_1; + prev = get_bits(f,1); + next = get_bits(f,1); + } else { + prev = next = 0; + n = f->blocksize_0; + } + +// WINDOWING + + window_center = n >> 1; + if (m->blockflag && !prev) { + *p_left_start = (n - f->blocksize_0) >> 2; + *p_left_end = (n + f->blocksize_0) >> 2; + } else { + *p_left_start = 0; + *p_left_end = window_center; + } + if (m->blockflag && !next) { + *p_right_start = (n*3 - f->blocksize_0) >> 2; + *p_right_end = (n*3 + f->blocksize_0) >> 2; + } else { + *p_right_start = window_center; + *p_right_end = n; + } + + return TRUE; +} + +static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left) +{ + Mapping *map; + int i,j,k,n,n2; + int zero_channel[256]; + int really_zero_channel[256]; + +// WINDOWING + + n = f->blocksize[m->blockflag]; + map = &f->mapping[m->mapping]; + +// FLOORS + n2 = n >> 1; + + CHECK(f); + + for (i=0; i < f->channels; ++i) { + int s = map->chan[i].mux, floor; + zero_channel[i] = FALSE; + floor = map->submap_floor[s]; + if (f->floor_types[floor] == 0) { + return error(f, VORBIS_invalid_stream); + } else { + Floor1 *g = &f->floor_config[floor].floor1; + if (get_bits(f, 1)) { + short *finalY; + uint8 step2_flag[256]; + static int range_list[4] = { 256, 128, 86, 64 }; + int range = range_list[g->floor1_multiplier-1]; + int offset = 2; + finalY = f->finalY[i]; + finalY[0] = get_bits(f, ilog(range)-1); + finalY[1] = get_bits(f, ilog(range)-1); + for (j=0; j < g->partitions; ++j) { + int pclass = g->partition_class_list[j]; + int cdim = g->class_dimensions[pclass]; + int cbits = g->class_subclasses[pclass]; + int csub = (1 << cbits)-1; + int cval = 0; + if (cbits) { + Codebook *c = f->codebooks + g->class_masterbooks[pclass]; + DECODE(cval,f,c); + } + for (k=0; k < cdim; ++k) { + int book = g->subclass_books[pclass][cval & csub]; + cval = cval >> cbits; + if (book >= 0) { + int temp; + Codebook *c = f->codebooks + book; + DECODE(temp,f,c); + finalY[offset++] = temp; + } else + finalY[offset++] = 0; + } + } + if (f->valid_bits == INVALID_BITS) goto error; // behavior according to spec + step2_flag[0] = step2_flag[1] = 1; + for (j=2; j < g->values; ++j) { + int low, high, pred, highroom, lowroom, room, val; + low = g->neighbors[j][0]; + high = g->neighbors[j][1]; + //neighbors(g->Xlist, j, &low, &high); + pred = predict_point(g->Xlist[j], g->Xlist[low], g->Xlist[high], finalY[low], finalY[high]); + val = finalY[j]; + highroom = range - pred; + lowroom = pred; + if (highroom < lowroom) + room = highroom * 2; + else + room = lowroom * 2; + if (val) { + step2_flag[low] = step2_flag[high] = 1; + step2_flag[j] = 1; + if (val >= room) + if (highroom > lowroom) + finalY[j] = val - lowroom + pred; + else + finalY[j] = pred - val + highroom - 1; + else + if (val & 1) + finalY[j] = pred - ((val+1)>>1); + else + finalY[j] = pred + (val>>1); + } else { + step2_flag[j] = 0; + finalY[j] = pred; + } + } + +#ifdef STB_VORBIS_NO_DEFER_FLOOR + do_floor(f, map, i, n, f->floor_buffers[i], finalY, step2_flag); +#else + // defer final floor computation until _after_ residue + for (j=0; j < g->values; ++j) { + if (!step2_flag[j]) + finalY[j] = -1; + } +#endif + } else { + error: + zero_channel[i] = TRUE; + } + // So we just defer everything else to later + + // at this point we've decoded the floor into buffer + } + } + CHECK(f); + // at this point we've decoded all floors + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + + // re-enable coupled channels if necessary + memcpy(really_zero_channel, zero_channel, sizeof(really_zero_channel[0]) * f->channels); + for (i=0; i < map->coupling_steps; ++i) + if (!zero_channel[map->chan[i].magnitude] || !zero_channel[map->chan[i].angle]) { + zero_channel[map->chan[i].magnitude] = zero_channel[map->chan[i].angle] = FALSE; + } + + CHECK(f); +// RESIDUE DECODE + for (i=0; i < map->submaps; ++i) { + float *residue_buffers[STB_VORBIS_MAX_CHANNELS]; + int r; + uint8 do_not_decode[256]; + int ch = 0; + for (j=0; j < f->channels; ++j) { + if (map->chan[j].mux == i) { + if (zero_channel[j]) { + do_not_decode[ch] = TRUE; + residue_buffers[ch] = NULL; + } else { + do_not_decode[ch] = FALSE; + residue_buffers[ch] = f->channel_buffers[j]; + } + ++ch; + } + } + r = map->submap_residue[i]; + decode_residue(f, residue_buffers, ch, n2, r, do_not_decode); + } + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + CHECK(f); + +// INVERSE COUPLING + for (i = map->coupling_steps-1; i >= 0; --i) { + int n2 = n >> 1; + float *m = f->channel_buffers[map->chan[i].magnitude]; + float *a = f->channel_buffers[map->chan[i].angle ]; + for (j=0; j < n2; ++j) { + float a2,m2; + if (m[j] > 0) + if (a[j] > 0) + m2 = m[j], a2 = m[j] - a[j]; + else + a2 = m[j], m2 = m[j] + a[j]; + else + if (a[j] > 0) + m2 = m[j], a2 = m[j] + a[j]; + else + a2 = m[j], m2 = m[j] - a[j]; + m[j] = m2; + a[j] = a2; + } + } + CHECK(f); + + // finish decoding the floors +#ifndef STB_VORBIS_NO_DEFER_FLOOR + for (i=0; i < f->channels; ++i) { + if (really_zero_channel[i]) { + memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); + } else { + do_floor(f, map, i, n, f->channel_buffers[i], f->finalY[i], NULL); + } + } +#else + for (i=0; i < f->channels; ++i) { + if (really_zero_channel[i]) { + memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); + } else { + for (j=0; j < n2; ++j) + f->channel_buffers[i][j] *= f->floor_buffers[i][j]; + } + } +#endif + +// INVERSE MDCT + CHECK(f); + for (i=0; i < f->channels; ++i) + inverse_mdct(f->channel_buffers[i], n, f, m->blockflag); + CHECK(f); + + // this shouldn't be necessary, unless we exited on an error + // and want to flush to get to the next packet + flush_packet(f); + + if (f->first_decode) { + // assume we start so first non-discarded sample is sample 0 + // this isn't to spec, but spec would require us to read ahead + // and decode the size of all current frames--could be done, + // but presumably it's not a commonly used feature + f->current_loc = -n2; // start of first frame is positioned for discard + // we might have to discard samples "from" the next frame too, + // if we're lapping a large block then a small at the start? + f->discard_samples_deferred = n - right_end; + f->current_loc_valid = TRUE; + f->first_decode = FALSE; + } else if (f->discard_samples_deferred) { + if (f->discard_samples_deferred >= right_start - left_start) { + f->discard_samples_deferred -= (right_start - left_start); + left_start = right_start; + *p_left = left_start; + } else { + left_start += f->discard_samples_deferred; + *p_left = left_start; + f->discard_samples_deferred = 0; + } + } else if (f->previous_length == 0 && f->current_loc_valid) { + // we're recovering from a seek... that means we're going to discard + // the samples from this packet even though we know our position from + // the last page header, so we need to update the position based on + // the discarded samples here + // but wait, the code below is going to add this in itself even + // on a discard, so we don't need to do it here... + } + + // check if we have ogg information about the sample # for this packet + if (f->last_seg_which == f->end_seg_with_known_loc) { + // if we have a valid current loc, and this is final: + if (f->current_loc_valid && (f->page_flag & PAGEFLAG_last_page)) { + uint32 current_end = f->known_loc_for_packet; + // then let's infer the size of the (probably) short final frame + if (current_end < f->current_loc + (right_end-left_start)) { + if (current_end < f->current_loc) { + // negative truncation, that's impossible! + *len = 0; + } else { + *len = current_end - f->current_loc; + } + *len += left_start; // this doesn't seem right, but has no ill effect on my test files + if (*len > right_end) *len = right_end; // this should never happen + f->current_loc += *len; + return TRUE; + } + } + // otherwise, just set our sample loc + // guess that the ogg granule pos refers to the _middle_ of the + // last frame? + // set f->current_loc to the position of left_start + f->current_loc = f->known_loc_for_packet - (n2-left_start); + f->current_loc_valid = TRUE; + } + if (f->current_loc_valid) + f->current_loc += (right_start - left_start); + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + *len = right_end; // ignore samples after the window goes to 0 + CHECK(f); + + return TRUE; +} + +static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right) +{ + int mode, left_end, right_end; + if (!vorbis_decode_initial(f, p_left, &left_end, p_right, &right_end, &mode)) return 0; + return vorbis_decode_packet_rest(f, len, f->mode_config + mode, *p_left, left_end, *p_right, right_end, p_left); +} + +static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right) +{ + int prev,i,j; + // we use right&left (the start of the right- and left-window sin()-regions) + // to determine how much to return, rather than inferring from the rules + // (same result, clearer code); 'left' indicates where our sin() window + // starts, therefore where the previous window's right edge starts, and + // therefore where to start mixing from the previous buffer. 'right' + // indicates where our sin() ending-window starts, therefore that's where + // we start saving, and where our returned-data ends. + + // mixin from previous window + if (f->previous_length) { + int i,j, n = f->previous_length; + float *w = get_window(f, n); + for (i=0; i < f->channels; ++i) { + for (j=0; j < n; ++j) + f->channel_buffers[i][left+j] = + f->channel_buffers[i][left+j]*w[ j] + + f->previous_window[i][ j]*w[n-1-j]; + } + } + + prev = f->previous_length; + + // last half of this data becomes previous window + f->previous_length = len - right; + + // @OPTIMIZE: could avoid this copy by double-buffering the + // output (flipping previous_window with channel_buffers), but + // then previous_window would have to be 2x as large, and + // channel_buffers couldn't be temp mem (although they're NOT + // currently temp mem, they could be (unless we want to level + // performance by spreading out the computation)) + for (i=0; i < f->channels; ++i) + for (j=0; right+j < len; ++j) + f->previous_window[i][j] = f->channel_buffers[i][right+j]; + + if (!prev) + // there was no previous packet, so this data isn't valid... + // this isn't entirely true, only the would-have-overlapped data + // isn't valid, but this seems to be what the spec requires + return 0; + + // truncate a short frame + if (len < right) right = len; + + f->samples_output += right-left; + + return right - left; +} + +static int vorbis_pump_first_frame(stb_vorbis *f) +{ + int len, right, left, res; + res = vorbis_decode_packet(f, &len, &left, &right); + if (res) + vorbis_finish_frame(f, len, left, right); + return res; +} + +#ifndef STB_VORBIS_NO_PUSHDATA_API +static int is_whole_packet_present(stb_vorbis *f, int end_page) +{ + // make sure that we have the packet available before continuing... + // this requires a full ogg parse, but we know we can fetch from f->stream + + // instead of coding this out explicitly, we could save the current read state, + // read the next packet with get8() until end-of-packet, check f->eof, then + // reset the state? but that would be slower, esp. since we'd have over 256 bytes + // of state to restore (primarily the page segment table) + + int s = f->next_seg, first = TRUE; + uint8 *p = f->stream; + + if (s != -1) { // if we're not starting the packet with a 'continue on next page' flag + for (; s < f->segment_count; ++s) { + p += f->segments[s]; + if (f->segments[s] < 255) // stop at first short segment + break; + } + // either this continues, or it ends it... + if (end_page) + if (s < f->segment_count-1) return error(f, VORBIS_invalid_stream); + if (s == f->segment_count) + s = -1; // set 'crosses page' flag + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + first = FALSE; + } + for (; s == -1;) { + uint8 *q; + int n; + + // check that we have the page header ready + if (p + 26 >= f->stream_end) return error(f, VORBIS_need_more_data); + // validate the page + if (memcmp(p, ogg_page_header, 4)) return error(f, VORBIS_invalid_stream); + if (p[4] != 0) return error(f, VORBIS_invalid_stream); + if (first) { // the first segment must NOT have 'continued_packet', later ones MUST + if (f->previous_length) + if ((p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream); + // if no previous length, we're resynching, so we can come in on a continued-packet, + // which we'll just drop + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream); + } + n = p[26]; // segment counts + q = p+27; // q points to segment table + p = q + n; // advance past header + // make sure we've read the segment table + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + for (s=0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) + break; + } + if (end_page) + if (s < n-1) return error(f, VORBIS_invalid_stream); + if (s == n) + s = -1; // set 'crosses page' flag + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + first = FALSE; + } + return TRUE; +} +#endif // !STB_VORBIS_NO_PUSHDATA_API + +static int start_decoder(vorb *f) +{ + uint8 header[6], x,y; + int len,i,j,k, max_submaps = 0; + int longest_floorlist=0; + + // first page, first packet + + if (!start_page(f)) return FALSE; + // validate page flag + if (!(f->page_flag & PAGEFLAG_first_page)) return error(f, VORBIS_invalid_first_page); + if (f->page_flag & PAGEFLAG_last_page) return error(f, VORBIS_invalid_first_page); + if (f->page_flag & PAGEFLAG_continued_packet) return error(f, VORBIS_invalid_first_page); + // check for expected packet length + if (f->segment_count != 1) return error(f, VORBIS_invalid_first_page); + if (f->segments[0] != 30) return error(f, VORBIS_invalid_first_page); + // read packet + // check packet header + if (get8(f) != VORBIS_packet_id) return error(f, VORBIS_invalid_first_page); + if (!getn(f, header, 6)) return error(f, VORBIS_unexpected_eof); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_first_page); + // vorbis_version + if (get32(f) != 0) return error(f, VORBIS_invalid_first_page); + f->channels = get8(f); if (!f->channels) return error(f, VORBIS_invalid_first_page); + if (f->channels > STB_VORBIS_MAX_CHANNELS) return error(f, VORBIS_too_many_channels); + f->sample_rate = get32(f); if (!f->sample_rate) return error(f, VORBIS_invalid_first_page); + get32(f); // bitrate_maximum + get32(f); // bitrate_nominal + get32(f); // bitrate_minimum + x = get8(f); + { + int log0,log1; + log0 = x & 15; + log1 = x >> 4; + f->blocksize_0 = 1 << log0; + f->blocksize_1 = 1 << log1; + if (log0 < 6 || log0 > 13) return error(f, VORBIS_invalid_setup); + if (log1 < 6 || log1 > 13) return error(f, VORBIS_invalid_setup); + if (log0 > log1) return error(f, VORBIS_invalid_setup); + } + + // framing_flag + x = get8(f); + if (!(x & 1)) return error(f, VORBIS_invalid_first_page); + + // second packet! + if (!start_page(f)) return FALSE; + + if (!start_packet(f)) return FALSE; + do { + len = next_segment(f); + skip(f, len); + f->bytes_in_seg = 0; + } while (len); + + // third packet! + if (!start_packet(f)) return FALSE; + + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (IS_PUSH_MODE(f)) { + if (!is_whole_packet_present(f, TRUE)) { + // convert error in ogg header to write type + if (f->error == VORBIS_invalid_stream) + f->error = VORBIS_invalid_setup; + return FALSE; + } + } + #endif + + crc32_init(); // always init it, to avoid multithread race conditions + + if (get8_packet(f) != VORBIS_packet_setup) return error(f, VORBIS_invalid_setup); + for (i=0; i < 6; ++i) header[i] = get8_packet(f); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_setup); + + // codebooks + + f->codebook_count = get_bits(f,8) + 1; + f->codebooks = (Codebook *) setup_malloc(f, sizeof(*f->codebooks) * f->codebook_count); + if (f->codebooks == NULL) return error(f, VORBIS_outofmem); + memset(f->codebooks, 0, sizeof(*f->codebooks) * f->codebook_count); + for (i=0; i < f->codebook_count; ++i) { + uint32 *values; + int ordered, sorted_count; + int total=0; + uint8 *lengths; + Codebook *c = f->codebooks+i; + CHECK(f); + x = get_bits(f, 8); if (x != 0x42) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); if (x != 0x43) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); if (x != 0x56) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); + c->dimensions = (get_bits(f, 8)<<8) + x; + x = get_bits(f, 8); + y = get_bits(f, 8); + c->entries = (get_bits(f, 8)<<16) + (y<<8) + x; + ordered = get_bits(f,1); + c->sparse = ordered ? 0 : get_bits(f,1); + + if (c->dimensions == 0 && c->entries != 0) return error(f, VORBIS_invalid_setup); + + if (c->sparse) + lengths = (uint8 *) setup_temp_malloc(f, c->entries); + else + lengths = c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries); + + if (!lengths) return error(f, VORBIS_outofmem); + + if (ordered) { + int current_entry = 0; + int current_length = get_bits(f,5) + 1; + while (current_entry < c->entries) { + int limit = c->entries - current_entry; + int n = get_bits(f, ilog(limit)); + if (current_entry + n > (int) c->entries) { return error(f, VORBIS_invalid_setup); } + memset(lengths + current_entry, current_length, n); + current_entry += n; + ++current_length; + } + } else { + for (j=0; j < c->entries; ++j) { + int present = c->sparse ? get_bits(f,1) : 1; + if (present) { + lengths[j] = get_bits(f, 5) + 1; + ++total; + if (lengths[j] == 32) + return error(f, VORBIS_invalid_setup); + } else { + lengths[j] = NO_CODE; + } + } + } + + if (c->sparse && total >= c->entries >> 2) { + // convert sparse items to non-sparse! + if (c->entries > (int) f->setup_temp_memory_required) + f->setup_temp_memory_required = c->entries; + + c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries); + if (c->codeword_lengths == NULL) return error(f, VORBIS_outofmem); + memcpy(c->codeword_lengths, lengths, c->entries); + setup_temp_free(f, lengths, c->entries); // note this is only safe if there have been no intervening temp mallocs! + lengths = c->codeword_lengths; + c->sparse = 0; + } + + // compute the size of the sorted tables + if (c->sparse) { + sorted_count = total; + } else { + sorted_count = 0; + #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH + for (j=0; j < c->entries; ++j) + if (lengths[j] > STB_VORBIS_FAST_HUFFMAN_LENGTH && lengths[j] != NO_CODE) + ++sorted_count; + #endif + } + + c->sorted_entries = sorted_count; + values = NULL; + + CHECK(f); + if (!c->sparse) { + c->codewords = (uint32 *) setup_malloc(f, sizeof(c->codewords[0]) * c->entries); + if (!c->codewords) return error(f, VORBIS_outofmem); + } else { + unsigned int size; + if (c->sorted_entries) { + c->codeword_lengths = (uint8 *) setup_malloc(f, c->sorted_entries); + if (!c->codeword_lengths) return error(f, VORBIS_outofmem); + c->codewords = (uint32 *) setup_temp_malloc(f, sizeof(*c->codewords) * c->sorted_entries); + if (!c->codewords) return error(f, VORBIS_outofmem); + values = (uint32 *) setup_temp_malloc(f, sizeof(*values) * c->sorted_entries); + if (!values) return error(f, VORBIS_outofmem); + } + size = c->entries + (sizeof(*c->codewords) + sizeof(*values)) * c->sorted_entries; + if (size > f->setup_temp_memory_required) + f->setup_temp_memory_required = size; + } + + if (!compute_codewords(c, lengths, c->entries, values)) { + if (c->sparse) setup_temp_free(f, values, 0); + return error(f, VORBIS_invalid_setup); + } + + if (c->sorted_entries) { + // allocate an extra slot for sentinels + c->sorted_codewords = (uint32 *) setup_malloc(f, sizeof(*c->sorted_codewords) * (c->sorted_entries+1)); + if (c->sorted_codewords == NULL) return error(f, VORBIS_outofmem); + // allocate an extra slot at the front so that c->sorted_values[-1] is defined + // so that we can catch that case without an extra if + c->sorted_values = ( int *) setup_malloc(f, sizeof(*c->sorted_values ) * (c->sorted_entries+1)); + if (c->sorted_values == NULL) return error(f, VORBIS_outofmem); + ++c->sorted_values; + c->sorted_values[-1] = -1; + compute_sorted_huffman(c, lengths, values); + } + + if (c->sparse) { + setup_temp_free(f, values, sizeof(*values)*c->sorted_entries); + setup_temp_free(f, c->codewords, sizeof(*c->codewords)*c->sorted_entries); + setup_temp_free(f, lengths, c->entries); + c->codewords = NULL; + } + + compute_accelerated_huffman(c); + + CHECK(f); + c->lookup_type = get_bits(f, 4); + if (c->lookup_type > 2) return error(f, VORBIS_invalid_setup); + if (c->lookup_type > 0) { + uint16 *mults; + c->minimum_value = float32_unpack(get_bits(f, 32)); + c->delta_value = float32_unpack(get_bits(f, 32)); + c->value_bits = get_bits(f, 4)+1; + c->sequence_p = get_bits(f,1); + if (c->lookup_type == 1) { + c->lookup_values = lookup1_values(c->entries, c->dimensions); + } else { + c->lookup_values = c->entries * c->dimensions; + } + if (c->lookup_values == 0) return error(f, VORBIS_invalid_setup); + mults = (uint16 *) setup_temp_malloc(f, sizeof(mults[0]) * c->lookup_values); + if (mults == NULL) return error(f, VORBIS_outofmem); + for (j=0; j < (int) c->lookup_values; ++j) { + int q = get_bits(f, c->value_bits); + if (q == EOP) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_invalid_setup); } + mults[j] = q; + } + +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int len, sparse = c->sparse; + float last=0; + // pre-expand the lookup1-style multiplicands, to avoid a divide in the inner loop + if (sparse) { + if (c->sorted_entries == 0) goto skip; + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions); + } else + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries * c->dimensions); + if (c->multiplicands == NULL) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); } + len = sparse ? c->sorted_entries : c->entries; + for (j=0; j < len; ++j) { + unsigned int z = sparse ? c->sorted_values[j] : j; + unsigned int div=1; + for (k=0; k < c->dimensions; ++k) { + int off = (z / div) % c->lookup_values; + float val = mults[off]; + val = mults[off]*c->delta_value + c->minimum_value + last; + c->multiplicands[j*c->dimensions + k] = val; + if (c->sequence_p) + last = val; + if (k+1 < c->dimensions) { + if (div > UINT_MAX / (unsigned int) c->lookup_values) { + setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); + return error(f, VORBIS_invalid_setup); + } + div *= c->lookup_values; + } + } + } + c->lookup_type = 2; + } + else +#endif + { + float last=0; + CHECK(f); + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values); + if (c->multiplicands == NULL) { setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); } + for (j=0; j < (int) c->lookup_values; ++j) { + float val = mults[j] * c->delta_value + c->minimum_value + last; + c->multiplicands[j] = val; + if (c->sequence_p) + last = val; + } + } +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + skip:; +#endif + setup_temp_free(f, mults, sizeof(mults[0])*c->lookup_values); + + CHECK(f); + } + CHECK(f); + } + + // time domain transfers (notused) + + x = get_bits(f, 6) + 1; + for (i=0; i < x; ++i) { + uint32 z = get_bits(f, 16); + if (z != 0) return error(f, VORBIS_invalid_setup); + } + + // Floors + f->floor_count = get_bits(f, 6)+1; + f->floor_config = (Floor *) setup_malloc(f, f->floor_count * sizeof(*f->floor_config)); + if (f->floor_config == NULL) return error(f, VORBIS_outofmem); + for (i=0; i < f->floor_count; ++i) { + f->floor_types[i] = get_bits(f, 16); + if (f->floor_types[i] > 1) return error(f, VORBIS_invalid_setup); + if (f->floor_types[i] == 0) { + Floor0 *g = &f->floor_config[i].floor0; + g->order = get_bits(f,8); + g->rate = get_bits(f,16); + g->bark_map_size = get_bits(f,16); + g->amplitude_bits = get_bits(f,6); + g->amplitude_offset = get_bits(f,8); + g->number_of_books = get_bits(f,4) + 1; + for (j=0; j < g->number_of_books; ++j) + g->book_list[j] = get_bits(f,8); + return error(f, VORBIS_feature_not_supported); + } else { + stbv__floor_ordering p[31*8+2]; + Floor1 *g = &f->floor_config[i].floor1; + int max_class = -1; + g->partitions = get_bits(f, 5); + for (j=0; j < g->partitions; ++j) { + g->partition_class_list[j] = get_bits(f, 4); + if (g->partition_class_list[j] > max_class) + max_class = g->partition_class_list[j]; + } + for (j=0; j <= max_class; ++j) { + g->class_dimensions[j] = get_bits(f, 3)+1; + g->class_subclasses[j] = get_bits(f, 2); + if (g->class_subclasses[j]) { + g->class_masterbooks[j] = get_bits(f, 8); + if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } + for (k=0; k < 1 << g->class_subclasses[j]; ++k) { + g->subclass_books[j][k] = get_bits(f,8)-1; + if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } + } + g->floor1_multiplier = get_bits(f,2)+1; + g->rangebits = get_bits(f,4); + g->Xlist[0] = 0; + g->Xlist[1] = 1 << g->rangebits; + g->values = 2; + for (j=0; j < g->partitions; ++j) { + int c = g->partition_class_list[j]; + for (k=0; k < g->class_dimensions[c]; ++k) { + g->Xlist[g->values] = get_bits(f, g->rangebits); + ++g->values; + } + } + // precompute the sorting + for (j=0; j < g->values; ++j) { + p[j].x = g->Xlist[j]; + p[j].id = j; + } + qsort(p, g->values, sizeof(p[0]), point_compare); + for (j=0; j < g->values; ++j) + g->sorted_order[j] = (uint8) p[j].id; + // precompute the neighbors + for (j=2; j < g->values; ++j) { + int low,hi; + neighbors(g->Xlist, j, &low,&hi); + g->neighbors[j][0] = low; + g->neighbors[j][1] = hi; + } + + if (g->values > longest_floorlist) + longest_floorlist = g->values; + } + } + + // Residue + f->residue_count = get_bits(f, 6)+1; + f->residue_config = (Residue *) setup_malloc(f, f->residue_count * sizeof(f->residue_config[0])); + if (f->residue_config == NULL) return error(f, VORBIS_outofmem); + memset(f->residue_config, 0, f->residue_count * sizeof(f->residue_config[0])); + for (i=0; i < f->residue_count; ++i) { + uint8 residue_cascade[64]; + Residue *r = f->residue_config+i; + f->residue_types[i] = get_bits(f, 16); + if (f->residue_types[i] > 2) return error(f, VORBIS_invalid_setup); + r->begin = get_bits(f, 24); + r->end = get_bits(f, 24); + if (r->end < r->begin) return error(f, VORBIS_invalid_setup); + r->part_size = get_bits(f,24)+1; + r->classifications = get_bits(f,6)+1; + r->classbook = get_bits(f,8); + if (r->classbook >= f->codebook_count) return error(f, VORBIS_invalid_setup); + for (j=0; j < r->classifications; ++j) { + uint8 high_bits=0; + uint8 low_bits=get_bits(f,3); + if (get_bits(f,1)) + high_bits = get_bits(f,5); + residue_cascade[j] = high_bits*8 + low_bits; + } + r->residue_books = (short (*)[8]) setup_malloc(f, sizeof(r->residue_books[0]) * r->classifications); + if (r->residue_books == NULL) return error(f, VORBIS_outofmem); + for (j=0; j < r->classifications; ++j) { + for (k=0; k < 8; ++k) { + if (residue_cascade[j] & (1 << k)) { + r->residue_books[j][k] = get_bits(f, 8); + if (r->residue_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } else { + r->residue_books[j][k] = -1; + } + } + } + // precompute the classifications[] array to avoid inner-loop mod/divide + // call it 'classdata' since we already have r->classifications + r->classdata = (uint8 **) setup_malloc(f, sizeof(*r->classdata) * f->codebooks[r->classbook].entries); + if (!r->classdata) return error(f, VORBIS_outofmem); + memset(r->classdata, 0, sizeof(*r->classdata) * f->codebooks[r->classbook].entries); + for (j=0; j < f->codebooks[r->classbook].entries; ++j) { + int classwords = f->codebooks[r->classbook].dimensions; + int temp = j; + r->classdata[j] = (uint8 *) setup_malloc(f, sizeof(r->classdata[j][0]) * classwords); + if (r->classdata[j] == NULL) return error(f, VORBIS_outofmem); + for (k=classwords-1; k >= 0; --k) { + r->classdata[j][k] = temp % r->classifications; + temp /= r->classifications; + } + } + } + + f->mapping_count = get_bits(f,6)+1; + f->mapping = (Mapping *) setup_malloc(f, f->mapping_count * sizeof(*f->mapping)); + if (f->mapping == NULL) return error(f, VORBIS_outofmem); + memset(f->mapping, 0, f->mapping_count * sizeof(*f->mapping)); + for (i=0; i < f->mapping_count; ++i) { + Mapping *m = f->mapping + i; + int mapping_type = get_bits(f,16); + if (mapping_type != 0) return error(f, VORBIS_invalid_setup); + m->chan = (MappingChannel *) setup_malloc(f, f->channels * sizeof(*m->chan)); + if (m->chan == NULL) return error(f, VORBIS_outofmem); + if (get_bits(f,1)) + m->submaps = get_bits(f,4)+1; + else + m->submaps = 1; + if (m->submaps > max_submaps) + max_submaps = m->submaps; + if (get_bits(f,1)) { + m->coupling_steps = get_bits(f,8)+1; + for (k=0; k < m->coupling_steps; ++k) { + m->chan[k].magnitude = get_bits(f, ilog(f->channels-1)); + m->chan[k].angle = get_bits(f, ilog(f->channels-1)); + if (m->chan[k].magnitude >= f->channels) return error(f, VORBIS_invalid_setup); + if (m->chan[k].angle >= f->channels) return error(f, VORBIS_invalid_setup); + if (m->chan[k].magnitude == m->chan[k].angle) return error(f, VORBIS_invalid_setup); + } + } else + m->coupling_steps = 0; + + // reserved field + if (get_bits(f,2)) return error(f, VORBIS_invalid_setup); + if (m->submaps > 1) { + for (j=0; j < f->channels; ++j) { + m->chan[j].mux = get_bits(f, 4); + if (m->chan[j].mux >= m->submaps) return error(f, VORBIS_invalid_setup); + } + } else + // @SPECIFICATION: this case is missing from the spec + for (j=0; j < f->channels; ++j) + m->chan[j].mux = 0; + + for (j=0; j < m->submaps; ++j) { + get_bits(f,8); // discard + m->submap_floor[j] = get_bits(f,8); + m->submap_residue[j] = get_bits(f,8); + if (m->submap_floor[j] >= f->floor_count) return error(f, VORBIS_invalid_setup); + if (m->submap_residue[j] >= f->residue_count) return error(f, VORBIS_invalid_setup); + } + } + + // Modes + f->mode_count = get_bits(f, 6)+1; + for (i=0; i < f->mode_count; ++i) { + Mode *m = f->mode_config+i; + m->blockflag = get_bits(f,1); + m->windowtype = get_bits(f,16); + m->transformtype = get_bits(f,16); + m->mapping = get_bits(f,8); + if (m->windowtype != 0) return error(f, VORBIS_invalid_setup); + if (m->transformtype != 0) return error(f, VORBIS_invalid_setup); + if (m->mapping >= f->mapping_count) return error(f, VORBIS_invalid_setup); + } + + flush_packet(f); + + f->previous_length = 0; + + for (i=0; i < f->channels; ++i) { + f->channel_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1); + f->previous_window[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2); + f->finalY[i] = (int16 *) setup_malloc(f, sizeof(int16) * longest_floorlist); + if (f->channel_buffers[i] == NULL || f->previous_window[i] == NULL || f->finalY[i] == NULL) return error(f, VORBIS_outofmem); + memset(f->channel_buffers[i], 0, sizeof(float) * f->blocksize_1); + #ifdef STB_VORBIS_NO_DEFER_FLOOR + f->floor_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2); + if (f->floor_buffers[i] == NULL) return error(f, VORBIS_outofmem); + #endif + } + + if (!init_blocksize(f, 0, f->blocksize_0)) return FALSE; + if (!init_blocksize(f, 1, f->blocksize_1)) return FALSE; + f->blocksize[0] = f->blocksize_0; + f->blocksize[1] = f->blocksize_1; + +#ifdef STB_VORBIS_DIVIDE_TABLE + if (integer_divide_table[1][1]==0) + for (i=0; i < DIVTAB_NUMER; ++i) + for (j=1; j < DIVTAB_DENOM; ++j) + integer_divide_table[i][j] = i / j; +#endif + + // compute how much temporary memory is needed + + // 1. + { + uint32 imdct_mem = (f->blocksize_1 * sizeof(float) >> 1); + uint32 classify_mem; + int i,max_part_read=0; + for (i=0; i < f->residue_count; ++i) { + Residue *r = f->residue_config + i; + unsigned int actual_size = f->blocksize_1 / 2; + unsigned int limit_r_begin = r->begin < actual_size ? r->begin : actual_size; + unsigned int limit_r_end = r->end < actual_size ? r->end : actual_size; + int n_read = limit_r_end - limit_r_begin; + int part_read = n_read / r->part_size; + if (part_read > max_part_read) + max_part_read = part_read; + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(uint8 *)); + #else + classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(int *)); + #endif + + // maximum reasonable partition size is f->blocksize_1 + + f->temp_memory_required = classify_mem; + if (imdct_mem > f->temp_memory_required) + f->temp_memory_required = imdct_mem; + } + + f->first_decode = TRUE; + + if (f->alloc.alloc_buffer) { + assert(f->temp_offset == f->alloc.alloc_buffer_length_in_bytes); + // check if there's enough temp memory so we don't error later + if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset) + return error(f, VORBIS_outofmem); + } + + f->first_audio_page_offset = stb_vorbis_get_file_offset(f); + + return TRUE; +} + +static void vorbis_deinit(stb_vorbis *p) +{ + int i,j; + if (p->residue_config) { + for (i=0; i < p->residue_count; ++i) { + Residue *r = p->residue_config+i; + if (r->classdata) { + for (j=0; j < p->codebooks[r->classbook].entries; ++j) + setup_free(p, r->classdata[j]); + setup_free(p, r->classdata); + } + setup_free(p, r->residue_books); + } + } + + if (p->codebooks) { + CHECK(p); + for (i=0; i < p->codebook_count; ++i) { + Codebook *c = p->codebooks + i; + setup_free(p, c->codeword_lengths); + setup_free(p, c->multiplicands); + setup_free(p, c->codewords); + setup_free(p, c->sorted_codewords); + // c->sorted_values[-1] is the first entry in the array + setup_free(p, c->sorted_values ? c->sorted_values-1 : NULL); + } + setup_free(p, p->codebooks); + } + setup_free(p, p->floor_config); + setup_free(p, p->residue_config); + if (p->mapping) { + for (i=0; i < p->mapping_count; ++i) + setup_free(p, p->mapping[i].chan); + setup_free(p, p->mapping); + } + CHECK(p); + for (i=0; i < p->channels && i < STB_VORBIS_MAX_CHANNELS; ++i) { + setup_free(p, p->channel_buffers[i]); + setup_free(p, p->previous_window[i]); + #ifdef STB_VORBIS_NO_DEFER_FLOOR + setup_free(p, p->floor_buffers[i]); + #endif + setup_free(p, p->finalY[i]); + } + for (i=0; i < 2; ++i) { + setup_free(p, p->A[i]); + setup_free(p, p->B[i]); + setup_free(p, p->C[i]); + setup_free(p, p->window[i]); + setup_free(p, p->bit_reverse[i]); + } + #ifndef STB_VORBIS_NO_STDIO + if (p->close_on_free) fclose(p->f); + #endif +} + +void stb_vorbis_close(stb_vorbis *p) +{ + if (p == NULL) return; + vorbis_deinit(p); + setup_free(p,p); +} + +static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z) +{ + memset(p, 0, sizeof(*p)); // NULL out all malloc'd pointers to start + if (z) { + p->alloc = *z; + p->alloc.alloc_buffer_length_in_bytes = (p->alloc.alloc_buffer_length_in_bytes+3) & ~3; + p->temp_offset = p->alloc.alloc_buffer_length_in_bytes; + } + p->eof = 0; + p->error = VORBIS__no_error; + p->stream = NULL; + p->codebooks = NULL; + p->page_crc_tests = -1; + #ifndef STB_VORBIS_NO_STDIO + p->close_on_free = FALSE; + p->f = NULL; + #endif +} + +int stb_vorbis_get_sample_offset(stb_vorbis *f) +{ + if (f->current_loc_valid) + return f->current_loc; + else + return -1; +} + +stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f) +{ + stb_vorbis_info d; + d.channels = f->channels; + d.sample_rate = f->sample_rate; + d.setup_memory_required = f->setup_memory_required; + d.setup_temp_memory_required = f->setup_temp_memory_required; + d.temp_memory_required = f->temp_memory_required; + d.max_frame_size = f->blocksize_1 >> 1; + return d; +} + +int stb_vorbis_get_error(stb_vorbis *f) +{ + int e = f->error; + f->error = VORBIS__no_error; + return e; +} + +static stb_vorbis * vorbis_alloc(stb_vorbis *f) +{ + stb_vorbis *p = (stb_vorbis *) setup_malloc(f, sizeof(*p)); + return p; +} + +#ifndef STB_VORBIS_NO_PUSHDATA_API + +void stb_vorbis_flush_pushdata(stb_vorbis *f) +{ + f->previous_length = 0; + f->page_crc_tests = 0; + f->discard_samples_deferred = 0; + f->current_loc_valid = FALSE; + f->first_decode = FALSE; + f->samples_output = 0; + f->channel_buffer_start = 0; + f->channel_buffer_end = 0; +} + +static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len) +{ + int i,n; + for (i=0; i < f->page_crc_tests; ++i) + f->scan[i].bytes_done = 0; + + // if we have room for more scans, search for them first, because + // they may cause us to stop early if their header is incomplete + if (f->page_crc_tests < STB_VORBIS_PUSHDATA_CRC_COUNT) { + if (data_len < 4) return 0; + data_len -= 3; // need to look for 4-byte sequence, so don't miss + // one that straddles a boundary + for (i=0; i < data_len; ++i) { + if (data[i] == 0x4f) { + if (0==memcmp(data+i, ogg_page_header, 4)) { + int j,len; + uint32 crc; + // make sure we have the whole page header + if (i+26 >= data_len || i+27+data[i+26] >= data_len) { + // only read up to this page start, so hopefully we'll + // have the whole page header start next time + data_len = i; + break; + } + // ok, we have it all; compute the length of the page + len = 27 + data[i+26]; + for (j=0; j < data[i+26]; ++j) + len += data[i+27+j]; + // scan everything up to the embedded crc (which we must 0) + crc = 0; + for (j=0; j < 22; ++j) + crc = crc32_update(crc, data[i+j]); + // now process 4 0-bytes + for ( ; j < 26; ++j) + crc = crc32_update(crc, 0); + // len is the total number of bytes we need to scan + n = f->page_crc_tests++; + f->scan[n].bytes_left = len-j; + f->scan[n].crc_so_far = crc; + f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24); + // if the last frame on a page is continued to the next, then + // we can't recover the sample_loc immediately + if (data[i+27+data[i+26]-1] == 255) + f->scan[n].sample_loc = ~0; + else + f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24); + f->scan[n].bytes_done = i+j; + if (f->page_crc_tests == STB_VORBIS_PUSHDATA_CRC_COUNT) + break; + // keep going if we still have room for more + } + } + } + } + + for (i=0; i < f->page_crc_tests;) { + uint32 crc; + int j; + int n = f->scan[i].bytes_done; + int m = f->scan[i].bytes_left; + if (m > data_len - n) m = data_len - n; + // m is the bytes to scan in the current chunk + crc = f->scan[i].crc_so_far; + for (j=0; j < m; ++j) + crc = crc32_update(crc, data[n+j]); + f->scan[i].bytes_left -= m; + f->scan[i].crc_so_far = crc; + if (f->scan[i].bytes_left == 0) { + // does it match? + if (f->scan[i].crc_so_far == f->scan[i].goal_crc) { + // Houston, we have page + data_len = n+m; // consumption amount is wherever that scan ended + f->page_crc_tests = -1; // drop out of page scan mode + f->previous_length = 0; // decode-but-don't-output one frame + f->next_seg = -1; // start a new page + f->current_loc = f->scan[i].sample_loc; // set the current sample location + // to the amount we'd have decoded had we decoded this page + f->current_loc_valid = f->current_loc != ~0U; + return data_len; + } + // delete entry + f->scan[i] = f->scan[--f->page_crc_tests]; + } else { + ++i; + } + } + + return data_len; +} + +// return value: number of bytes we used +int stb_vorbis_decode_frame_pushdata( + stb_vorbis *f, // the file we're decoding + const uint8 *data, int data_len, // the memory available for decoding + int *channels, // place to write number of float * buffers + float ***output, // place to write float ** array of float * buffers + int *samples // place to write number of output samples + ) +{ + int i; + int len,right,left; + + if (!IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + if (f->page_crc_tests >= 0) { + *samples = 0; + return vorbis_search_for_page_pushdata(f, (uint8 *) data, data_len); + } + + f->stream = (uint8 *) data; + f->stream_end = (uint8 *) data + data_len; + f->error = VORBIS__no_error; + + // check that we have the entire packet in memory + if (!is_whole_packet_present(f, FALSE)) { + *samples = 0; + return 0; + } + + if (!vorbis_decode_packet(f, &len, &left, &right)) { + // save the actual error we encountered + enum STBVorbisError error = f->error; + if (error == VORBIS_bad_packet_type) { + // flush and resynch + f->error = VORBIS__no_error; + while (get8_packet(f) != EOP) + if (f->eof) break; + *samples = 0; + return (int) (f->stream - data); + } + if (error == VORBIS_continued_packet_flag_invalid) { + if (f->previous_length == 0) { + // we may be resynching, in which case it's ok to hit one + // of these; just discard the packet + f->error = VORBIS__no_error; + while (get8_packet(f) != EOP) + if (f->eof) break; + *samples = 0; + return (int) (f->stream - data); + } + } + // if we get an error while parsing, what to do? + // well, it DEFINITELY won't work to continue from where we are! + stb_vorbis_flush_pushdata(f); + // restore the error that actually made us bail + f->error = error; + *samples = 0; + return 1; + } + + // success! + len = vorbis_finish_frame(f, len, left, right); + for (i=0; i < f->channels; ++i) + f->outputs[i] = f->channel_buffers[i] + left; + + if (channels) *channels = f->channels; + *samples = len; + *output = f->outputs; + return (int) (f->stream - data); +} + +stb_vorbis *stb_vorbis_open_pushdata( + const unsigned char *data, int data_len, // the memory available for decoding + int *data_used, // only defined if result is not NULL + int *error, const stb_vorbis_alloc *alloc) +{ + stb_vorbis *f, p; + vorbis_init(&p, alloc); + p.stream = (uint8 *) data; + p.stream_end = (uint8 *) data + data_len; + p.push_mode = TRUE; + if (!start_decoder(&p)) { + if (p.eof) + *error = VORBIS_need_more_data; + else + *error = p.error; + return NULL; + } + f = vorbis_alloc(&p); + if (f) { + *f = p; + *data_used = (int) (f->stream - data); + *error = 0; + return f; + } else { + vorbis_deinit(&p); + return NULL; + } +} +#endif // STB_VORBIS_NO_PUSHDATA_API + +unsigned int stb_vorbis_get_file_offset(stb_vorbis *f) +{ + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (f->push_mode) return 0; + #endif + if (USE_MEMORY(f)) return (unsigned int) (f->stream - f->stream_start); + #ifndef STB_VORBIS_NO_STDIO + return (unsigned int) (ftell(f->f) - f->f_start); + #endif +} + +#ifndef STB_VORBIS_NO_PULLDATA_API +// +// DATA-PULLING API +// + +static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last) +{ + for(;;) { + int n; + if (f->eof) return 0; + n = get8(f); + if (n == 0x4f) { // page header candidate + unsigned int retry_loc = stb_vorbis_get_file_offset(f); + int i; + // check if we're off the end of a file_section stream + if (retry_loc - 25 > f->stream_len) + return 0; + // check the rest of the header + for (i=1; i < 4; ++i) + if (get8(f) != ogg_page_header[i]) + break; + if (f->eof) return 0; + if (i == 4) { + uint8 header[27]; + uint32 i, crc, goal, len; + for (i=0; i < 4; ++i) + header[i] = ogg_page_header[i]; + for (; i < 27; ++i) + header[i] = get8(f); + if (f->eof) return 0; + if (header[4] != 0) goto invalid; + goal = header[22] + (header[23] << 8) + (header[24]<<16) + (header[25]<<24); + for (i=22; i < 26; ++i) + header[i] = 0; + crc = 0; + for (i=0; i < 27; ++i) + crc = crc32_update(crc, header[i]); + len = 0; + for (i=0; i < header[26]; ++i) { + int s = get8(f); + crc = crc32_update(crc, s); + len += s; + } + if (len && f->eof) return 0; + for (i=0; i < len; ++i) + crc = crc32_update(crc, get8(f)); + // finished parsing probable page + if (crc == goal) { + // we could now check that it's either got the last + // page flag set, OR it's followed by the capture + // pattern, but I guess TECHNICALLY you could have + // a file with garbage between each ogg page and recover + // from it automatically? So even though that paranoia + // might decrease the chance of an invalid decode by + // another 2^32, not worth it since it would hose those + // invalid-but-useful files? + if (end) + *end = stb_vorbis_get_file_offset(f); + if (last) { + if (header[5] & 0x04) + *last = 1; + else + *last = 0; + } + set_file_offset(f, retry_loc-1); + return 1; + } + } + invalid: + // not a valid page, so rewind and look for next one + set_file_offset(f, retry_loc); + } + } +} + + +#define SAMPLE_unknown 0xffffffff + +// seeking is implemented with a binary search, which narrows down the range to +// 64K, before using a linear search (because finding the synchronization +// pattern can be expensive, and the chance we'd find the end page again is +// relatively high for small ranges) +// +// two initial interpolation-style probes are used at the start of the search +// to try to bound either side of the binary search sensibly, while still +// working in O(log n) time if they fail. + +static int get_seek_page_info(stb_vorbis *f, ProbedPage *z) +{ + uint8 header[27], lacing[255]; + int i,len; + + // record where the page starts + z->page_start = stb_vorbis_get_file_offset(f); + + // parse the header + getn(f, header, 27); + if (header[0] != 'O' || header[1] != 'g' || header[2] != 'g' || header[3] != 'S') + return 0; + getn(f, lacing, header[26]); + + // determine the length of the payload + len = 0; + for (i=0; i < header[26]; ++i) + len += lacing[i]; + + // this implies where the page ends + z->page_end = z->page_start + 27 + header[26] + len; + + // read the last-decoded sample out of the data + z->last_decoded_sample = header[6] + (header[7] << 8) + (header[8] << 16) + (header[9] << 24); + + // restore file state to where we were + set_file_offset(f, z->page_start); + return 1; +} + +// rarely used function to seek back to the preceeding page while finding the +// start of a packet +static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset) +{ + unsigned int previous_safe, end; + + // now we want to seek back 64K from the limit + if (limit_offset >= 65536 && limit_offset-65536 >= f->first_audio_page_offset) + previous_safe = limit_offset - 65536; + else + previous_safe = f->first_audio_page_offset; + + set_file_offset(f, previous_safe); + + while (vorbis_find_page(f, &end, NULL)) { + if (end >= limit_offset && stb_vorbis_get_file_offset(f) < limit_offset) + return 1; + set_file_offset(f, end); + } + + return 0; +} + +// implements the search logic for finding a page and starting decoding. if +// the function succeeds, current_loc_valid will be true and current_loc will +// be less than or equal to the provided sample number (the closer the +// better). +static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number) +{ + ProbedPage left, right, mid; + int i, start_seg_with_known_loc, end_pos, page_start; + uint32 delta, stream_length, padding; + double offset, bytes_per_sample; + int probe = 0; + + // find the last page and validate the target sample + stream_length = stb_vorbis_stream_length_in_samples(f); + if (stream_length == 0) return error(f, VORBIS_seek_without_length); + if (sample_number > stream_length) return error(f, VORBIS_seek_invalid); + + // this is the maximum difference between the window-center (which is the + // actual granule position value), and the right-start (which the spec + // indicates should be the granule position (give or take one)). + padding = ((f->blocksize_1 - f->blocksize_0) >> 2); + if (sample_number < padding) + sample_number = 0; + else + sample_number -= padding; + + left = f->p_first; + while (left.last_decoded_sample == ~0U) { + // (untested) the first page does not have a 'last_decoded_sample' + set_file_offset(f, left.page_end); + if (!get_seek_page_info(f, &left)) goto error; + } + + right = f->p_last; + assert(right.last_decoded_sample != ~0U); + + // starting from the start is handled differently + if (sample_number <= left.last_decoded_sample) { + if (stb_vorbis_seek_start(f)) + return 1; + return 0; + } + + while (left.page_end != right.page_start) { + assert(left.page_end < right.page_start); + // search range in bytes + delta = right.page_start - left.page_end; + if (delta <= 65536) { + // there's only 64K left to search - handle it linearly + set_file_offset(f, left.page_end); + } else { + if (probe < 2) { + if (probe == 0) { + // first probe (interpolate) + double data_bytes = right.page_end - left.page_start; + bytes_per_sample = data_bytes / right.last_decoded_sample; + offset = left.page_start + bytes_per_sample * (sample_number - left.last_decoded_sample); + } else { + // second probe (try to bound the other side) + double error = ((double) sample_number - mid.last_decoded_sample) * bytes_per_sample; + if (error >= 0 && error < 8000) error = 8000; + if (error < 0 && error > -8000) error = -8000; + offset += error * 2; + } + + // ensure the offset is valid + if (offset < left.page_end) + offset = left.page_end; + if (offset > right.page_start - 65536) + offset = right.page_start - 65536; + + set_file_offset(f, (unsigned int) offset); + } else { + // binary search for large ranges (offset by 32K to ensure + // we don't hit the right page) + set_file_offset(f, left.page_end + (delta / 2) - 32768); + } + + if (!vorbis_find_page(f, NULL, NULL)) goto error; + } + + for (;;) { + if (!get_seek_page_info(f, &mid)) goto error; + if (mid.last_decoded_sample != ~0U) break; + // (untested) no frames end on this page + set_file_offset(f, mid.page_end); + assert(mid.page_start < right.page_start); + } + + // if we've just found the last page again then we're in a tricky file, + // and we're close enough. + if (mid.page_start == right.page_start) + break; + + if (sample_number < mid.last_decoded_sample) + right = mid; + else + left = mid; + + ++probe; + } + + // seek back to start of the last packet + page_start = left.page_start; + set_file_offset(f, page_start); + if (!start_page(f)) return error(f, VORBIS_seek_failed); + end_pos = f->end_seg_with_known_loc; + assert(end_pos >= 0); + + for (;;) { + for (i = end_pos; i > 0; --i) + if (f->segments[i-1] != 255) + break; + + start_seg_with_known_loc = i; + + if (start_seg_with_known_loc > 0 || !(f->page_flag & PAGEFLAG_continued_packet)) + break; + + // (untested) the final packet begins on an earlier page + if (!go_to_page_before(f, page_start)) + goto error; + + page_start = stb_vorbis_get_file_offset(f); + if (!start_page(f)) goto error; + end_pos = f->segment_count - 1; + } + + // prepare to start decoding + f->current_loc_valid = FALSE; + f->last_seg = FALSE; + f->valid_bits = 0; + f->packet_bytes = 0; + f->bytes_in_seg = 0; + f->previous_length = 0; + f->next_seg = start_seg_with_known_loc; + + for (i = 0; i < start_seg_with_known_loc; i++) + skip(f, f->segments[i]); + + // start decoding (optimizable - this frame is generally discarded) + if (!vorbis_pump_first_frame(f)) + return 0; + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + return 1; + +error: + // try to restore the file to a valid state + stb_vorbis_seek_start(f); + return error(f, VORBIS_seek_failed); +} + +// the same as vorbis_decode_initial, but without advancing +static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode) +{ + int bits_read, bytes_read; + + if (!vorbis_decode_initial(f, p_left_start, p_left_end, p_right_start, p_right_end, mode)) + return 0; + + // either 1 or 2 bytes were read, figure out which so we can rewind + bits_read = 1 + ilog(f->mode_count-1); + if (f->mode_config[*mode].blockflag) + bits_read += 2; + bytes_read = (bits_read + 7) / 8; + + f->bytes_in_seg += bytes_read; + f->packet_bytes -= bytes_read; + skip(f, -bytes_read); + if (f->next_seg == -1) + f->next_seg = f->segment_count - 1; + else + f->next_seg--; + f->valid_bits = 0; + + return 1; +} + +int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number) +{ + uint32 max_frame_samples; + + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + // fast page-level search + if (!seek_to_sample_coarse(f, sample_number)) + return 0; + + assert(f->current_loc_valid); + assert(f->current_loc <= sample_number); + + // linear search for the relevant packet + max_frame_samples = (f->blocksize_1*3 - f->blocksize_0) >> 2; + while (f->current_loc < sample_number) { + int left_start, left_end, right_start, right_end, mode, frame_samples; + if (!peek_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode)) + return error(f, VORBIS_seek_failed); + // calculate the number of samples returned by the next frame + frame_samples = right_start - left_start; + if (f->current_loc + frame_samples > sample_number) { + return 1; // the next frame will contain the sample + } else if (f->current_loc + frame_samples + max_frame_samples > sample_number) { + // there's a chance the frame after this could contain the sample + vorbis_pump_first_frame(f); + } else { + // this frame is too early to be relevant + f->current_loc += frame_samples; + f->previous_length = 0; + maybe_start_packet(f); + flush_packet(f); + } + } + // the next frame will start with the sample + assert(f->current_loc == sample_number); + return 1; +} + +int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number) +{ + if (!stb_vorbis_seek_frame(f, sample_number)) + return 0; + + if (sample_number != f->current_loc) { + int n; + uint32 frame_start = f->current_loc; + stb_vorbis_get_frame_float(f, &n, NULL); + assert(sample_number > frame_start); + assert(f->channel_buffer_start + (int) (sample_number-frame_start) <= f->channel_buffer_end); + f->channel_buffer_start += (sample_number - frame_start); + } + + return 1; +} + +int stb_vorbis_seek_start(stb_vorbis *f) +{ + if (IS_PUSH_MODE(f)) { return error(f, VORBIS_invalid_api_mixing); } + set_file_offset(f, f->first_audio_page_offset); + f->previous_length = 0; + f->first_decode = TRUE; + f->next_seg = -1; + return vorbis_pump_first_frame(f); +} + +unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f) +{ + unsigned int restore_offset, previous_safe; + unsigned int end, last_page_loc; + + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + if (!f->total_samples) { + unsigned int last; + uint32 lo,hi; + char header[6]; + + // first, store the current decode position so we can restore it + restore_offset = stb_vorbis_get_file_offset(f); + + // now we want to seek back 64K from the end (the last page must + // be at most a little less than 64K, but let's allow a little slop) + if (f->stream_len >= 65536 && f->stream_len-65536 >= f->first_audio_page_offset) + previous_safe = f->stream_len - 65536; + else + previous_safe = f->first_audio_page_offset; + + set_file_offset(f, previous_safe); + // previous_safe is now our candidate 'earliest known place that seeking + // to will lead to the final page' + + if (!vorbis_find_page(f, &end, &last)) { + // if we can't find a page, we're hosed! + f->error = VORBIS_cant_find_last_page; + f->total_samples = 0xffffffff; + goto done; + } + + // check if there are more pages + last_page_loc = stb_vorbis_get_file_offset(f); + + // stop when the last_page flag is set, not when we reach eof; + // this allows us to stop short of a 'file_section' end without + // explicitly checking the length of the section + while (!last) { + set_file_offset(f, end); + if (!vorbis_find_page(f, &end, &last)) { + // the last page we found didn't have the 'last page' flag + // set. whoops! + break; + } + previous_safe = last_page_loc+1; + last_page_loc = stb_vorbis_get_file_offset(f); + } + + set_file_offset(f, last_page_loc); + + // parse the header + getn(f, (unsigned char *)header, 6); + // extract the absolute granule position + lo = get32(f); + hi = get32(f); + if (lo == 0xffffffff && hi == 0xffffffff) { + f->error = VORBIS_cant_find_last_page; + f->total_samples = SAMPLE_unknown; + goto done; + } + if (hi) + lo = 0xfffffffe; // saturate + f->total_samples = lo; + + f->p_last.page_start = last_page_loc; + f->p_last.page_end = end; + f->p_last.last_decoded_sample = lo; + + done: + set_file_offset(f, restore_offset); + } + return f->total_samples == SAMPLE_unknown ? 0 : f->total_samples; +} + +float stb_vorbis_stream_length_in_seconds(stb_vorbis *f) +{ + return stb_vorbis_stream_length_in_samples(f) / (float) f->sample_rate; +} + + + +int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output) +{ + int len, right,left,i; + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + if (!vorbis_decode_packet(f, &len, &left, &right)) { + f->channel_buffer_start = f->channel_buffer_end = 0; + return 0; + } + + len = vorbis_finish_frame(f, len, left, right); + for (i=0; i < f->channels; ++i) + f->outputs[i] = f->channel_buffers[i] + left; + + f->channel_buffer_start = left; + f->channel_buffer_end = left+len; + + if (channels) *channels = f->channels; + if (output) *output = f->outputs; + return len; +} + +#ifndef STB_VORBIS_NO_STDIO + +stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length) +{ + stb_vorbis *f, p; + vorbis_init(&p, alloc); + p.f = file; + p.f_start = (uint32) ftell(file); + p.stream_len = length; + p.close_on_free = close_on_free; + if (start_decoder(&p)) { + f = vorbis_alloc(&p); + if (f) { + *f = p; + vorbis_pump_first_frame(f); + return f; + } + } + if (error) *error = p.error; + vorbis_deinit(&p); + return NULL; +} + +stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc) +{ + unsigned int len, start; + start = (unsigned int) ftell(file); + fseek(file, 0, SEEK_END); + len = (unsigned int) (ftell(file) - start); + fseek(file, start, SEEK_SET); + return stb_vorbis_open_file_section(file, close_on_free, error, alloc, len); +} + +stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc) +{ + FILE *f = fopen(filename, "rb"); + if (f) + return stb_vorbis_open_file(f, TRUE, error, alloc); + if (error) *error = VORBIS_file_open_failure; + return NULL; +} +#endif // STB_VORBIS_NO_STDIO + +stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc) +{ + stb_vorbis *f, p; + if (data == NULL) return NULL; + vorbis_init(&p, alloc); + p.stream = (uint8 *) data; + p.stream_end = (uint8 *) data + len; + p.stream_start = (uint8 *) p.stream; + p.stream_len = len; + p.push_mode = FALSE; + if (start_decoder(&p)) { + f = vorbis_alloc(&p); + if (f) { + *f = p; + vorbis_pump_first_frame(f); + if (error) *error = VORBIS__no_error; + return f; + } + } + if (error) *error = p.error; + vorbis_deinit(&p); + return NULL; +} + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +#define PLAYBACK_MONO 1 +#define PLAYBACK_LEFT 2 +#define PLAYBACK_RIGHT 4 + +#define L (PLAYBACK_LEFT | PLAYBACK_MONO) +#define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO) +#define R (PLAYBACK_RIGHT | PLAYBACK_MONO) + +static int8 channel_position[7][6] = +{ + { 0 }, + { C }, + { L, R }, + { L, C, R }, + { L, R, L, R }, + { L, C, R, L, R }, + { L, C, R, L, R, C }, +}; + + +#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT + typedef union { + float f; + int i; + } float_conv; + typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4]; + #define FASTDEF(x) float_conv x + // add (1<<23) to convert to int, then divide by 2^SHIFT, then add 0.5/2^SHIFT to round + #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT)) + #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22)) + #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s)) + #define check_endianness() +#else + #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s)))) + #define check_endianness() + #define FASTDEF(x) +#endif + +static void copy_samples(short *dest, float *src, int len) +{ + int i; + check_endianness(); + for (i=0; i < len; ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp, src[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + dest[i] = v; + } +} + +static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len) +{ + #define BUFFER_SIZE 32 + float buffer[BUFFER_SIZE]; + int i,j,o,n = BUFFER_SIZE; + check_endianness(); + for (o = 0; o < len; o += BUFFER_SIZE) { + memset(buffer, 0, sizeof(buffer)); + if (o + n > len) n = len - o; + for (j=0; j < num_c; ++j) { + if (channel_position[num_c][j] & mask) { + for (i=0; i < n; ++i) + buffer[i] += data[j][d_offset+o+i]; + } + } + for (i=0; i < n; ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + output[o+i] = v; + } + } +} + +static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len) +{ + #define BUFFER_SIZE 32 + float buffer[BUFFER_SIZE]; + int i,j,o,n = BUFFER_SIZE >> 1; + // o is the offset in the source data + check_endianness(); + for (o = 0; o < len; o += BUFFER_SIZE >> 1) { + // o2 is the offset in the output data + int o2 = o << 1; + memset(buffer, 0, sizeof(buffer)); + if (o + n > len) n = len - o; + for (j=0; j < num_c; ++j) { + int m = channel_position[num_c][j] & (PLAYBACK_LEFT | PLAYBACK_RIGHT); + if (m == (PLAYBACK_LEFT | PLAYBACK_RIGHT)) { + for (i=0; i < n; ++i) { + buffer[i*2+0] += data[j][d_offset+o+i]; + buffer[i*2+1] += data[j][d_offset+o+i]; + } + } else if (m == PLAYBACK_LEFT) { + for (i=0; i < n; ++i) { + buffer[i*2+0] += data[j][d_offset+o+i]; + } + } else if (m == PLAYBACK_RIGHT) { + for (i=0; i < n; ++i) { + buffer[i*2+1] += data[j][d_offset+o+i]; + } + } + } + for (i=0; i < (n<<1); ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + output[o2+i] = v; + } + } +} + +static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples) +{ + int i; + if (buf_c != data_c && buf_c <= 2 && data_c <= 6) { + static int channel_selector[3][2] = { {0}, {PLAYBACK_MONO}, {PLAYBACK_LEFT, PLAYBACK_RIGHT} }; + for (i=0; i < buf_c; ++i) + compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples); + } else { + int limit = buf_c < data_c ? buf_c : data_c; + for (i=0; i < limit; ++i) + copy_samples(buffer[i]+b_offset, data[i]+d_offset, samples); + for ( ; i < buf_c; ++i) + memset(buffer[i]+b_offset, 0, sizeof(short) * samples); + } +} + +int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples) +{ + float **output; + int len = stb_vorbis_get_frame_float(f, NULL, &output); + if (len > num_samples) len = num_samples; + if (len) + convert_samples_short(num_c, buffer, 0, f->channels, output, 0, len); + return len; +} + +static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len) +{ + int i; + check_endianness(); + if (buf_c != data_c && buf_c <= 2 && data_c <= 6) { + assert(buf_c == 2); + for (i=0; i < buf_c; ++i) + compute_stereo_samples(buffer, data_c, data, d_offset, len); + } else { + int limit = buf_c < data_c ? buf_c : data_c; + int j; + for (j=0; j < len; ++j) { + for (i=0; i < limit; ++i) { + FASTDEF(temp); + float f = data[i][d_offset+j]; + int v = FAST_SCALED_FLOAT_TO_INT(temp, f,15);//data[i][d_offset+j],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + *buffer++ = v; + } + for ( ; i < buf_c; ++i) + *buffer++ = 0; + } + } +} + +int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts) +{ + float **output; + int len; + if (num_c == 1) return stb_vorbis_get_frame_short(f,num_c,&buffer, num_shorts); + len = stb_vorbis_get_frame_float(f, NULL, &output); + if (len) { + if (len*num_c > num_shorts) len = num_shorts / num_c; + convert_channels_short_interleaved(num_c, buffer, f->channels, output, 0, len); + } + return len; +} + +int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts) +{ + float **outputs; + int len = num_shorts / channels; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + if (k) + convert_channels_short_interleaved(channels, buffer, f->channels, f->channel_buffers, f->channel_buffer_start, k); + buffer += k*channels; + n += k; + f->channel_buffer_start += k; + if (n == len) break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break; + } + return n; +} + +int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len) +{ + float **outputs; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + if (k) + convert_samples_short(channels, buffer, n, f->channels, f->channel_buffers, f->channel_buffer_start, k); + n += k; + f->channel_buffer_start += k; + if (n == len) break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break; + } + return n; +} + +#ifndef STB_VORBIS_NO_STDIO +int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output) +{ + int data_len, offset, total, limit, error; + short *data; + stb_vorbis *v = stb_vorbis_open_filename(filename, &error, NULL); + if (v == NULL) return -1; + limit = v->channels * 4096; + *channels = v->channels; + if (sample_rate) + *sample_rate = v->sample_rate; + offset = data_len = 0; + total = limit; + data = (short *) malloc(total * sizeof(*data)); + if (data == NULL) { + stb_vorbis_close(v); + return -2; + } + for (;;) { + int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset); + if (n == 0) break; + data_len += n; + offset += n * v->channels; + if (offset + limit > total) { + short *data2; + total *= 2; + data2 = (short *) realloc(data, total * sizeof(*data)); + if (data2 == NULL) { + free(data); + stb_vorbis_close(v); + return -2; + } + data = data2; + } + } + *output = data; + stb_vorbis_close(v); + return data_len; +} +#endif // NO_STDIO + +int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output) +{ + int data_len, offset, total, limit, error; + short *data; + stb_vorbis *v = stb_vorbis_open_memory(mem, len, &error, NULL); + if (v == NULL) return -1; + limit = v->channels * 4096; + *channels = v->channels; + if (sample_rate) + *sample_rate = v->sample_rate; + offset = data_len = 0; + total = limit; + data = (short *) malloc(total * sizeof(*data)); + if (data == NULL) { + stb_vorbis_close(v); + return -2; + } + for (;;) { + int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset); + if (n == 0) break; + data_len += n; + offset += n * v->channels; + if (offset + limit > total) { + short *data2; + total *= 2; + data2 = (short *) realloc(data, total * sizeof(*data)); + if (data2 == NULL) { + free(data); + stb_vorbis_close(v); + return -2; + } + data = data2; + } + } + *output = data; + stb_vorbis_close(v); + return data_len; +} +#endif // STB_VORBIS_NO_INTEGER_CONVERSION + +int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats) +{ + float **outputs; + int len = num_floats / channels; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int i,j; + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + for (j=0; j < k; ++j) { + for (i=0; i < z; ++i) + *buffer++ = f->channel_buffers[i][f->channel_buffer_start+j]; + for ( ; i < channels; ++i) + *buffer++ = 0; + } + n += k; + f->channel_buffer_start += k; + if (n == len) + break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) + break; + } + return n; +} + +int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples) +{ + float **outputs; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < num_samples) { + int i; + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= num_samples) k = num_samples - n; + if (k) { + for (i=0; i < z; ++i) + memcpy(buffer[i]+n, f->channel_buffers[i]+f->channel_buffer_start, sizeof(float)*k); + for ( ; i < channels; ++i) + memset(buffer[i]+n, 0, sizeof(float) * k); + } + n += k; + f->channel_buffer_start += k; + if (n == num_samples) + break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) + break; + } + return n; +} +#endif // STB_VORBIS_NO_PULLDATA_API + +/* Version history + 1.12 - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files + 1.11 - 2017-07-23 - fix MinGW compilation + 1.10 - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory + 1.09 - 2016-04-04 - back out 'avoid discarding last frame' fix from previous version + 1.08 - 2016-04-02 - fixed multiple warnings; fix setup memory leaks; + avoid discarding last frame of audio data + 1.07 - 2015-01-16 - fixed some warnings, fix mingw, const-correct API + some more crash fixes when out of memory or with corrupt files + 1.06 - 2015-08-31 - full, correct support for seeking API (Dougall Johnson) + some crash fixes when out of memory or with corrupt files + 1.05 - 2015-04-19 - don't define __forceinline if it's redundant + 1.04 - 2014-08-27 - fix missing const-correct case in API + 1.03 - 2014-08-07 - Warning fixes + 1.02 - 2014-07-09 - Declare qsort compare function _cdecl on windows + 1.01 - 2014-06-18 - fix stb_vorbis_get_samples_float + 1.0 - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in multichannel + (API change) report sample rate for decode-full-file funcs + 0.99996 - bracket #include for macintosh compilation by Laurent Gomila + 0.99995 - use union instead of pointer-cast for fast-float-to-int to avoid alias-optimization problem + 0.99994 - change fast-float-to-int to work in single-precision FPU mode, remove endian-dependence + 0.99993 - remove assert that fired on legal files with empty tables + 0.99992 - rewind-to-start + 0.99991 - bugfix to stb_vorbis_get_samples_short by Bernhard Wodo + 0.9999 - (should have been 0.99990) fix no-CRT support, compiling as C++ + 0.9998 - add a full-decode function with a memory source + 0.9997 - fix a bug in the read-from-FILE case in 0.9996 addition + 0.9996 - query length of vorbis stream in samples/seconds + 0.9995 - bugfix to another optimization that only happened in certain files + 0.9994 - bugfix to one of the optimizations that caused significant (but inaudible?) errors + 0.9993 - performance improvements; runs in 99% to 104% of time of reference implementation + 0.9992 - performance improvement of IMDCT; now performs close to reference implementation + 0.9991 - performance improvement of IMDCT + 0.999 - (should have been 0.9990) performance improvement of IMDCT + 0.998 - no-CRT support from Casey Muratori + 0.997 - bugfixes for bugs found by Terje Mathisen + 0.996 - bugfix: fast-huffman decode initialized incorrectly for sparse codebooks; fixing gives 10% speedup - found by Terje Mathisen + 0.995 - bugfix: fix to 'effective' overrun detection - found by Terje Mathisen + 0.994 - bugfix: garbage decode on final VQ symbol of a non-multiple - found by Terje Mathisen + 0.993 - bugfix: pushdata API required 1 extra byte for empty page (failed to consume final page if empty) - found by Terje Mathisen + 0.992 - fixes for MinGW warning + 0.991 - turn fast-float-conversion on by default + 0.990 - fix push-mode seek recovery if you seek into the headers + 0.98b - fix to bad release of 0.98 + 0.98 - fix push-mode seek recovery; robustify float-to-int and support non-fast mode + 0.97 - builds under c++ (typecasting, don't use 'class' keyword) + 0.96 - somehow MY 0.95 was right, but the web one was wrong, so here's my 0.95 rereleased as 0.96, fixes a typo in the clamping code + 0.95 - clamping code for 16-bit functions + 0.94 - not publically released + 0.93 - fixed all-zero-floor case (was decoding garbage) + 0.92 - fixed a memory leak + 0.91 - conditional compiles to omit parts of the API and the infrastructure to support them: STB_VORBIS_NO_PULLDATA_API, STB_VORBIS_NO_PUSHDATA_API, STB_VORBIS_NO_STDIO, STB_VORBIS_NO_INTEGER_CONVERSION + 0.90 - first public release +*/ + +#endif // STB_VORBIS_HEADER_ONLY + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/audio/vorbis/internal/stb/stbvorbis.js b/audio/vorbis/internal/stb/stbvorbis.js new file mode 100644 index 000000000..05f741aff --- /dev/null +++ b/audio/vorbis/internal/stb/stbvorbis.js @@ -0,0 +1,2042 @@ +// 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) +// {{PRE_JSES}} + +// 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]; + } +} + +Module['arguments'] = []; +Module['thisProgram'] = './this.program'; +Module['quit'] = function(status, toThrow) { + throw toThrow; +}; +Module['preRun'] = []; +Module['postRun'] = []; + +// The environment setup code below is customized to use Module. +// *** Environment setup code *** +var ENVIRONMENT_IS_WEB = false; +var ENVIRONMENT_IS_WORKER = false; +var ENVIRONMENT_IS_NODE = false; +var ENVIRONMENT_IS_SHELL = false; + +// Three configurations we can be running in: +// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false) +// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false) +// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true) + +if (Module['ENVIRONMENT']) { + if (Module['ENVIRONMENT'] === 'WEB') { + ENVIRONMENT_IS_WEB = true; + } else if (Module['ENVIRONMENT'] === 'WORKER') { + ENVIRONMENT_IS_WORKER = true; + } else if (Module['ENVIRONMENT'] === 'NODE') { + ENVIRONMENT_IS_NODE = true; + } else if (Module['ENVIRONMENT'] === 'SHELL') { + ENVIRONMENT_IS_SHELL = true; + } else { + throw new Error('Module[\'ENVIRONMENT\'] value is not valid. must be one of: WEB|WORKER|NODE|SHELL.'); + } +} else { + ENVIRONMENT_IS_WEB = typeof window === 'object'; + ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'; + ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER; + ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; +} + + +if (ENVIRONMENT_IS_NODE) { + // Expose functionality in the same simple way that the shells work + // Note that we pollute the global namespace here, otherwise we break in node + var nodeFS; + var nodePath; + + Module['read'] = function shell_read(filename, binary) { + var ret; + if (!nodeFS) nodeFS = require('fs'); + if (!nodePath) nodePath = require('path'); + filename = nodePath['normalize'](filename); + ret = nodeFS['readFileSync'](filename); + return binary ? ret : ret.toString(); + }; + + Module['readBinary'] = function readBinary(filename) { + var ret = Module['read'](filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + + if (process['argv'].length > 1) { + Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/'); + } + + Module['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; + } + }); + // Currently node will swallow unhandled rejections, but this behavior is + // deprecated, and in the future it will exit with error status. + process['on']('unhandledRejection', function(reason, p) { + process['exit'](1); + }); + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; +} else +if (ENVIRONMENT_IS_SHELL) { + if (typeof read != 'undefined') { + Module['read'] = function shell_read(f) { + return read(f); + }; + } + + Module['readBinary'] = function readBinary(f) { + var data; + if (typeof readbuffer === 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data === 'object'); + return data; + }; + + if (typeof scriptArgs != 'undefined') { + Module['arguments'] = scriptArgs; + } else if (typeof arguments != 'undefined') { + Module['arguments'] = arguments; + } + + if (typeof quit === 'function') { + Module['quit'] = function(status, toThrow) { + quit(status); + } + } +} else +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + Module['read'] = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + Module['readBinary'] = function readBinary(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + + Module['readAsync'] = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + + Module['setWindowTitle'] = function(title) { document.title = title }; +} else +{ + throw new Error('not compiled for this environment'); +} + +// console.log is checked first, as 'print' on the web will open a print dialogue +// printErr is preferable to console.warn (works better in shells) +// bind(console) is necessary to fix IE/Edge closed dev tools panel behavior. +Module['print'] = typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null); +Module['printErr'] = typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || Module['print']); + +// *** Environment setup code *** + +// Closure helpers +Module.print = Module['print']; +Module.printErr = Module['printErr']; + +// 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 = undefined; + + + +// {{PREAMBLE_ADDITIONS}} + +var STACK_ALIGN = 16; + + +function staticAlloc(size) { + assert(!staticSealed); + var ret = STATICTOP; + STATICTOP = (STATICTOP + size + 15) & -16; + return ret; +} + +function dynamicAlloc(size) { + assert(DYNAMICTOP_PTR); + var ret = HEAP32[DYNAMICTOP_PTR>>2]; + var end = (ret + size + 15) & -16; + HEAP32[DYNAMICTOP_PTR>>2] = end; + if (end >= TOTAL_MEMORY) { + var success = enlargeMemory(); + if (!success) { + HEAP32[DYNAMICTOP_PTR>>2] = ret; + return 0; + } + } + return ret; +} + +function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default + var ret = size = Math.ceil(size / factor) * factor; + return ret; +} + +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 = parseInt(type.substr(1)); + assert(bits % 8 === 0); + return bits / 8; + } else { + return 0; + } + } + } +} + +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + Module.printErr(text); + } +} + +var asm2wasmImports = { // special asm2wasm imports + "f64-rem": function(x, y) { + return x % y; + }, + "debugger": function() { + debugger; + } +}; + + + +var jsCallStartIndex = 1; +var functionPointers = new Array(0); + +// 'sig' parameter is only used on LLVM wasm backend +function addFunction(func, sig) { + var base = 0; + for (var i = base; i < base + 0; i++) { + if (!functionPointers[i]) { + functionPointers[i] = func; + return jsCallStartIndex + i; + } + } + throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; +} + +function removeFunction(index) { + functionPointers[index-jsCallStartIndex] = null; +} + +var funcWrappers = {}; + +function getFuncWrapper(func, sig) { + if (!func) return; // on null pointer, return undefined + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + // optimize away arguments usage in common cases + if (sig.length === 1) { + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func); + }; + } else if (sig.length === 2) { + sigCache[func] = function dynCall_wrapper(arg) { + return dynCall(sig, func, [arg]); + }; + } else { + // general case + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func, Array.prototype.slice.call(arguments)); + }; + } + } + return sigCache[func]; +} + + +function makeBigInt(low, high, unsigned) { + return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); +} + +function dynCall(sig, ptr, args) { + if (args && args.length) { + return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); + } else { + return Module['dynCall_' + sig].call(null, ptr); + } +} + + + +var Runtime = { + // FIXME backwards compatibility layer for ports. Support some Runtime.* + // for now, fix it there, then remove it from here. That way we + // can minimize any period of breakage. + dynCall: dynCall, // for SDL2 port +}; + +// The address globals begin at. Very low in memory, for code size and optimization opportunities. +// Above 0 is static memory, starting with globals. +// Then the stack. +// Then 'dynamic' memory for sbrk. +var GLOBAL_BASE = 1024; + + +// === 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 + + + +//======================================== +// Runtime essentials +//======================================== + +var ABORT = 0; // whether we are quitting the application. no code should run after this. set in exit() and abort() +var EXITSTATUS = 0; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +var globalScope = this; + +// 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; +} + +var JSfuncs = { + // Helpers for cwrap -- it can't refer to Runtime directly because it might + // be renamed by closure, instead it calls JSfuncs['stackSave'].body to find + // out what the minified function name is. + 'stackSave': function() { + stackSave() + }, + 'stackRestore': function() { + stackRestore() + }, + // type conversion from js to c + 'arrayToC' : function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + }, + 'stringToC' : 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; + } +}; + +// For fast lookup of conversion functions +var toC = { + 'string': JSfuncs['stringToC'], 'array': JSfuncs['arrayToC'] +}; + +// C calling interface. +function ccall (ident, returnType, argTypes, args, opts) { + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + if (returnType === 'string') ret = Pointer_stringify(ret); + else if (returnType === 'boolean') ret = Boolean(ret); + if (stack !== 0) { + stackRestore(stack); + } + return ret; +} + +function cwrap (ident, returnType, argTypes) { + argTypes = argTypes || []; + var cfunc = getCFunc(ident); + // 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) { + return cfunc; + } + return function() { + return ccall(ident, returnType, argTypes, arguments); + } +} + +/** @type {function(number, number, string, boolean=)} */ +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); + } +} + +/** @type {function(number, string, boolean=)} */ +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; +} + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_STATIC = 2; // Cannot be freed +var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk +var ALLOC_NONE = 4; // Do not allocate + +// 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, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((TypedArray|Array|number), string, number, number=)} */ +function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr; + } else { + ret = [typeof _malloc === 'function' ? _malloc : staticAlloc, stackAlloc, staticAlloc, dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length)); + } + + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[((ptr)>>2)]=0; + } + stop = ret + size; + while (ptr < stop) { + HEAP8[((ptr++)>>0)]=0; + } + return ret; + } + + if (singleType === 'i8') { + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; + } + + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + + // no need to look up size unless type changes, so cache it + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + + return ret; +} + +// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready +function getMemory(size) { + if (!staticSealed) return staticAlloc(size); + if (!runtimeInitialized) return dynamicAlloc(size); + return _malloc(size); +} + +/** @type {function(number, number=)} */ +function Pointer_stringify(ptr, length) { + if (length === 0 || !ptr) return ''; + // Find the length, and check for UTF while doing so + var hasUtf = 0; + var t; + var i = 0; + while (1) { + t = HEAPU8[(((ptr)+(i))>>0)]; + hasUtf |= t; + if (t == 0 && !length) break; + i++; + if (length && i == length) break; + } + if (!length) length = i; + + var ret = ''; + + if (hasUtf < 128) { + var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack + var curr; + while (length > 0) { + curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK))); + ret = ret ? ret + curr : curr; + ptr += MAX_CHUNK; + length -= MAX_CHUNK; + } + return ret; + } + return UTF8ToString(ptr); +} + +// 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 = HEAP8[((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 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; +function UTF8ArrayToString(u8Array, idx) { + 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. + while (u8Array[endPtr]) ++endPtr; + + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); + } else { + var u0, u1, u2, u3, u4, u5; + + var str = ''; + while (1) { + // 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 + u0 = u8Array[idx++]; + if (!u0) return str; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + u1 = u8Array[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + u2 = u8Array[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u3 = u8Array[idx++] & 63; + if ((u0 & 0xF8) == 0xF0) { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3; + } else { + u4 = u8Array[idx++] & 63; + if ((u0 & 0xFC) == 0xF8) { + u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4; + } else { + u5 = u8Array[idx++] & 63; + u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5; + } + } + } + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } +} + +// 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. + +function UTF8ToString(ptr) { + return UTF8ArrayToString(HEAPU8,ptr); +} + +// 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. +// outU8Array: 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, outU8Array, 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) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + outU8Array[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + outU8Array[outIdx++] = 0xC0 | (u >> 6); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + outU8Array[outIdx++] = 0xE0 | (u >> 12); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0x1FFFFF) { + if (outIdx + 3 >= endIdx) break; + outU8Array[outIdx++] = 0xF0 | (u >> 18); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0x3FFFFFF) { + if (outIdx + 4 >= endIdx) break; + outU8Array[outIdx++] = 0xF8 | (u >> 24); + outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 5 >= endIdx) break; + outU8Array[outIdx++] = 0xFC | (u >> 30); + outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + outU8Array[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 if (u <= 0x1FFFFF) { + len += 4; + } else if (u <= 0x3FFFFFF) { + len += 5; + } else { + len += 6; + } + } + return len; +} + +// 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) { + 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; + while (HEAP16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var i = 0; + + var str = ''; + while (1) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) return str; + ++i; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + } +} + +// 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) { + var i = 0; + + var str = ''; + while (1) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) + return str; + ++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); + } + } +} + +// 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; +} + +function demangle(func) { + return func; +} + +function demangleAll(text) { + var regex = + /__Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (x + ' [' + y + ']'); + }); +} + +function jsStackTrace() { + var err = new Error(); + if (!err.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(0); + } catch(e) { + err = e; + } + if (!err.stack) { + return '(no stack trace available)'; + } + } + return err.stack.toString(); +} + +function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); +} + +// Memory management + +var PAGE_SIZE = 16384; +var WASM_PAGE_SIZE = 65536; +var ASMJS_PAGE_SIZE = 16777216; +var MIN_TOTAL_MEMORY = 16777216; + +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 updateGlobalBuffer(buf) { + Module['buffer'] = buffer = buf; +} + +function updateGlobalBufferViews() { + Module['HEAP8'] = HEAP8 = new Int8Array(buffer); + Module['HEAP16'] = HEAP16 = new Int16Array(buffer); + Module['HEAP32'] = HEAP32 = new Int32Array(buffer); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer); +} + +var STATIC_BASE, STATICTOP, staticSealed; // static area +var STACK_BASE, STACKTOP, STACK_MAX; // stack area +var DYNAMIC_BASE, DYNAMICTOP_PTR; // dynamic area handled by sbrk + + STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0; + staticSealed = false; + + + +function abortOnCannotGrowMemory() { + abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 '); +} + +if (!Module['reallocBuffer']) Module['reallocBuffer'] = function(size) { + var ret; + try { + if (ArrayBuffer.transfer) { + ret = ArrayBuffer.transfer(buffer, size); + } else { + var oldHEAP8 = HEAP8; + ret = new ArrayBuffer(size); + var temp = new Int8Array(ret); + temp.set(oldHEAP8); + } + } catch(e) { + return false; + } + var success = _emscripten_replace_memory(ret); + if (!success) return false; + return ret; +}; + +function enlargeMemory() { + // TOTAL_MEMORY is the current size of the actual array, and DYNAMICTOP is the new top. + + + var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB. + var LIMIT = 2147483648 - PAGE_MULTIPLE; // We can do one page short of 2GB as theoretical maximum. + + if (HEAP32[DYNAMICTOP_PTR>>2] > LIMIT) { + return false; + } + + var OLD_TOTAL_MEMORY = TOTAL_MEMORY; + TOTAL_MEMORY = Math.max(TOTAL_MEMORY, MIN_TOTAL_MEMORY); // So the loop below will not be infinite, and minimum asm.js memory size is 16MB. + + while (TOTAL_MEMORY < HEAP32[DYNAMICTOP_PTR>>2]) { // Keep incrementing the heap size as long as it's less than what is requested. + if (TOTAL_MEMORY <= 536870912) { + TOTAL_MEMORY = alignUp(2 * TOTAL_MEMORY, PAGE_MULTIPLE); // Simple heuristic: double until 1GB... + } else { + // ..., but after that, add smaller increments towards 2GB, which we cannot reach + TOTAL_MEMORY = Math.min(alignUp((3 * TOTAL_MEMORY + 2147483648) / 4, PAGE_MULTIPLE), LIMIT); + } + } + + + var replacement = Module['reallocBuffer'](TOTAL_MEMORY); + if (!replacement || replacement.byteLength != TOTAL_MEMORY) { + // restore the state to before this call, we failed + TOTAL_MEMORY = OLD_TOTAL_MEMORY; + return false; + } + + // everything worked + + updateGlobalBuffer(replacement); + updateGlobalBufferViews(); + + + + return true; +} + +var byteLength; +try { + byteLength = Function.prototype.call.bind(Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get); + byteLength(new ArrayBuffer(4)); // can fail on older ie +} catch(e) { // can fail on older node/v8 + byteLength = function(buffer) { return buffer.byteLength; }; +} + +var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880; +var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216; +if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')'); + +// Initialize the runtime's memory + + + +// Use a provided buffer, if there is one, or else allocate a new one +if (Module['buffer']) { + buffer = Module['buffer']; +} else { + // Use a WebAssembly memory where available + if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') { + Module['wasmMemory'] = new WebAssembly.Memory({ 'initial': TOTAL_MEMORY / WASM_PAGE_SIZE }); + buffer = Module['wasmMemory'].buffer; + } else + { + buffer = new ArrayBuffer(TOTAL_MEMORY); + } + Module['buffer'] = buffer; +} +updateGlobalBufferViews(); + + +function getTotalMemory() { + return TOTAL_MEMORY; +} + +// Endianness check (note: assumes compiler arch was little-endian) + HEAP32[0] = 0x63736d65; /* 'emsc' */ +HEAP16[1] = 0x6373; +if (HEAPU8[2] !== 0x73 || HEAPU8[3] !== 0x63) throw 'Runtime error: expected the system to be little-endian!'; + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(); + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + Module['dynCall_v'](func); + } else { + Module['dynCall_vi'](func, callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } +} + +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; + + +function preRun() { + // compatibility - merge in anything from Module['preRun'] at this time + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} + +function ensureInitRuntime() { + if (runtimeInitialized) return; + runtimeInitialized = true; + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + callRuntimeCallbacks(__ATMAIN__); +} + +function exitRuntime() { + callRuntimeCallbacks(__ATEXIT__); + runtimeExited = true; +} + +function postRun() { + // compatibility - merge in anything from Module['postRun'] at this time + 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) { + __ATEXIT__.unshift(cb); +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// 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 */ +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); +} + +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; +} + +function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts + : Math.pow(2, bits) + value; +} +function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + + +var Math_abs = Math.abs; +var Math_cos = Math.cos; +var Math_sin = Math.sin; +var Math_tan = Math.tan; +var Math_acos = Math.acos; +var Math_asin = Math.asin; +var Math_atan = Math.atan; +var Math_atan2 = Math.atan2; +var Math_exp = Math.exp; +var Math_log = Math.log; +var Math_sqrt = Math.sqrt; +var Math_ceil = Math.ceil; +var Math_floor = Math.floor; +var Math_pow = Math.pow; +var Math_imul = Math.imul; +var Math_fround = Math.fround; +var Math_round = Math.round; +var Math_min = Math.min; +var Math_max = Math.max; +var Math_clz32 = Math.clz32; +var Math_trunc = Math.trunc; + +// 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 +// PRE_RUN_ADDITIONS (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 + + + +var memoryInitializer = null; + + + + + + +// 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 String.prototype.startsWith ? + filename.startsWith(dataURIPrefix) : + filename.indexOf(dataURIPrefix) === 0; +} + + + + +function integrateWasmJS() { + // wasm.js has several methods for creating the compiled code module here: + // * 'native-wasm' : use native WebAssembly support in the browser + // * 'interpret-s-expr': load s-expression code from a .wast and interpret + // * 'interpret-binary': load binary wasm and interpret + // * 'interpret-asm2wasm': load asm.js code, translate to wasm, and interpret + // * 'asmjs': no wasm, just load the asm.js code and use that (good for testing) + // The method is set at compile time (BINARYEN_METHOD) + // The method can be a comma-separated list, in which case, we will try the + // options one by one. Some of them can fail gracefully, and then we can try + // the next. + + // inputs + + var method = 'native-wasm'; + + var wasmTextFile = 'stbvorbis.wast'; + var wasmBinaryFile = 'stbvorbis.wasm'; + var asmjsCodeFile = 'stbvorbis.temp.asm.js'; + + if (typeof Module['locateFile'] === 'function') { + if (!isDataURI(wasmTextFile)) { + wasmTextFile = Module['locateFile'](wasmTextFile); + } + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = Module['locateFile'](wasmBinaryFile); + } + if (!isDataURI(asmjsCodeFile)) { + asmjsCodeFile = Module['locateFile'](asmjsCodeFile); + } + } + + // utilities + + var wasmPageSize = 64*1024; + + var info = { + 'global': null, + 'env': null, + 'asm2wasm': asm2wasmImports, + 'parent': Module // Module inside wasm-js.cpp refers to wasm-js.cpp; this allows access to the outside program. + }; + + var exports = null; + + + function mergeMemory(newBuffer) { + // The wasm instance creates its memory. But static init code might have written to + // buffer already, including the mem init file, and we must copy it over in a proper merge. + // TODO: avoid this copy, by avoiding such static init writes + // TODO: in shorter term, just copy up to the last static init write + var oldBuffer = Module['buffer']; + if (newBuffer.byteLength < oldBuffer.byteLength) { + Module['printErr']('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here'); + } + var oldView = new Int8Array(oldBuffer); + var newView = new Int8Array(newBuffer); + + + newView.set(oldView); + updateGlobalBuffer(newBuffer); + updateGlobalBufferViews(); + } + + function fixImports(imports) { + return imports; + } + + function getBinary() { + try { + if (Module['wasmBinary']) { + return new Uint8Array(Module['wasmBinary']); + } + if (Module['readBinary']) { + return Module['readBinary'](wasmBinaryFile); + } else { + throw "on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. 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, and have the Fetch api, use that + // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web + if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(); + }); + } + // Otherwise, getBinary should be able to get it synchronously + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); + } + + // do-method functions + + + function doNativeWasm(global, env, providedBuffer) { + if (typeof WebAssembly !== 'object') { + Module['printErr']('no native wasm support detected'); + return false; + } + // prepare memory import + if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) { + Module['printErr']('no native wasm Memory in use'); + return false; + } + env['memory'] = Module['wasmMemory']; + // Load the wasm module and create an instance of using native support in the JS engine. + info['global'] = { + 'NaN': NaN, + 'Infinity': Infinity + }; + info['global.Math'] = Math; + info['env'] = env; + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + function receiveInstance(instance, module) { + exports = instance.exports; + if (exports.memory) mergeMemory(exports.memory); + Module['asm'] = exports; + Module["usingWasm"] = true; + removeRunDependency('wasm-instantiate'); + } + addRunDependency('wasm-instantiate'); + + // 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 { + return Module['instantiateWasm'](info, receiveInstance); + } catch(e) { + Module['printErr']('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + 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 + receiveInstance(output['instance'], output['module']); + } + function instantiateArrayBuffer(receiver) { + getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver).catch(function(reason) { + Module['printErr']('failed to asynchronously prepare wasm: ' + reason); + abort(reason); + }); + } + // Prefer streaming instantiation if available. + if (!Module['wasmBinary'] && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + typeof fetch === 'function') { + WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, { credentials: 'same-origin' }), info) + .then(receiveInstantiatedSource) + .catch(function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + Module['printErr']('wasm streaming compile failed: ' + reason); + Module['printErr']('falling back to ArrayBuffer instantiation'); + instantiateArrayBuffer(receiveInstantiatedSource); + }); + } else { + instantiateArrayBuffer(receiveInstantiatedSource); + } + return {}; // no exports yet; we'll fill them in later + } + + + // We may have a preloaded value in Module.asm, save it + Module['asmPreload'] = Module['asm']; + + // Memory growth integration code + + var asmjsReallocBuffer = Module['reallocBuffer']; + + var wasmReallocBuffer = function(size) { + var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB. + size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size + var old = Module['buffer']; + var oldSize = old.byteLength; + if (Module["usingWasm"]) { + // native wasm support + try { + var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize); // .grow() takes a delta compared to the previous size + if (result !== (-1 | 0)) { + // success in native wasm memory growth, get the buffer from the memory + return Module['buffer'] = Module['wasmMemory'].buffer; + } else { + return null; + } + } catch(e) { + return null; + } + } + }; + + Module['reallocBuffer'] = function(size) { + if (finalMethod === 'asmjs') { + return asmjsReallocBuffer(size); + } else { + return wasmReallocBuffer(size); + } + }; + + // we may try more than one; this is the final one, that worked and we are using + var finalMethod = ''; + + // Provide an "asm.js function" for the application, called to "link" the asm.js module. We instantiate + // the wasm module at that time, and it receives imports and provides exports and so forth, the app + // doesn't need to care that it is wasm or olyfilled wasm or asm.js. + + Module['asm'] = function(global, env, providedBuffer) { + env = fixImports(env); + + // import table + if (!env['table']) { + var TABLE_SIZE = Module['wasmTableSize']; + if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; // works in binaryen interpreter at least + var MAX_TABLE_SIZE = Module['wasmMaxTableSize']; + if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') { + if (MAX_TABLE_SIZE !== undefined) { + env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, 'maximum': MAX_TABLE_SIZE, 'element': 'anyfunc' }); + } else { + env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, element: 'anyfunc' }); + } + } else { + env['table'] = new Array(TABLE_SIZE); // works in binaryen interpreter at least + } + Module['wasmTable'] = env['table']; + } + + if (!env['memoryBase']) { + env['memoryBase'] = Module['STATIC_BASE']; // tell the memory segments where to place themselves + } + if (!env['tableBase']) { + env['tableBase'] = 0; // table starts at 0 by default, in dynamic linking this will change + } + + // try the methods. each should return the exports if it succeeded + + var exports; + exports = doNativeWasm(global, env, providedBuffer); + + assert(exports, 'no binaryen method succeeded.'); + + + return exports; + }; + + var methodHandler = Module['asm']; // note our method handler, as we may modify Module['asm'] later +} + +integrateWasmJS(); + +// === Body === + +var ASM_CONSTS = []; + + + + + +STATIC_BASE = GLOBAL_BASE; + +STATICTOP = STATIC_BASE + 3888; +/* global initializers */ __ATINIT__.push(); + + + + + + + +var STATIC_BUMP = 3888; +Module["STATIC_BASE"] = STATIC_BASE; +Module["STATIC_BUMP"] = STATIC_BUMP; + +/* no memory initializer */ +var tempDoublePtr = STATICTOP; STATICTOP += 16; + +function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much + + HEAP8[tempDoublePtr] = HEAP8[ptr]; + + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; + +} + +function copyTempDouble(ptr) { + + HEAP8[tempDoublePtr] = HEAP8[ptr]; + + HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; + + HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; + + HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; + + HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; + + HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; + + HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; + + HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; + +} + +// {{PRE_LIBRARY}} + + + function ___assert_fail(condition, filename, line, func) { + abort('Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function']); + } + + function _abort() { + Module['abort'](); + } + + var _llvm_floor_f64=Math_floor; + + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src+num), dest); + return dest; + } + + + + + function ___setErrNo(value) { + if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value; + return value; + } +DYNAMICTOP_PTR = staticAlloc(4); + +STACK_BASE = STACKTOP = alignMemory(STATICTOP); + +STACK_MAX = STACK_BASE + TOTAL_STACK; + +DYNAMIC_BASE = alignMemory(STACK_MAX); + +HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; + +staticSealed = true; // seal the static portion of memory + +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(''); +} + + + +Module['wasmTableSize'] = 4; + +Module['wasmMaxTableSize'] = 4; + +function invoke_iii(index,a1,a2) { + try { + return Module["dynCall_iii"](index,a1,a2); + } catch(e) { + if (typeof e !== 'number' && e !== 'longjmp') throw e; + Module["setThrew"](1, 0); + } +} + +Module.asmGlobalArg = {}; + +Module.asmLibraryArg = { "abort": abort, "assert": assert, "enlargeMemory": enlargeMemory, "getTotalMemory": getTotalMemory, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "invoke_iii": invoke_iii, "___assert_fail": ___assert_fail, "___setErrNo": ___setErrNo, "_abort": _abort, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_llvm_floor_f64": _llvm_floor_f64, "DYNAMICTOP_PTR": DYNAMICTOP_PTR, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX }; +// EMSCRIPTEN_START_ASM +var asm =Module["asm"]// EMSCRIPTEN_END_ASM +(Module.asmGlobalArg, Module.asmLibraryArg, buffer); + +Module["asm"] = asm; +var ___errno_location = Module["___errno_location"] = function() { return Module["asm"]["___errno_location"].apply(null, arguments) }; +var _emscripten_replace_memory = Module["_emscripten_replace_memory"] = function() { return Module["asm"]["_emscripten_replace_memory"].apply(null, arguments) }; +var _free = Module["_free"] = function() { return Module["asm"]["_free"].apply(null, arguments) }; +var _malloc = Module["_malloc"] = function() { return Module["asm"]["_malloc"].apply(null, arguments) }; +var _memcpy = Module["_memcpy"] = function() { return Module["asm"]["_memcpy"].apply(null, arguments) }; +var _memset = Module["_memset"] = function() { return Module["asm"]["_memset"].apply(null, arguments) }; +var _sbrk = Module["_sbrk"] = function() { return Module["asm"]["_sbrk"].apply(null, arguments) }; +var _stb_vorbis_decode_memory = Module["_stb_vorbis_decode_memory"] = function() { return Module["asm"]["_stb_vorbis_decode_memory"].apply(null, arguments) }; +var establishStackSpace = Module["establishStackSpace"] = function() { return Module["asm"]["establishStackSpace"].apply(null, arguments) }; +var getTempRet0 = Module["getTempRet0"] = function() { return Module["asm"]["getTempRet0"].apply(null, arguments) }; +var runPostSets = Module["runPostSets"] = function() { return Module["asm"]["runPostSets"].apply(null, arguments) }; +var setTempRet0 = Module["setTempRet0"] = function() { return Module["asm"]["setTempRet0"].apply(null, arguments) }; +var setThrew = Module["setThrew"] = function() { return Module["asm"]["setThrew"].apply(null, arguments) }; +var stackAlloc = Module["stackAlloc"] = function() { return Module["asm"]["stackAlloc"].apply(null, arguments) }; +var stackRestore = Module["stackRestore"] = function() { return Module["asm"]["stackRestore"].apply(null, arguments) }; +var stackSave = Module["stackSave"] = function() { return Module["asm"]["stackSave"].apply(null, arguments) }; +var dynCall_iii = Module["dynCall_iii"] = function() { return Module["asm"]["dynCall_iii"].apply(null, arguments) }; +; + + + +// === Auto-generated postamble setup entry stuff === + +Module['asm'] = asm; + + + +Module["ccall"] = ccall; +Module["cwrap"] = cwrap; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +/** + * @constructor + * @extends {Error} + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +}; +ExitStatus.prototype = new Error(); +ExitStatus.prototype.constructor = ExitStatus; + +var initialStackTop; +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 (!Module['calledRun']) run(); + if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +} + + + + + +/** @type {function(Array=)} */ +function run(args) { + args = args || Module['arguments']; + + if (runDependencies > 0) { + return; + } + + + preRun(); + + if (runDependencies > 0) return; // a preRun added a dependency, run will be called later + if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame + + function doRun() { + if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening + Module['calledRun'] = true; + + if (ABORT) return; + + ensureInitRuntime(); + + 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; + + +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 && Module['noExitRuntime'] && status === 0) { + return; + } + + if (Module['noExitRuntime']) { + } else { + + ABORT = true; + EXITSTATUS = status; + STACKTOP = initialStackTop; + + exitRuntime(); + + if (Module['onExit']) Module['onExit'](status); + } + + if (ENVIRONMENT_IS_NODE) { + process['exit'](status); + } + Module['quit'](status, new ExitStatus(status)); +} +Module['exit'] = exit; + +var abortDecorators = []; + +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + if (what !== undefined) { + Module.print(what); + Module.printErr(what); + what = JSON.stringify(what) + } else { + what = ''; + } + + ABORT = true; + EXITSTATUS = 1; + + throw 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'; +} +Module['abort'] = abort; + +// {{PRE_RUN_ADDITIONS}} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + + +Module["noExitRuntime"] = true; + +run(); + +// {{POST_RUN_ADDITIONS}} + + + + + +// {{MODULE_ADDITIONS}} + + + diff --git a/audio/vorbis/internal/stb/stbvorbisjs_file_js.go b/audio/vorbis/internal/stb/stbvorbisjs_file_js.go new file mode 100644 index 000000000..516957c92 --- /dev/null +++ b/audio/vorbis/internal/stb/stbvorbisjs_file_js.go @@ -0,0 +1,6 @@ +// Code generated by file2byteslice. DO NOT EDIT. +// (gofmt is fine after generating) + +package stb + +var stbvorbis_js = []byte("// The Module object: Our interface to the outside world. We import\n// and export values on it. There are various ways Module can be used:\n// 1. Not defined. We create it here\n// 2. A function parameter, function(Module) { ..generated code.. }\n// 3. pre-run appended it, var Module = {}; ..generated code..\n// 4. External script tag defines var Module.\n// We need to check if Module already exists (e.g. case 3 above).\n// Substitution will be replaced with actual code on later stage of the build,\n// this way Closure Compiler will not mangle it (e.g. case 4. above).\n// Note that if you want to run closure, and also to use Module\n// after the generated code, you will need to define var Module = {};\n// before the code. Then that object will be used in the code, and you\n// can continue to use Module afterwards as well.\nvar Module = typeof Module !== 'undefined' ? Module : {};\n\n// --pre-jses are emitted after the Module integration code, so that they can\n// refer to Module (if they choose; they can also define Module)\n// {{PRE_JSES}}\n\n// Sometimes an existing Module object exists with properties\n// meant to overwrite the default module functionality. Here\n// we collect those properties and reapply _after_ we configure\n// the current environment's defaults to avoid having to be so\n// defensive during initialization.\nvar moduleOverrides = {};\nvar key;\nfor (key in Module) {\n if (Module.hasOwnProperty(key)) {\n moduleOverrides[key] = Module[key];\n }\n}\n\nModule['arguments'] = [];\nModule['thisProgram'] = './this.program';\nModule['quit'] = function(status, toThrow) {\n throw toThrow;\n};\nModule['preRun'] = [];\nModule['postRun'] = [];\n\n// The environment setup code below is customized to use Module.\n// *** Environment setup code ***\nvar ENVIRONMENT_IS_WEB = false;\nvar ENVIRONMENT_IS_WORKER = false;\nvar ENVIRONMENT_IS_NODE = false;\nvar ENVIRONMENT_IS_SHELL = false;\n\n// Three configurations we can be running in:\n// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)\n// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)\n// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)\n\nif (Module['ENVIRONMENT']) {\n if (Module['ENVIRONMENT'] === 'WEB') {\n ENVIRONMENT_IS_WEB = true;\n } else if (Module['ENVIRONMENT'] === 'WORKER') {\n ENVIRONMENT_IS_WORKER = true;\n } else if (Module['ENVIRONMENT'] === 'NODE') {\n ENVIRONMENT_IS_NODE = true;\n } else if (Module['ENVIRONMENT'] === 'SHELL') {\n ENVIRONMENT_IS_SHELL = true;\n } else {\n throw new Error('Module[\\'ENVIRONMENT\\'] value is not valid. must be one of: WEB|WORKER|NODE|SHELL.');\n }\n} else {\n ENVIRONMENT_IS_WEB = typeof window === 'object';\n ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';\n ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;\n ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;\n}\n\n\nif (ENVIRONMENT_IS_NODE) {\n // Expose functionality in the same simple way that the shells work\n // Note that we pollute the global namespace here, otherwise we break in node\n var nodeFS;\n var nodePath;\n\n Module['read'] = function shell_read(filename, binary) {\n var ret;\n if (!nodeFS) nodeFS = require('fs');\n if (!nodePath) nodePath = require('path');\n filename = nodePath['normalize'](filename);\n ret = nodeFS['readFileSync'](filename);\n return binary ? ret : ret.toString();\n };\n\n Module['readBinary'] = function readBinary(filename) {\n var ret = Module['read'](filename, true);\n if (!ret.buffer) {\n ret = new Uint8Array(ret);\n }\n assert(ret.buffer);\n return ret;\n };\n\n if (process['argv'].length > 1) {\n Module['thisProgram'] = process['argv'][1].replace(/\\\\/g, '/');\n }\n\n Module['arguments'] = process['argv'].slice(2);\n\n if (typeof module !== 'undefined') {\n module['exports'] = Module;\n }\n\n process['on']('uncaughtException', function(ex) {\n // suppress ExitStatus exceptions from showing an error\n if (!(ex instanceof ExitStatus)) {\n throw ex;\n }\n });\n // Currently node will swallow unhandled rejections, but this behavior is\n // deprecated, and in the future it will exit with error status.\n process['on']('unhandledRejection', function(reason, p) {\n process['exit'](1);\n });\n\n Module['inspect'] = function () { return '[Emscripten Module object]'; };\n} else\nif (ENVIRONMENT_IS_SHELL) {\n if (typeof read != 'undefined') {\n Module['read'] = function shell_read(f) {\n return read(f);\n };\n }\n\n Module['readBinary'] = function readBinary(f) {\n var data;\n if (typeof readbuffer === 'function') {\n return new Uint8Array(readbuffer(f));\n }\n data = read(f, 'binary');\n assert(typeof data === 'object');\n return data;\n };\n\n if (typeof scriptArgs != 'undefined') {\n Module['arguments'] = scriptArgs;\n } else if (typeof arguments != 'undefined') {\n Module['arguments'] = arguments;\n }\n\n if (typeof quit === 'function') {\n Module['quit'] = function(status, toThrow) {\n quit(status);\n }\n }\n} else\nif (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {\n Module['read'] = function shell_read(url) {\n var xhr = new XMLHttpRequest();\n xhr.open('GET', url, false);\n xhr.send(null);\n return xhr.responseText;\n };\n\n if (ENVIRONMENT_IS_WORKER) {\n Module['readBinary'] = function readBinary(url) {\n var xhr = new XMLHttpRequest();\n xhr.open('GET', url, false);\n xhr.responseType = 'arraybuffer';\n xhr.send(null);\n return new Uint8Array(xhr.response);\n };\n }\n\n Module['readAsync'] = function readAsync(url, onload, onerror) {\n var xhr = new XMLHttpRequest();\n xhr.open('GET', url, true);\n xhr.responseType = 'arraybuffer';\n xhr.onload = function xhr_onload() {\n if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0\n onload(xhr.response);\n return;\n }\n onerror();\n };\n xhr.onerror = onerror;\n xhr.send(null);\n };\n\n Module['setWindowTitle'] = function(title) { document.title = title };\n} else\n{\n throw new Error('not compiled for this environment');\n}\n\n// console.log is checked first, as 'print' on the web will open a print dialogue\n// printErr is preferable to console.warn (works better in shells)\n// bind(console) is necessary to fix IE/Edge closed dev tools panel behavior.\nModule['print'] = typeof console !== 'undefined' ? console.log.bind(console) : (typeof print !== 'undefined' ? print : null);\nModule['printErr'] = typeof printErr !== 'undefined' ? printErr : ((typeof console !== 'undefined' && console.warn.bind(console)) || Module['print']);\n\n// *** Environment setup code ***\n\n// Closure helpers\nModule.print = Module['print'];\nModule.printErr = Module['printErr'];\n\n// Merge back in the overrides\nfor (key in moduleOverrides) {\n if (moduleOverrides.hasOwnProperty(key)) {\n Module[key] = moduleOverrides[key];\n }\n}\n// Free the object hierarchy contained in the overrides, this lets the GC\n// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.\nmoduleOverrides = undefined;\n\n\n\n// {{PREAMBLE_ADDITIONS}}\n\nvar STACK_ALIGN = 16;\n\n\nfunction staticAlloc(size) {\n assert(!staticSealed);\n var ret = STATICTOP;\n STATICTOP = (STATICTOP + size + 15) & -16;\n return ret;\n}\n\nfunction dynamicAlloc(size) {\n assert(DYNAMICTOP_PTR);\n var ret = HEAP32[DYNAMICTOP_PTR>>2];\n var end = (ret + size + 15) & -16;\n HEAP32[DYNAMICTOP_PTR>>2] = end;\n if (end >= TOTAL_MEMORY) {\n var success = enlargeMemory();\n if (!success) {\n HEAP32[DYNAMICTOP_PTR>>2] = ret;\n return 0;\n }\n }\n return ret;\n}\n\nfunction alignMemory(size, factor) {\n if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default\n var ret = size = Math.ceil(size / factor) * factor;\n return ret;\n}\n\nfunction getNativeTypeSize(type) {\n switch (type) {\n case 'i1': case 'i8': return 1;\n case 'i16': return 2;\n case 'i32': return 4;\n case 'i64': return 8;\n case 'float': return 4;\n case 'double': return 8;\n default: {\n if (type[type.length-1] === '*') {\n return 4; // A pointer\n } else if (type[0] === 'i') {\n var bits = parseInt(type.substr(1));\n assert(bits % 8 === 0);\n return bits / 8;\n } else {\n return 0;\n }\n }\n }\n}\n\nfunction warnOnce(text) {\n if (!warnOnce.shown) warnOnce.shown = {};\n if (!warnOnce.shown[text]) {\n warnOnce.shown[text] = 1;\n Module.printErr(text);\n }\n}\n\nvar asm2wasmImports = { // special asm2wasm imports\n \"f64-rem\": function(x, y) {\n return x % y;\n },\n \"debugger\": function() {\n debugger;\n }\n};\n\n\n\nvar jsCallStartIndex = 1;\nvar functionPointers = new Array(0);\n\n// 'sig' parameter is only used on LLVM wasm backend\nfunction addFunction(func, sig) {\n var base = 0;\n for (var i = base; i < base + 0; i++) {\n if (!functionPointers[i]) {\n functionPointers[i] = func;\n return jsCallStartIndex + i;\n }\n }\n throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';\n}\n\nfunction removeFunction(index) {\n functionPointers[index-jsCallStartIndex] = null;\n}\n\nvar funcWrappers = {};\n\nfunction getFuncWrapper(func, sig) {\n if (!func) return; // on null pointer, return undefined\n assert(sig);\n if (!funcWrappers[sig]) {\n funcWrappers[sig] = {};\n }\n var sigCache = funcWrappers[sig];\n if (!sigCache[func]) {\n // optimize away arguments usage in common cases\n if (sig.length === 1) {\n sigCache[func] = function dynCall_wrapper() {\n return dynCall(sig, func);\n };\n } else if (sig.length === 2) {\n sigCache[func] = function dynCall_wrapper(arg) {\n return dynCall(sig, func, [arg]);\n };\n } else {\n // general case\n sigCache[func] = function dynCall_wrapper() {\n return dynCall(sig, func, Array.prototype.slice.call(arguments));\n };\n }\n }\n return sigCache[func];\n}\n\n\nfunction makeBigInt(low, high, unsigned) {\n return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));\n}\n\nfunction dynCall(sig, ptr, args) {\n if (args && args.length) {\n return Module['dynCall_' + sig].apply(null, [ptr].concat(args));\n } else {\n return Module['dynCall_' + sig].call(null, ptr);\n }\n}\n\n\n\nvar Runtime = {\n // FIXME backwards compatibility layer for ports. Support some Runtime.*\n // for now, fix it there, then remove it from here. That way we\n // can minimize any period of breakage.\n dynCall: dynCall, // for SDL2 port\n};\n\n// The address globals begin at. Very low in memory, for code size and optimization opportunities.\n// Above 0 is static memory, starting with globals.\n// Then the stack.\n// Then 'dynamic' memory for sbrk.\nvar GLOBAL_BASE = 1024;\n\n\n// === Preamble library stuff ===\n\n// Documentation for the public APIs defined in this file must be updated in:\n// site/source/docs/api_reference/preamble.js.rst\n// A prebuilt local version of the documentation is available at:\n// site/build/text/docs/api_reference/preamble.js.txt\n// You can also build docs locally as HTML or other formats in site/\n// An online HTML version (which may be of a different version of Emscripten)\n// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html\n\n\n\n//========================================\n// Runtime essentials\n//========================================\n\nvar ABORT = 0; // whether we are quitting the application. no code should run after this. set in exit() and abort()\nvar EXITSTATUS = 0;\n\n/** @type {function(*, string=)} */\nfunction assert(condition, text) {\n if (!condition) {\n abort('Assertion failed: ' + text);\n }\n}\n\nvar globalScope = this;\n\n// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)\nfunction getCFunc(ident) {\n var func = Module['_' + ident]; // closure exported function\n assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported');\n return func;\n}\n\nvar JSfuncs = {\n // Helpers for cwrap -- it can't refer to Runtime directly because it might\n // be renamed by closure, instead it calls JSfuncs['stackSave'].body to find\n // out what the minified function name is.\n 'stackSave': function() {\n stackSave()\n },\n 'stackRestore': function() {\n stackRestore()\n },\n // type conversion from js to c\n 'arrayToC' : function(arr) {\n var ret = stackAlloc(arr.length);\n writeArrayToMemory(arr, ret);\n return ret;\n },\n 'stringToC' : function(str) {\n var ret = 0;\n if (str !== null && str !== undefined && str !== 0) { // null string\n // at most 4 bytes per UTF-8 code point, +1 for the trailing '\\0'\n var len = (str.length << 2) + 1;\n ret = stackAlloc(len);\n stringToUTF8(str, ret, len);\n }\n return ret;\n }\n};\n\n// For fast lookup of conversion functions\nvar toC = {\n 'string': JSfuncs['stringToC'], 'array': JSfuncs['arrayToC']\n};\n\n// C calling interface.\nfunction ccall (ident, returnType, argTypes, args, opts) {\n var func = getCFunc(ident);\n var cArgs = [];\n var stack = 0;\n if (args) {\n for (var i = 0; i < args.length; i++) {\n var converter = toC[argTypes[i]];\n if (converter) {\n if (stack === 0) stack = stackSave();\n cArgs[i] = converter(args[i]);\n } else {\n cArgs[i] = args[i];\n }\n }\n }\n var ret = func.apply(null, cArgs);\n if (returnType === 'string') ret = Pointer_stringify(ret);\n else if (returnType === 'boolean') ret = Boolean(ret);\n if (stack !== 0) {\n stackRestore(stack);\n }\n return ret;\n}\n\nfunction cwrap (ident, returnType, argTypes) {\n argTypes = argTypes || [];\n var cfunc = getCFunc(ident);\n // When the function takes numbers and returns a number, we can just return\n // the original function\n var numericArgs = argTypes.every(function(type){ return type === 'number'});\n var numericRet = returnType !== 'string';\n if (numericRet && numericArgs) {\n return cfunc;\n }\n return function() {\n return ccall(ident, returnType, argTypes, arguments);\n }\n}\n\n/** @type {function(number, number, string, boolean=)} */\nfunction setValue(ptr, value, type, noSafe) {\n type = type || 'i8';\n if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit\n switch(type) {\n case 'i1': HEAP8[((ptr)>>0)]=value; break;\n case 'i8': HEAP8[((ptr)>>0)]=value; break;\n case 'i16': HEAP16[((ptr)>>1)]=value; break;\n case 'i32': HEAP32[((ptr)>>2)]=value; break;\n 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;\n case 'float': HEAPF32[((ptr)>>2)]=value; break;\n case 'double': HEAPF64[((ptr)>>3)]=value; break;\n default: abort('invalid type for setValue: ' + type);\n }\n}\n\n/** @type {function(number, string, boolean=)} */\nfunction getValue(ptr, type, noSafe) {\n type = type || 'i8';\n if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit\n switch(type) {\n case 'i1': return HEAP8[((ptr)>>0)];\n case 'i8': return HEAP8[((ptr)>>0)];\n case 'i16': return HEAP16[((ptr)>>1)];\n case 'i32': return HEAP32[((ptr)>>2)];\n case 'i64': return HEAP32[((ptr)>>2)];\n case 'float': return HEAPF32[((ptr)>>2)];\n case 'double': return HEAPF64[((ptr)>>3)];\n default: abort('invalid type for getValue: ' + type);\n }\n return null;\n}\n\nvar ALLOC_NORMAL = 0; // Tries to use _malloc()\nvar ALLOC_STACK = 1; // Lives for the duration of the current function call\nvar ALLOC_STATIC = 2; // Cannot be freed\nvar ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk\nvar ALLOC_NONE = 4; // Do not allocate\n\n// allocate(): This is for internal use. You can use it yourself as well, but the interface\n// is a little tricky (see docs right below). The reason is that it is optimized\n// for multiple syntaxes to save space in generated code. So you should\n// normally not use allocate(), and instead allocate memory using _malloc(),\n// initialize it with setValue(), and so forth.\n// @slab: An array of data, or a number. If a number, then the size of the block to allocate,\n// in *bytes* (note that this is sometimes confusing: the next parameter does not\n// affect this!)\n// @types: Either an array of types, one for each byte (or 0 if no type at that position),\n// or a single type which is used for the entire block. This only matters if there\n// is initial data - if @slab is a number, then this does not matter at all and is\n// ignored.\n// @allocator: How to allocate memory, see ALLOC_*\n/** @type {function((TypedArray|Array|number), string, number, number=)} */\nfunction allocate(slab, types, allocator, ptr) {\n var zeroinit, size;\n if (typeof slab === 'number') {\n zeroinit = true;\n size = slab;\n } else {\n zeroinit = false;\n size = slab.length;\n }\n\n var singleType = typeof types === 'string' ? types : null;\n\n var ret;\n if (allocator == ALLOC_NONE) {\n ret = ptr;\n } else {\n ret = [typeof _malloc === 'function' ? _malloc : staticAlloc, stackAlloc, staticAlloc, dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));\n }\n\n if (zeroinit) {\n var stop;\n ptr = ret;\n assert((ret & 3) == 0);\n stop = ret + (size & ~3);\n for (; ptr < stop; ptr += 4) {\n HEAP32[((ptr)>>2)]=0;\n }\n stop = ret + size;\n while (ptr < stop) {\n HEAP8[((ptr++)>>0)]=0;\n }\n return ret;\n }\n\n if (singleType === 'i8') {\n if (slab.subarray || slab.slice) {\n HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret);\n } else {\n HEAPU8.set(new Uint8Array(slab), ret);\n }\n return ret;\n }\n\n var i = 0, type, typeSize, previousType;\n while (i < size) {\n var curr = slab[i];\n\n type = singleType || types[i];\n if (type === 0) {\n i++;\n continue;\n }\n\n if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later\n\n setValue(ret+i, curr, type);\n\n // no need to look up size unless type changes, so cache it\n if (previousType !== type) {\n typeSize = getNativeTypeSize(type);\n previousType = type;\n }\n i += typeSize;\n }\n\n return ret;\n}\n\n// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready\nfunction getMemory(size) {\n if (!staticSealed) return staticAlloc(size);\n if (!runtimeInitialized) return dynamicAlloc(size);\n return _malloc(size);\n}\n\n/** @type {function(number, number=)} */\nfunction Pointer_stringify(ptr, length) {\n if (length === 0 || !ptr) return '';\n // Find the length, and check for UTF while doing so\n var hasUtf = 0;\n var t;\n var i = 0;\n while (1) {\n t = HEAPU8[(((ptr)+(i))>>0)];\n hasUtf |= t;\n if (t == 0 && !length) break;\n i++;\n if (length && i == length) break;\n }\n if (!length) length = i;\n\n var ret = '';\n\n if (hasUtf < 128) {\n var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack\n var curr;\n while (length > 0) {\n curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));\n ret = ret ? ret + curr : curr;\n ptr += MAX_CHUNK;\n length -= MAX_CHUNK;\n }\n return ret;\n }\n return UTF8ToString(ptr);\n}\n\n// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns\n// a copy of that string as a Javascript String object.\n\nfunction AsciiToString(ptr) {\n var str = '';\n while (1) {\n var ch = HEAP8[((ptr++)>>0)];\n if (!ch) return str;\n str += String.fromCharCode(ch);\n }\n}\n\n// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',\n// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.\n\nfunction stringToAscii(str, outPtr) {\n return writeAsciiToMemory(str, outPtr, false);\n}\n\n// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns\n// a copy of that string as a Javascript String object.\n\nvar UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;\nfunction UTF8ArrayToString(u8Array, idx) {\n var endPtr = idx;\n // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.\n // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.\n while (u8Array[endPtr]) ++endPtr;\n\n if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {\n return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));\n } else {\n var u0, u1, u2, u3, u4, u5;\n\n var str = '';\n while (1) {\n // 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\n u0 = u8Array[idx++];\n if (!u0) return str;\n if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }\n u1 = u8Array[idx++] & 63;\n if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }\n u2 = u8Array[idx++] & 63;\n if ((u0 & 0xF0) == 0xE0) {\n u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;\n } else {\n u3 = u8Array[idx++] & 63;\n if ((u0 & 0xF8) == 0xF0) {\n u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3;\n } else {\n u4 = u8Array[idx++] & 63;\n if ((u0 & 0xFC) == 0xF8) {\n u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4;\n } else {\n u5 = u8Array[idx++] & 63;\n u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5;\n }\n }\n }\n if (u0 < 0x10000) {\n str += String.fromCharCode(u0);\n } else {\n var ch = u0 - 0x10000;\n str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n }\n }\n }\n}\n\n// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns\n// a copy of that string as a Javascript String object.\n\nfunction UTF8ToString(ptr) {\n return UTF8ArrayToString(HEAPU8,ptr);\n}\n\n// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',\n// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.\n// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.\n// Parameters:\n// str: the Javascript string to copy.\n// outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element.\n// outIdx: The starting offset in the array to begin the copying.\n// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null\n// terminator, i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.\n// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.\n// Returns the number of bytes written, EXCLUDING the null terminator.\n\nfunction stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {\n if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.\n return 0;\n\n var startIdx = outIdx;\n var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.\n for (var i = 0; i < str.length; ++i) {\n // 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.\n // See http://unicode.org/faq/utf_bom.html#utf16-3\n // 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\n var u = str.charCodeAt(i); // possibly a lead surrogate\n if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);\n if (u <= 0x7F) {\n if (outIdx >= endIdx) break;\n outU8Array[outIdx++] = u;\n } else if (u <= 0x7FF) {\n if (outIdx + 1 >= endIdx) break;\n outU8Array[outIdx++] = 0xC0 | (u >> 6);\n outU8Array[outIdx++] = 0x80 | (u & 63);\n } else if (u <= 0xFFFF) {\n if (outIdx + 2 >= endIdx) break;\n outU8Array[outIdx++] = 0xE0 | (u >> 12);\n outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);\n outU8Array[outIdx++] = 0x80 | (u & 63);\n } else if (u <= 0x1FFFFF) {\n if (outIdx + 3 >= endIdx) break;\n outU8Array[outIdx++] = 0xF0 | (u >> 18);\n outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);\n outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);\n outU8Array[outIdx++] = 0x80 | (u & 63);\n } else if (u <= 0x3FFFFFF) {\n if (outIdx + 4 >= endIdx) break;\n outU8Array[outIdx++] = 0xF8 | (u >> 24);\n outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63);\n outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);\n outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);\n outU8Array[outIdx++] = 0x80 | (u & 63);\n } else {\n if (outIdx + 5 >= endIdx) break;\n outU8Array[outIdx++] = 0xFC | (u >> 30);\n outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63);\n outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63);\n outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);\n outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);\n outU8Array[outIdx++] = 0x80 | (u & 63);\n }\n }\n // Null-terminate the pointer to the buffer.\n outU8Array[outIdx] = 0;\n return outIdx - startIdx;\n}\n\n// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',\n// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.\n// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.\n// Returns the number of bytes written, EXCLUDING the null terminator.\n\nfunction stringToUTF8(str, outPtr, maxBytesToWrite) {\n return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);\n}\n\n// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.\n\nfunction lengthBytesUTF8(str) {\n var len = 0;\n for (var i = 0; i < str.length; ++i) {\n // 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.\n // See http://unicode.org/faq/utf_bom.html#utf16-3\n var u = str.charCodeAt(i); // possibly a lead surrogate\n if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);\n if (u <= 0x7F) {\n ++len;\n } else if (u <= 0x7FF) {\n len += 2;\n } else if (u <= 0xFFFF) {\n len += 3;\n } else if (u <= 0x1FFFFF) {\n len += 4;\n } else if (u <= 0x3FFFFFF) {\n len += 5;\n } else {\n len += 6;\n }\n }\n return len;\n}\n\n// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns\n// a copy of that string as a Javascript String object.\n\nvar UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;\nfunction UTF16ToString(ptr) {\n var endPtr = ptr;\n // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.\n // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.\n var idx = endPtr >> 1;\n while (HEAP16[idx]) ++idx;\n endPtr = idx << 1;\n\n if (endPtr - ptr > 32 && UTF16Decoder) {\n return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));\n } else {\n var i = 0;\n\n var str = '';\n while (1) {\n var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];\n if (codeUnit == 0) return str;\n ++i;\n // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.\n str += String.fromCharCode(codeUnit);\n }\n }\n}\n\n// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',\n// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.\n// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.\n// Parameters:\n// str: the Javascript string to copy.\n// outPtr: Byte address in Emscripten HEAP where to write the string to.\n// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null\n// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.\n// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.\n// Returns the number of bytes written, EXCLUDING the null terminator.\n\nfunction stringToUTF16(str, outPtr, maxBytesToWrite) {\n // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.\n if (maxBytesToWrite === undefined) {\n maxBytesToWrite = 0x7FFFFFFF;\n }\n if (maxBytesToWrite < 2) return 0;\n maxBytesToWrite -= 2; // Null terminator.\n var startPtr = outPtr;\n var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;\n for (var i = 0; i < numCharsToWrite; ++i) {\n // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.\n var codeUnit = str.charCodeAt(i); // possibly a lead surrogate\n HEAP16[((outPtr)>>1)]=codeUnit;\n outPtr += 2;\n }\n // Null-terminate the pointer to the HEAP.\n HEAP16[((outPtr)>>1)]=0;\n return outPtr - startPtr;\n}\n\n// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.\n\nfunction lengthBytesUTF16(str) {\n return str.length*2;\n}\n\nfunction UTF32ToString(ptr) {\n var i = 0;\n\n var str = '';\n while (1) {\n var utf32 = HEAP32[(((ptr)+(i*4))>>2)];\n if (utf32 == 0)\n return str;\n ++i;\n // 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.\n // See http://unicode.org/faq/utf_bom.html#utf16-3\n if (utf32 >= 0x10000) {\n var ch = utf32 - 0x10000;\n str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n } else {\n str += String.fromCharCode(utf32);\n }\n }\n}\n\n// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',\n// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.\n// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.\n// Parameters:\n// str: the Javascript string to copy.\n// outPtr: Byte address in Emscripten HEAP where to write the string to.\n// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null\n// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.\n// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.\n// Returns the number of bytes written, EXCLUDING the null terminator.\n\nfunction stringToUTF32(str, outPtr, maxBytesToWrite) {\n // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.\n if (maxBytesToWrite === undefined) {\n maxBytesToWrite = 0x7FFFFFFF;\n }\n if (maxBytesToWrite < 4) return 0;\n var startPtr = outPtr;\n var endPtr = startPtr + maxBytesToWrite - 4;\n for (var i = 0; i < str.length; ++i) {\n // 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.\n // See http://unicode.org/faq/utf_bom.html#utf16-3\n var codeUnit = str.charCodeAt(i); // possibly a lead surrogate\n if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {\n var trailSurrogate = str.charCodeAt(++i);\n codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);\n }\n HEAP32[((outPtr)>>2)]=codeUnit;\n outPtr += 4;\n if (outPtr + 4 > endPtr) break;\n }\n // Null-terminate the pointer to the HEAP.\n HEAP32[((outPtr)>>2)]=0;\n return outPtr - startPtr;\n}\n\n// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.\n\nfunction lengthBytesUTF32(str) {\n var len = 0;\n for (var i = 0; i < str.length; ++i) {\n // 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.\n // See http://unicode.org/faq/utf_bom.html#utf16-3\n var codeUnit = str.charCodeAt(i);\n if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.\n len += 4;\n }\n\n return len;\n}\n\n// Allocate heap space for a JS string, and write it there.\n// It is the responsibility of the caller to free() that memory.\nfunction allocateUTF8(str) {\n var size = lengthBytesUTF8(str) + 1;\n var ret = _malloc(size);\n if (ret) stringToUTF8Array(str, HEAP8, ret, size);\n return ret;\n}\n\n// Allocate stack space for a JS string, and write it there.\nfunction allocateUTF8OnStack(str) {\n var size = lengthBytesUTF8(str) + 1;\n var ret = stackAlloc(size);\n stringToUTF8Array(str, HEAP8, ret, size);\n return ret;\n}\n\nfunction demangle(func) {\n return func;\n}\n\nfunction demangleAll(text) {\n var regex =\n /__Z[\\w\\d_]+/g;\n return text.replace(regex,\n function(x) {\n var y = demangle(x);\n return x === y ? x : (x + ' [' + y + ']');\n });\n}\n\nfunction jsStackTrace() {\n var err = new Error();\n if (!err.stack) {\n // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,\n // so try that as a special-case.\n try {\n throw new Error(0);\n } catch(e) {\n err = e;\n }\n if (!err.stack) {\n return '(no stack trace available)';\n }\n }\n return err.stack.toString();\n}\n\nfunction stackTrace() {\n var js = jsStackTrace();\n if (Module['extraStackTrace']) js += '\\n' + Module['extraStackTrace']();\n return demangleAll(js);\n}\n\n// Memory management\n\nvar PAGE_SIZE = 16384;\nvar WASM_PAGE_SIZE = 65536;\nvar ASMJS_PAGE_SIZE = 16777216;\nvar MIN_TOTAL_MEMORY = 16777216;\n\nfunction alignUp(x, multiple) {\n if (x % multiple > 0) {\n x += multiple - (x % multiple);\n }\n return x;\n}\n\nvar HEAP,\n/** @type {ArrayBuffer} */\n buffer,\n/** @type {Int8Array} */\n HEAP8,\n/** @type {Uint8Array} */\n HEAPU8,\n/** @type {Int16Array} */\n HEAP16,\n/** @type {Uint16Array} */\n HEAPU16,\n/** @type {Int32Array} */\n HEAP32,\n/** @type {Uint32Array} */\n HEAPU32,\n/** @type {Float32Array} */\n HEAPF32,\n/** @type {Float64Array} */\n HEAPF64;\n\nfunction updateGlobalBuffer(buf) {\n Module['buffer'] = buffer = buf;\n}\n\nfunction updateGlobalBufferViews() {\n Module['HEAP8'] = HEAP8 = new Int8Array(buffer);\n Module['HEAP16'] = HEAP16 = new Int16Array(buffer);\n Module['HEAP32'] = HEAP32 = new Int32Array(buffer);\n Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer);\n Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer);\n Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer);\n Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer);\n Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer);\n}\n\nvar STATIC_BASE, STATICTOP, staticSealed; // static area\nvar STACK_BASE, STACKTOP, STACK_MAX; // stack area\nvar DYNAMIC_BASE, DYNAMICTOP_PTR; // dynamic area handled by sbrk\n\n STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;\n staticSealed = false;\n\n\n\nfunction abortOnCannotGrowMemory() {\n abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ');\n}\n\nif (!Module['reallocBuffer']) Module['reallocBuffer'] = function(size) {\n var ret;\n try {\n if (ArrayBuffer.transfer) {\n ret = ArrayBuffer.transfer(buffer, size);\n } else {\n var oldHEAP8 = HEAP8;\n ret = new ArrayBuffer(size);\n var temp = new Int8Array(ret);\n temp.set(oldHEAP8);\n }\n } catch(e) {\n return false;\n }\n var success = _emscripten_replace_memory(ret);\n if (!success) return false;\n return ret;\n};\n\nfunction enlargeMemory() {\n // TOTAL_MEMORY is the current size of the actual array, and DYNAMICTOP is the new top.\n\n\n var PAGE_MULTIPLE = Module[\"usingWasm\"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB.\n var LIMIT = 2147483648 - PAGE_MULTIPLE; // We can do one page short of 2GB as theoretical maximum.\n\n if (HEAP32[DYNAMICTOP_PTR>>2] > LIMIT) {\n return false;\n }\n\n var OLD_TOTAL_MEMORY = TOTAL_MEMORY;\n TOTAL_MEMORY = Math.max(TOTAL_MEMORY, MIN_TOTAL_MEMORY); // So the loop below will not be infinite, and minimum asm.js memory size is 16MB.\n\n while (TOTAL_MEMORY < HEAP32[DYNAMICTOP_PTR>>2]) { // Keep incrementing the heap size as long as it's less than what is requested.\n if (TOTAL_MEMORY <= 536870912) {\n TOTAL_MEMORY = alignUp(2 * TOTAL_MEMORY, PAGE_MULTIPLE); // Simple heuristic: double until 1GB...\n } else {\n // ..., but after that, add smaller increments towards 2GB, which we cannot reach\n TOTAL_MEMORY = Math.min(alignUp((3 * TOTAL_MEMORY + 2147483648) / 4, PAGE_MULTIPLE), LIMIT);\n }\n }\n\n\n var replacement = Module['reallocBuffer'](TOTAL_MEMORY);\n if (!replacement || replacement.byteLength != TOTAL_MEMORY) {\n // restore the state to before this call, we failed\n TOTAL_MEMORY = OLD_TOTAL_MEMORY;\n return false;\n }\n\n // everything worked\n\n updateGlobalBuffer(replacement);\n updateGlobalBufferViews();\n\n\n\n return true;\n}\n\nvar byteLength;\ntry {\n byteLength = Function.prototype.call.bind(Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get);\n byteLength(new ArrayBuffer(4)); // can fail on older ie\n} catch(e) { // can fail on older node/v8\n byteLength = function(buffer) { return buffer.byteLength; };\n}\n\nvar TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;\nvar TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216;\nif (TOTAL_MEMORY < TOTAL_STACK) Module.printErr('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')');\n\n// Initialize the runtime's memory\n\n\n\n// Use a provided buffer, if there is one, or else allocate a new one\nif (Module['buffer']) {\n buffer = Module['buffer'];\n} else {\n // Use a WebAssembly memory where available\n if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') {\n Module['wasmMemory'] = new WebAssembly.Memory({ 'initial': TOTAL_MEMORY / WASM_PAGE_SIZE });\n buffer = Module['wasmMemory'].buffer;\n } else\n {\n buffer = new ArrayBuffer(TOTAL_MEMORY);\n }\n Module['buffer'] = buffer;\n}\nupdateGlobalBufferViews();\n\n\nfunction getTotalMemory() {\n return TOTAL_MEMORY;\n}\n\n// Endianness check (note: assumes compiler arch was little-endian)\n HEAP32[0] = 0x63736d65; /* 'emsc' */\nHEAP16[1] = 0x6373;\nif (HEAPU8[2] !== 0x73 || HEAPU8[3] !== 0x63) throw 'Runtime error: expected the system to be little-endian!';\n\nfunction callRuntimeCallbacks(callbacks) {\n while(callbacks.length > 0) {\n var callback = callbacks.shift();\n if (typeof callback == 'function') {\n callback();\n continue;\n }\n var func = callback.func;\n if (typeof func === 'number') {\n if (callback.arg === undefined) {\n Module['dynCall_v'](func);\n } else {\n Module['dynCall_vi'](func, callback.arg);\n }\n } else {\n func(callback.arg === undefined ? null : callback.arg);\n }\n }\n}\n\nvar __ATPRERUN__ = []; // functions called before the runtime is initialized\nvar __ATINIT__ = []; // functions called during startup\nvar __ATMAIN__ = []; // functions called when main() is to be run\nvar __ATEXIT__ = []; // functions called during shutdown\nvar __ATPOSTRUN__ = []; // functions called after the main() is called\n\nvar runtimeInitialized = false;\nvar runtimeExited = false;\n\n\nfunction preRun() {\n // compatibility - merge in anything from Module['preRun'] at this time\n if (Module['preRun']) {\n if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];\n while (Module['preRun'].length) {\n addOnPreRun(Module['preRun'].shift());\n }\n }\n callRuntimeCallbacks(__ATPRERUN__);\n}\n\nfunction ensureInitRuntime() {\n if (runtimeInitialized) return;\n runtimeInitialized = true;\n callRuntimeCallbacks(__ATINIT__);\n}\n\nfunction preMain() {\n callRuntimeCallbacks(__ATMAIN__);\n}\n\nfunction exitRuntime() {\n callRuntimeCallbacks(__ATEXIT__);\n runtimeExited = true;\n}\n\nfunction postRun() {\n // compatibility - merge in anything from Module['postRun'] at this time\n if (Module['postRun']) {\n if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];\n while (Module['postRun'].length) {\n addOnPostRun(Module['postRun'].shift());\n }\n }\n callRuntimeCallbacks(__ATPOSTRUN__);\n}\n\nfunction addOnPreRun(cb) {\n __ATPRERUN__.unshift(cb);\n}\n\nfunction addOnInit(cb) {\n __ATINIT__.unshift(cb);\n}\n\nfunction addOnPreMain(cb) {\n __ATMAIN__.unshift(cb);\n}\n\nfunction addOnExit(cb) {\n __ATEXIT__.unshift(cb);\n}\n\nfunction addOnPostRun(cb) {\n __ATPOSTRUN__.unshift(cb);\n}\n\n// Deprecated: This function should not be called because it is unsafe and does not provide\n// a maximum length limit of how many bytes it is allowed to write. Prefer calling the\n// function stringToUTF8Array() instead, which takes in a maximum length that can be used\n// to be secure from out of bounds writes.\n/** @deprecated */\nfunction writeStringToMemory(string, buffer, dontAddNull) {\n warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!');\n\n var /** @type {number} */ lastChar, /** @type {number} */ end;\n if (dontAddNull) {\n // stringToUTF8Array always appends null. If we don't want to do that, remember the\n // character that existed at the location where the null will be placed, and restore\n // that after the write (below).\n end = buffer + lengthBytesUTF8(string);\n lastChar = HEAP8[end];\n }\n stringToUTF8(string, buffer, Infinity);\n if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.\n}\n\nfunction writeArrayToMemory(array, buffer) {\n HEAP8.set(array, buffer);\n}\n\nfunction writeAsciiToMemory(str, buffer, dontAddNull) {\n for (var i = 0; i < str.length; ++i) {\n HEAP8[((buffer++)>>0)]=str.charCodeAt(i);\n }\n // Null-terminate the pointer to the HEAP.\n if (!dontAddNull) HEAP8[((buffer)>>0)]=0;\n}\n\nfunction unSign(value, bits, ignore) {\n if (value >= 0) {\n return value;\n }\n return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts\n : Math.pow(2, bits) + value;\n}\nfunction reSign(value, bits, ignore) {\n if (value <= 0) {\n return value;\n }\n var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32\n : Math.pow(2, bits-1);\n if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that\n // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors\n // TODO: In i64 mode 1, resign the two parts separately and safely\n value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts\n }\n return value;\n}\n\n\nvar Math_abs = Math.abs;\nvar Math_cos = Math.cos;\nvar Math_sin = Math.sin;\nvar Math_tan = Math.tan;\nvar Math_acos = Math.acos;\nvar Math_asin = Math.asin;\nvar Math_atan = Math.atan;\nvar Math_atan2 = Math.atan2;\nvar Math_exp = Math.exp;\nvar Math_log = Math.log;\nvar Math_sqrt = Math.sqrt;\nvar Math_ceil = Math.ceil;\nvar Math_floor = Math.floor;\nvar Math_pow = Math.pow;\nvar Math_imul = Math.imul;\nvar Math_fround = Math.fround;\nvar Math_round = Math.round;\nvar Math_min = Math.min;\nvar Math_max = Math.max;\nvar Math_clz32 = Math.clz32;\nvar Math_trunc = Math.trunc;\n\n// A counter of dependencies for calling run(). If we need to\n// do asynchronous work before running, increment this and\n// decrement it. Incrementing must happen in a place like\n// PRE_RUN_ADDITIONS (used by emcc to add file preloading).\n// Note that you can add dependencies in preRun, even though\n// it happens right before run - run will be postponed until\n// the dependencies are met.\nvar runDependencies = 0;\nvar runDependencyWatcher = null;\nvar dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled\n\nfunction getUniqueRunDependency(id) {\n return id;\n}\n\nfunction addRunDependency(id) {\n runDependencies++;\n if (Module['monitorRunDependencies']) {\n Module['monitorRunDependencies'](runDependencies);\n }\n}\n\nfunction removeRunDependency(id) {\n runDependencies--;\n if (Module['monitorRunDependencies']) {\n Module['monitorRunDependencies'](runDependencies);\n }\n if (runDependencies == 0) {\n if (runDependencyWatcher !== null) {\n clearInterval(runDependencyWatcher);\n runDependencyWatcher = null;\n }\n if (dependenciesFulfilled) {\n var callback = dependenciesFulfilled;\n dependenciesFulfilled = null;\n callback(); // can add another dependenciesFulfilled\n }\n }\n}\n\nModule[\"preloadedImages\"] = {}; // maps url to image data\nModule[\"preloadedAudios\"] = {}; // maps url to audio data\n\n\n\nvar memoryInitializer = null;\n\n\n\n\n\n\n// Prefix of data URIs emitted by SINGLE_FILE and related options.\nvar dataURIPrefix = 'data:application/octet-stream;base64,';\n\n// Indicates whether filename is a base64 data URI.\nfunction isDataURI(filename) {\n return String.prototype.startsWith ?\n filename.startsWith(dataURIPrefix) :\n filename.indexOf(dataURIPrefix) === 0;\n}\n\n\n\n\nfunction integrateWasmJS() {\n // wasm.js has several methods for creating the compiled code module here:\n // * 'native-wasm' : use native WebAssembly support in the browser\n // * 'interpret-s-expr': load s-expression code from a .wast and interpret\n // * 'interpret-binary': load binary wasm and interpret\n // * 'interpret-asm2wasm': load asm.js code, translate to wasm, and interpret\n // * 'asmjs': no wasm, just load the asm.js code and use that (good for testing)\n // The method is set at compile time (BINARYEN_METHOD)\n // The method can be a comma-separated list, in which case, we will try the\n // options one by one. Some of them can fail gracefully, and then we can try\n // the next.\n\n // inputs\n\n var method = 'native-wasm';\n\n var wasmTextFile = 'stbvorbis.wast';\n var wasmBinaryFile = 'stbvorbis.wasm';\n var asmjsCodeFile = 'stbvorbis.temp.asm.js';\n\n if (typeof Module['locateFile'] === 'function') {\n if (!isDataURI(wasmTextFile)) {\n wasmTextFile = Module['locateFile'](wasmTextFile);\n }\n if (!isDataURI(wasmBinaryFile)) {\n wasmBinaryFile = Module['locateFile'](wasmBinaryFile);\n }\n if (!isDataURI(asmjsCodeFile)) {\n asmjsCodeFile = Module['locateFile'](asmjsCodeFile);\n }\n }\n\n // utilities\n\n var wasmPageSize = 64*1024;\n\n var info = {\n 'global': null,\n 'env': null,\n 'asm2wasm': asm2wasmImports,\n 'parent': Module // Module inside wasm-js.cpp refers to wasm-js.cpp; this allows access to the outside program.\n };\n\n var exports = null;\n\n\n function mergeMemory(newBuffer) {\n // The wasm instance creates its memory. But static init code might have written to\n // buffer already, including the mem init file, and we must copy it over in a proper merge.\n // TODO: avoid this copy, by avoiding such static init writes\n // TODO: in shorter term, just copy up to the last static init write\n var oldBuffer = Module['buffer'];\n if (newBuffer.byteLength < oldBuffer.byteLength) {\n Module['printErr']('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here');\n }\n var oldView = new Int8Array(oldBuffer);\n var newView = new Int8Array(newBuffer);\n\n\n newView.set(oldView);\n updateGlobalBuffer(newBuffer);\n updateGlobalBufferViews();\n }\n\n function fixImports(imports) {\n return imports;\n }\n\n function getBinary() {\n try {\n if (Module['wasmBinary']) {\n return new Uint8Array(Module['wasmBinary']);\n }\n if (Module['readBinary']) {\n return Module['readBinary'](wasmBinaryFile);\n } else {\n throw \"on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. emcc.py will do that for you when generating HTML (but not JS)\";\n }\n }\n catch (err) {\n abort(err);\n }\n }\n\n function getBinaryPromise() {\n // if we don't have the binary yet, and have the Fetch api, use that\n // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web\n if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') {\n return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) {\n if (!response['ok']) {\n throw \"failed to load wasm binary file at '\" + wasmBinaryFile + \"'\";\n }\n return response['arrayBuffer']();\n }).catch(function () {\n return getBinary();\n });\n }\n // Otherwise, getBinary should be able to get it synchronously\n return new Promise(function(resolve, reject) {\n resolve(getBinary());\n });\n }\n\n // do-method functions\n\n\n function doNativeWasm(global, env, providedBuffer) {\n if (typeof WebAssembly !== 'object') {\n Module['printErr']('no native wasm support detected');\n return false;\n }\n // prepare memory import\n if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) {\n Module['printErr']('no native wasm Memory in use');\n return false;\n }\n env['memory'] = Module['wasmMemory'];\n // Load the wasm module and create an instance of using native support in the JS engine.\n info['global'] = {\n 'NaN': NaN,\n 'Infinity': Infinity\n };\n info['global.Math'] = Math;\n info['env'] = env;\n // handle a generated wasm instance, receiving its exports and\n // performing other necessary setup\n function receiveInstance(instance, module) {\n exports = instance.exports;\n if (exports.memory) mergeMemory(exports.memory);\n Module['asm'] = exports;\n Module[\"usingWasm\"] = true;\n removeRunDependency('wasm-instantiate');\n }\n addRunDependency('wasm-instantiate');\n\n // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback\n // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel\n // to any other async startup actions they are performing.\n if (Module['instantiateWasm']) {\n try {\n return Module['instantiateWasm'](info, receiveInstance);\n } catch(e) {\n Module['printErr']('Module.instantiateWasm callback failed with error: ' + e);\n return false;\n }\n }\n\n function receiveInstantiatedSource(output) {\n // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance.\n // receiveInstance() will swap in the exports (to Module.asm) so they can be called\n receiveInstance(output['instance'], output['module']);\n }\n function instantiateArrayBuffer(receiver) {\n getBinaryPromise().then(function(binary) {\n return WebAssembly.instantiate(binary, info);\n }).then(receiver).catch(function(reason) {\n Module['printErr']('failed to asynchronously prepare wasm: ' + reason);\n abort(reason);\n });\n }\n // Prefer streaming instantiation if available.\n if (!Module['wasmBinary'] &&\n typeof WebAssembly.instantiateStreaming === 'function' &&\n !isDataURI(wasmBinaryFile) &&\n typeof fetch === 'function') {\n WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, { credentials: 'same-origin' }), info)\n .then(receiveInstantiatedSource)\n .catch(function(reason) {\n // We expect the most common failure cause to be a bad MIME type for the binary,\n // in which case falling back to ArrayBuffer instantiation should work.\n Module['printErr']('wasm streaming compile failed: ' + reason);\n Module['printErr']('falling back to ArrayBuffer instantiation');\n instantiateArrayBuffer(receiveInstantiatedSource);\n });\n } else {\n instantiateArrayBuffer(receiveInstantiatedSource);\n }\n return {}; // no exports yet; we'll fill them in later\n }\n\n\n // We may have a preloaded value in Module.asm, save it\n Module['asmPreload'] = Module['asm'];\n\n // Memory growth integration code\n\n var asmjsReallocBuffer = Module['reallocBuffer'];\n\n var wasmReallocBuffer = function(size) {\n var PAGE_MULTIPLE = Module[\"usingWasm\"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB.\n size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size\n var old = Module['buffer'];\n var oldSize = old.byteLength;\n if (Module[\"usingWasm\"]) {\n // native wasm support\n try {\n var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize); // .grow() takes a delta compared to the previous size\n if (result !== (-1 | 0)) {\n // success in native wasm memory growth, get the buffer from the memory\n return Module['buffer'] = Module['wasmMemory'].buffer;\n } else {\n return null;\n }\n } catch(e) {\n return null;\n }\n }\n };\n\n Module['reallocBuffer'] = function(size) {\n if (finalMethod === 'asmjs') {\n return asmjsReallocBuffer(size);\n } else {\n return wasmReallocBuffer(size);\n }\n };\n\n // we may try more than one; this is the final one, that worked and we are using\n var finalMethod = '';\n\n // Provide an \"asm.js function\" for the application, called to \"link\" the asm.js module. We instantiate\n // the wasm module at that time, and it receives imports and provides exports and so forth, the app\n // doesn't need to care that it is wasm or olyfilled wasm or asm.js.\n\n Module['asm'] = function(global, env, providedBuffer) {\n env = fixImports(env);\n\n // import table\n if (!env['table']) {\n var TABLE_SIZE = Module['wasmTableSize'];\n if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; // works in binaryen interpreter at least\n var MAX_TABLE_SIZE = Module['wasmMaxTableSize'];\n if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') {\n if (MAX_TABLE_SIZE !== undefined) {\n env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, 'maximum': MAX_TABLE_SIZE, 'element': 'anyfunc' });\n } else {\n env['table'] = new WebAssembly.Table({ 'initial': TABLE_SIZE, element: 'anyfunc' });\n }\n } else {\n env['table'] = new Array(TABLE_SIZE); // works in binaryen interpreter at least\n }\n Module['wasmTable'] = env['table'];\n }\n\n if (!env['memoryBase']) {\n env['memoryBase'] = Module['STATIC_BASE']; // tell the memory segments where to place themselves\n }\n if (!env['tableBase']) {\n env['tableBase'] = 0; // table starts at 0 by default, in dynamic linking this will change\n }\n\n // try the methods. each should return the exports if it succeeded\n\n var exports;\n exports = doNativeWasm(global, env, providedBuffer);\n\n assert(exports, 'no binaryen method succeeded.');\n\n\n return exports;\n };\n\n var methodHandler = Module['asm']; // note our method handler, as we may modify Module['asm'] later\n}\n\nintegrateWasmJS();\n\n// === Body ===\n\nvar ASM_CONSTS = [];\n\n\n\n\n\nSTATIC_BASE = GLOBAL_BASE;\n\nSTATICTOP = STATIC_BASE + 3888;\n/* global initializers */ __ATINIT__.push();\n\n\n\n\n\n\n\nvar STATIC_BUMP = 3888;\nModule[\"STATIC_BASE\"] = STATIC_BASE;\nModule[\"STATIC_BUMP\"] = STATIC_BUMP;\n\n/* no memory initializer */\nvar tempDoublePtr = STATICTOP; STATICTOP += 16;\n\nfunction copyTempFloat(ptr) { // functions, because inlining this code increases code size too much\n\n HEAP8[tempDoublePtr] = HEAP8[ptr];\n\n HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];\n\n HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];\n\n HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];\n\n}\n\nfunction copyTempDouble(ptr) {\n\n HEAP8[tempDoublePtr] = HEAP8[ptr];\n\n HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];\n\n HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];\n\n HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];\n\n HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];\n\n HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];\n\n HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];\n\n HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];\n\n}\n\n// {{PRE_LIBRARY}}\n\n\n function ___assert_fail(condition, filename, line, func) {\n abort('Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function']);\n }\n\n function _abort() {\n Module['abort']();\n }\n\n var _llvm_floor_f64=Math_floor;\n\n \n function _emscripten_memcpy_big(dest, src, num) {\n HEAPU8.set(HEAPU8.subarray(src, src+num), dest);\n return dest;\n } \n\n \n\n \n function ___setErrNo(value) {\n if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value;\n return value;\n } \nDYNAMICTOP_PTR = staticAlloc(4);\n\nSTACK_BASE = STACKTOP = alignMemory(STATICTOP);\n\nSTACK_MAX = STACK_BASE + TOTAL_STACK;\n\nDYNAMIC_BASE = alignMemory(STACK_MAX);\n\nHEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE;\n\nstaticSealed = true; // seal the static portion of memory\n\nvar ASSERTIONS = false;\n\n/** @type {function(string, boolean=, number=)} */\nfunction intArrayFromString(stringy, dontAddNull, length) {\n var len = length > 0 ? length : lengthBytesUTF8(stringy)+1;\n var u8array = new Array(len);\n var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);\n if (dontAddNull) u8array.length = numBytesWritten;\n return u8array;\n}\n\nfunction intArrayToString(array) {\n var ret = [];\n for (var i = 0; i < array.length; i++) {\n var chr = array[i];\n if (chr > 0xFF) {\n if (ASSERTIONS) {\n assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.');\n }\n chr &= 0xFF;\n }\n ret.push(String.fromCharCode(chr));\n }\n return ret.join('');\n}\n\n\n\nModule['wasmTableSize'] = 4;\n\nModule['wasmMaxTableSize'] = 4;\n\nfunction invoke_iii(index,a1,a2) {\n try {\n return Module[\"dynCall_iii\"](index,a1,a2);\n } catch(e) {\n if (typeof e !== 'number' && e !== 'longjmp') throw e;\n Module[\"setThrew\"](1, 0);\n }\n}\n\nModule.asmGlobalArg = {};\n\nModule.asmLibraryArg = { \"abort\": abort, \"assert\": assert, \"enlargeMemory\": enlargeMemory, \"getTotalMemory\": getTotalMemory, \"abortOnCannotGrowMemory\": abortOnCannotGrowMemory, \"invoke_iii\": invoke_iii, \"___assert_fail\": ___assert_fail, \"___setErrNo\": ___setErrNo, \"_abort\": _abort, \"_emscripten_memcpy_big\": _emscripten_memcpy_big, \"_llvm_floor_f64\": _llvm_floor_f64, \"DYNAMICTOP_PTR\": DYNAMICTOP_PTR, \"tempDoublePtr\": tempDoublePtr, \"ABORT\": ABORT, \"STACKTOP\": STACKTOP, \"STACK_MAX\": STACK_MAX };\n// EMSCRIPTEN_START_ASM\nvar asm =Module[\"asm\"]// EMSCRIPTEN_END_ASM\n(Module.asmGlobalArg, Module.asmLibraryArg, buffer);\n\nModule[\"asm\"] = asm;\nvar ___errno_location = Module[\"___errno_location\"] = function() { return Module[\"asm\"][\"___errno_location\"].apply(null, arguments) };\nvar _emscripten_replace_memory = Module[\"_emscripten_replace_memory\"] = function() { return Module[\"asm\"][\"_emscripten_replace_memory\"].apply(null, arguments) };\nvar _free = Module[\"_free\"] = function() { return Module[\"asm\"][\"_free\"].apply(null, arguments) };\nvar _malloc = Module[\"_malloc\"] = function() { return Module[\"asm\"][\"_malloc\"].apply(null, arguments) };\nvar _memcpy = Module[\"_memcpy\"] = function() { return Module[\"asm\"][\"_memcpy\"].apply(null, arguments) };\nvar _memset = Module[\"_memset\"] = function() { return Module[\"asm\"][\"_memset\"].apply(null, arguments) };\nvar _sbrk = Module[\"_sbrk\"] = function() { return Module[\"asm\"][\"_sbrk\"].apply(null, arguments) };\nvar _stb_vorbis_decode_memory = Module[\"_stb_vorbis_decode_memory\"] = function() { return Module[\"asm\"][\"_stb_vorbis_decode_memory\"].apply(null, arguments) };\nvar establishStackSpace = Module[\"establishStackSpace\"] = function() { return Module[\"asm\"][\"establishStackSpace\"].apply(null, arguments) };\nvar getTempRet0 = Module[\"getTempRet0\"] = function() { return Module[\"asm\"][\"getTempRet0\"].apply(null, arguments) };\nvar runPostSets = Module[\"runPostSets\"] = function() { return Module[\"asm\"][\"runPostSets\"].apply(null, arguments) };\nvar setTempRet0 = Module[\"setTempRet0\"] = function() { return Module[\"asm\"][\"setTempRet0\"].apply(null, arguments) };\nvar setThrew = Module[\"setThrew\"] = function() { return Module[\"asm\"][\"setThrew\"].apply(null, arguments) };\nvar stackAlloc = Module[\"stackAlloc\"] = function() { return Module[\"asm\"][\"stackAlloc\"].apply(null, arguments) };\nvar stackRestore = Module[\"stackRestore\"] = function() { return Module[\"asm\"][\"stackRestore\"].apply(null, arguments) };\nvar stackSave = Module[\"stackSave\"] = function() { return Module[\"asm\"][\"stackSave\"].apply(null, arguments) };\nvar dynCall_iii = Module[\"dynCall_iii\"] = function() { return Module[\"asm\"][\"dynCall_iii\"].apply(null, arguments) };\n;\n\n\n\n// === Auto-generated postamble setup entry stuff ===\n\nModule['asm'] = asm;\n\n\n\nModule[\"ccall\"] = ccall;\nModule[\"cwrap\"] = cwrap;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n/**\n * @constructor\n * @extends {Error}\n * @this {ExitStatus}\n */\nfunction ExitStatus(status) {\n this.name = \"ExitStatus\";\n this.message = \"Program terminated with exit(\" + status + \")\";\n this.status = status;\n};\nExitStatus.prototype = new Error();\nExitStatus.prototype.constructor = ExitStatus;\n\nvar initialStackTop;\nvar calledMain = false;\n\ndependenciesFulfilled = function runCaller() {\n // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)\n if (!Module['calledRun']) run();\n if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled\n}\n\n\n\n\n\n/** @type {function(Array=)} */\nfunction run(args) {\n args = args || Module['arguments'];\n\n if (runDependencies > 0) {\n return;\n }\n\n\n preRun();\n\n if (runDependencies > 0) return; // a preRun added a dependency, run will be called later\n if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame\n\n function doRun() {\n if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening\n Module['calledRun'] = true;\n\n if (ABORT) return;\n\n ensureInitRuntime();\n\n preMain();\n\n if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();\n\n\n postRun();\n }\n\n if (Module['setStatus']) {\n Module['setStatus']('Running...');\n setTimeout(function() {\n setTimeout(function() {\n Module['setStatus']('');\n }, 1);\n doRun();\n }, 1);\n } else {\n doRun();\n }\n}\nModule['run'] = run;\n\n\nfunction exit(status, implicit) {\n\n // if this is just main exit-ing implicitly, and the status is 0, then we\n // don't need to do anything here and can just leave. if the status is\n // non-zero, though, then we need to report it.\n // (we may have warned about this earlier, if a situation justifies doing so)\n if (implicit && Module['noExitRuntime'] && status === 0) {\n return;\n }\n\n if (Module['noExitRuntime']) {\n } else {\n\n ABORT = true;\n EXITSTATUS = status;\n STACKTOP = initialStackTop;\n\n exitRuntime();\n\n if (Module['onExit']) Module['onExit'](status);\n }\n\n if (ENVIRONMENT_IS_NODE) {\n process['exit'](status);\n }\n Module['quit'](status, new ExitStatus(status));\n}\nModule['exit'] = exit;\n\nvar abortDecorators = [];\n\nfunction abort(what) {\n if (Module['onAbort']) {\n Module['onAbort'](what);\n }\n\n if (what !== undefined) {\n Module.print(what);\n Module.printErr(what);\n what = JSON.stringify(what)\n } else {\n what = '';\n }\n\n ABORT = true;\n EXITSTATUS = 1;\n\n throw 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';\n}\nModule['abort'] = abort;\n\n// {{PRE_RUN_ADDITIONS}}\n\nif (Module['preInit']) {\n if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];\n while (Module['preInit'].length > 0) {\n Module['preInit'].pop()();\n }\n}\n\n\nModule[\"noExitRuntime\"] = true;\n\nrun();\n\n// {{POST_RUN_ADDITIONS}}\n\n\n\n\n\n// {{MODULE_ADDITIONS}}\n\n\n\n") diff --git a/audio/vorbis/internal/stb/wasm.js b/audio/vorbis/internal/stb/wasm.js new file mode 100644 index 000000000..100f21eba --- /dev/null +++ b/audio/vorbis/internal/stb/wasm.js @@ -0,0 +1,4 @@ +// Code generated by genwasmjs.go. DO NOT EDIT. + +var Module = typeof Module !== 'undefined' ? Module : {}; +Module['wasmBinary'] = Uint8Array.from(atob("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"), c => c.charCodeAt(0)); diff --git a/audio/vorbis/internal/stb/wasmjs_file_js.go b/audio/vorbis/internal/stb/wasmjs_file_js.go new file mode 100644 index 000000000..f8ab4a4c7 --- /dev/null +++ b/audio/vorbis/internal/stb/wasmjs_file_js.go @@ -0,0 +1,6 @@ +// Code generated by file2byteslice. DO NOT EDIT. +// (gofmt is fine after generating) + +package stb + +var wasm_js = []byte("// Code generated by genwasmjs.go. DO NOT EDIT.\n\nvar Module = typeof Module !== 'undefined' ? Module : {};\nModule['wasmBinary'] = Uint8Array.from(atob(\"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\"), c => c.charCodeAt(0));\n") diff --git a/audio/vorbis/vorbis.go b/audio/vorbis/vorbis.go index 4666a8a52..0cd18c189 100644 --- a/audio/vorbis/vorbis.go +++ b/audio/vorbis/vorbis.go @@ -20,8 +20,6 @@ import ( "io" "runtime" - "github.com/jfreymuth/oggvorbis" - "github.com/hajimehoshi/ebiten/audio" "github.com/hajimehoshi/ebiten/audio/internal/convert" ) @@ -63,13 +61,20 @@ func (s *Stream) Size() int64 { return s.Length() } +type decoder interface { + Read([]float32) (int, error) + Length() int64 + Channels() int + SampleRate() int +} + type decoded struct { data []float32 totalBytes int readBytes int posInBytes int source io.Closer - decoder *oggvorbis.Reader + decoder decoder } func (d *decoded) readUntil(posInBytes int) error { @@ -93,7 +98,6 @@ func (d *decoded) readUntil(posInBytes int) error { if err != nil { return err } - runtime.Gosched() } return nil } @@ -157,7 +161,7 @@ func (d *decoded) Length() int64 { // decode accepts an ogg stream and returns a decorded stream. func decode(in audio.ReadSeekCloser) (*decoded, int, int, error) { - r, err := oggvorbis.NewReader(in) + r, err := newDecoder(in) if err != nil { return nil, 0, 0, err } diff --git a/audio/vorbis/vorbis_js.go b/audio/vorbis/vorbis_js.go new file mode 100644 index 000000000..964de9947 --- /dev/null +++ b/audio/vorbis/vorbis_js.go @@ -0,0 +1,72 @@ +// Copyright 2018 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build js + +package vorbis + +import ( + "io" + "io/ioutil" + + "github.com/hajimehoshi/ebiten/audio" + "github.com/hajimehoshi/ebiten/audio/vorbis/internal/stb" +) + +type decoderImpl struct { + data []int16 + channels int + sampleRate int +} + +func (d *decoderImpl) Read(buf []float32) (int, error) { + if len(d.data) == 0 { + return 0, io.EOF + } + + n := len(buf) + if n > len(d.data) { + n = len(d.data) + } + for i := 0; i < n; i++ { + buf[i] = float32(d.data[i]) / 32768 + } + d.data = d.data[n:] + return n, nil +} + +func (d *decoderImpl) Length() int64 { + return int64(len(d.data) / d.channels) +} + +func (d *decoderImpl) Channels() int { + return d.channels +} + +func (d *decoderImpl) SampleRate() int { + return d.sampleRate +} + +func newDecoder(in audio.ReadSeekCloser) (decoder, error) { + buf, err := ioutil.ReadAll(in) + if err != nil { + return nil, err + } + + data, channels, sampleRate, err := stb.DecodeVorbis(buf) + if err != nil { + return nil, err + } + return &decoderImpl{data, channels, sampleRate}, nil +} diff --git a/audio/vorbis/vorbis_notjs.go b/audio/vorbis/vorbis_notjs.go new file mode 100644 index 000000000..0d05dc642 --- /dev/null +++ b/audio/vorbis/vorbis_notjs.go @@ -0,0 +1,27 @@ +// Copyright 2018 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build !js + +package vorbis + +import ( + "github.com/jfreymuth/oggvorbis" + + "github.com/hajimehoshi/ebiten/audio" +) + +func newDecoder(in audio.ReadSeekCloser) (decoder, error) { + return oggvorbis.NewReader(in) +}