From e8f6dad0255813215b0c1fca45eb19e2accb3389 Mon Sep 17 00:00:00 2001 From: Katajisto Date: Tue, 29 Sep 2026 20:55:49 +0300 Subject: [PATCH] add stb_vorbis --- modules/sokol-jai/sokol/build_clibs_wasm.sh | 2 + modules/sokol-jai/sokol/c/stb_vorbis.c | 9 + modules/sokol-jai/sokol/c/stb_vorbis_impl.c | 5584 +++++++++++++++++ modules/stb_vorbis/android/arm64/stb_vorbis.a | Bin 0 -> 91482 bytes .../stb_vorbis/android/arm64/stb_vorbis.so | Bin 0 -> 81000 bytes modules/stb_vorbis/android/x64/stb_vorbis.a | Bin 0 -> 100690 bytes modules/stb_vorbis/android/x64/stb_vorbis.so | Bin 0 -> 87368 bytes modules/stb_vorbis/bindings.jai | 273 + modules/stb_vorbis/generate.jai | 180 + modules/stb_vorbis/linux/stb_vorbis.a | Bin 0 -> 110362 bytes modules/stb_vorbis/linux/stb_vorbis.so | Bin 0 -> 97736 bytes modules/stb_vorbis/macos/stb_vorbis.a | Bin 0 -> 189344 bytes modules/stb_vorbis/macos/stb_vorbis.dylib | Bin 0 -> 220856 bytes modules/stb_vorbis/module.jai | 11 + modules/stb_vorbis/source/stb_vorbis.c | 5584 +++++++++++++++++ modules/stb_vorbis/source/stb_vorbis_custom.c | 9 + modules/stb_vorbis/windows/stb_vorbis.dll | Bin 0 -> 250880 bytes modules/stb_vorbis/windows/stb_vorbis.lib | Bin 0 -> 152016 bytes 18 files changed, 11652 insertions(+) create mode 100644 modules/sokol-jai/sokol/c/stb_vorbis.c create mode 100644 modules/sokol-jai/sokol/c/stb_vorbis_impl.c create mode 100644 modules/stb_vorbis/android/arm64/stb_vorbis.a create mode 100644 modules/stb_vorbis/android/arm64/stb_vorbis.so create mode 100644 modules/stb_vorbis/android/x64/stb_vorbis.a create mode 100644 modules/stb_vorbis/android/x64/stb_vorbis.so create mode 100644 modules/stb_vorbis/bindings.jai create mode 100644 modules/stb_vorbis/generate.jai create mode 100644 modules/stb_vorbis/linux/stb_vorbis.a create mode 100644 modules/stb_vorbis/linux/stb_vorbis.so create mode 100644 modules/stb_vorbis/macos/stb_vorbis.a create mode 100644 modules/stb_vorbis/macos/stb_vorbis.dylib create mode 100644 modules/stb_vorbis/module.jai create mode 100644 modules/stb_vorbis/source/stb_vorbis.c create mode 100644 modules/stb_vorbis/source/stb_vorbis_custom.c create mode 100644 modules/stb_vorbis/windows/stb_vorbis.dll create mode 100644 modules/stb_vorbis/windows/stb_vorbis.lib diff --git a/modules/sokol-jai/sokol/build_clibs_wasm.sh b/modules/sokol-jai/sokol/build_clibs_wasm.sh index 3cf49db..0e18905 100755 --- a/modules/sokol-jai/sokol/build_clibs_wasm.sh +++ b/modules/sokol-jai/sokol/build_clibs_wasm.sh @@ -32,6 +32,7 @@ build_lib_wasm_release sokol_fetch fetch/sokol_fetch_wasm_gl_release SOKOL build_lib_wasm_release sokol_audio audio/sokol_audio_wasm_gl_release SOKOL_GLES3 build_lib_wasm_release sokol_gl gl/sokol_gl_wasm_gl_release SOKOL_GLES3 build_lib_wasm_release stb_image stbi/stb_image SOKOL_GLES3 +build_lib_wasm_release stb_vorbis stbv/stb_vorbis SOKOL_GLES3 # wasm + GL + Debug build_lib_wasm_debug sokol_log log/sokol_log_wasm_gl_debug SOKOL_GLES3 @@ -47,5 +48,6 @@ build_lib_wasm_debug sokol_fetch fetch/sokol_fetch_wasm_gl_debug SOKOL_G build_lib_wasm_debug sokol_audio audio/sokol_audio_wasm_gl_debug SOKOL_GLES3 build_lib_wasm_debug sokol_gl gl/sokol_gl_wasm_gl_debug SOKOL_GLES3 build_lib_wasm_debug stb_image stbi/stb_image SOKOL_GLES3 +build_lib_wasm_debug stb_vorbis stbv/stb_vorbis SOKOL_GLES3 rm *.o diff --git a/modules/sokol-jai/sokol/c/stb_vorbis.c b/modules/sokol-jai/sokol/c/stb_vorbis.c new file mode 100644 index 0000000..db23bc2 --- /dev/null +++ b/modules/sokol-jai/sokol/c/stb_vorbis.c @@ -0,0 +1,9 @@ +#ifdef WIN32 +#define __EXPORT __declspec(dllexport) +#else +#define __EXPORT +#endif + +#define extern extern __EXPORT + +#include "stb_vorbis_impl.c" diff --git a/modules/sokol-jai/sokol/c/stb_vorbis_impl.c b/modules/sokol-jai/sokol/c/stb_vorbis_impl.c new file mode 100644 index 0000000..3e5c250 --- /dev/null +++ b/modules/sokol-jai/sokol/c/stb_vorbis_impl.c @@ -0,0 +1,5584 @@ +// Ogg Vorbis audio decoder - v1.22 - 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 github:alxprd +// Tom Beaumont Ingo Leitgeb Nicolas Guillemot +// Phillip Bennefall Rohit Thiago Goulart +// github:manxorist Saga Musix github:infatum +// Timur Gagiev Maxwell Koo Peter Waller +// github:audinowho Dougall Johnson David Reid +// github:Clownacy Pedro J. Estebanez Remi Verschelde +// AnthoFoxo github:morlat Gabriel Ravier +// +// Partial history: +// 1.22 - 2021-07-11 - various small fixes +// 1.21 - 2021-07-02 - fix bug for files with no comments +// 1.20 - 2020-07-11 - several small fixes +// 1.19 - 2020-02-05 - warnings +// 1.18 - 2020-02-02 - fix seek bugs; parse header comments; misc warnings etc. +// 1.17 - 2019-07-08 - fix CVE-2019-13217..CVE-2019-13223 (by ForAllSecure) +// 1.16 - 2019-03-04 - fix warnings +// 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found +// 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; + +typedef struct +{ + char *vendor; + + int comment_list_length; + char **comment_list; +} stb_vorbis_comment; + +// get general information about the file +extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f); + +// get ogg comments +extern stb_vorbis_comment stb_vorbis_get_comment(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. +// +// *output points into stb_vorbis's internal output buffer storage; these +// buffers are owned by stb_vorbis and application code should not free +// them or modify their contents. They are transient and will be overwritten +// once you ask for more data to get decoded, so be sure to grab any data +// you need before then. + +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. Moreover, 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, + VORBIS_ogg_skeleton_not_supported +}; + + +#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(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__) + #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 + #ifndef alloca + #define alloca __builtin_alloca + #endif +#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; + +#ifdef _MSC_VER +#define STBV_NOTUSED(v) (void)(v) +#else +#define STBV_NOTUSED(v) (void)sizeof(v) +#endif + +// @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; + + char *vendor; + int comment_list_length; + char **comment_list; + + // 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; + + // the page to seek to when seeking to start, may be zero + uint32 first_audio_page_offset; + + // p_first is the page on which the first audio packet ends + // (but not necessarily the page on which it starts) + 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) (void)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+7) & ~7; // round up to nearest 8 for alignment of future allocs. + 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+7) & ~7; // round up to nearest 8 for alignment of future allocs. + 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+7)&~7; + 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, (int)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; } + assert(len[k] < 32); // no error return required, code reading lens checks this + // 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; + assert(z < 32); // no error return required, code reading lens checks this + // 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]; + available[z] = 0; + add_entry(c, bit_reverse(res), i, m++, len[i], values); + // propagate availability up the tree + if (z != len[i]) { + 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 + if (pow((float) r+1, dim) <= entries) + return -1; + if ((int) floor(pow((float) r, dim)) > entries) + return -1; + 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; + if (f->first_decode && !IS_PUSH_MODE(f)) { + f->p_first.page_start = stb_vorbis_get_file_offset(f) - 4; + } + // 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; + len = 0; + for (i=0; i < f->segment_count; ++i) + len += f->segments[i]; + len += 27 + f->segment_count; + f->p_first.page_end = f->p_first.page_start + len; + f->p_first.last_decoded_sample = loc0; + } + 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 int get32_packet(vorb *f) +{ + uint32 x; + x = get8_packet(f); + x += get8_packet(f) << 8; + x += get8_packet(f) << 16; + x += (uint32) get8_packet(f) << 24; + 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; + } + } + + assert(f->valid_bits >= n); + 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&255]); + 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&255]); + } + } +} + +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 > 2) { + 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; + float l00,l11; + + k00 = z[-0] - z[ -8]; + k11 = z[-1] - z[ -9]; + l00 = z[-2] - z[-10]; + l11 = z[-3] - z[-11]; + z[ -0] = z[-0] + z[ -8]; + z[ -1] = z[-1] + z[ -9]; + z[ -2] = z[-2] + z[-10]; + z[ -3] = z[-3] + z[-11]; + z[ -8] = k00; + z[ -9] = k11; + z[-10] = (l00+l11) * A2; + z[-11] = (l11-l00) * A2; + + k00 = z[ -4] - z[-12]; + k11 = z[ -5] - z[-13]; + l00 = z[ -6] - z[-14]; + l11 = z[ -7] - z[-15]; + z[ -4] = z[ -4] + z[-12]; + z[ -5] = z[ -5] + z[-13]; + z[ -6] = z[ -6] + z[-14]; + z[ -7] = z[ -7] + z[-15]; + z[-12] = k11; + z[-13] = -k00; + z[-14] = (l11-l00) * A2; + z[-15] = (l00+l11) * -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 propagates 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]; + 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 + STBV_NOTUSED(step2_flag); + 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 + + STBV_NOTUSED(left_end); + 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 = 0u - n2; // start of first frame is positioned for discard (NB this is an intentional unsigned overflow/wrap-around) + // 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); + if (w == NULL) return 0; + 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) +{ + // 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 (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 (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 + f->first_decode = TRUE; + + 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) { + // check for the Ogg skeleton fishead identifying header to refine our error + if (f->segments[0] == 64 && + getn(f, header, 6) && + header[0] == 'f' && + header[1] == 'i' && + header[2] == 's' && + header[3] == 'h' && + header[4] == 'e' && + header[5] == 'a' && + get8(f) == 'd' && + get8(f) == '\0') return error(f, VORBIS_ogg_skeleton_not_supported); + else + 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; + + if (!next_segment(f)) return FALSE; + + if (get8_packet(f) != VORBIS_packet_comment) 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); + //file vendor + len = get32_packet(f); + f->vendor = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->vendor == NULL) return error(f, VORBIS_outofmem); + for(i=0; i < len; ++i) { + f->vendor[i] = get8_packet(f); + } + f->vendor[len] = (char)'\0'; + //user comments + f->comment_list_length = get32_packet(f); + f->comment_list = NULL; + if (f->comment_list_length > 0) + { + f->comment_list = (char**) setup_malloc(f, sizeof(char*) * (f->comment_list_length)); + if (f->comment_list == NULL) return error(f, VORBIS_outofmem); + } + + for(i=0; i < f->comment_list_length; ++i) { + len = get32_packet(f); + f->comment_list[i] = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->comment_list[i] == NULL) return error(f, VORBIS_outofmem); + + for(j=0; j < len; ++j) { + f->comment_list[i][j] = get8_packet(f); + } + f->comment_list[i][len] = (char)'\0'; + } + + // framing_flag + x = get8_packet(f); + if (!(x & 1)) return error(f, VORBIS_invalid_setup); + + + skip(f, f->bytes_in_seg); + f->bytes_in_seg = 0; + + 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)) { + // 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_length >= 32) return error(f, VORBIS_invalid_setup); + 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) { + int values = lookup1_values(c->entries, c->dimensions); + if (values < 0) return error(f, VORBIS_invalid_setup); + c->lookup_values = (uint32) values; + } 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]*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] = (int16)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-1; ++j) + if (p[j].x == p[j+1].x) + return error(f, VORBIS_invalid_setup); + 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 = 0,hi = 0; + 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; + if (m->coupling_steps > f->channels) return error(f, VORBIS_invalid_setup); + 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; + } + + + 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); + } + + // @TODO: stb_vorbis_seek_start expects first_audio_page_offset to point to a page + // without PAGEFLAG_continued_packet, so this either points to the first page, or + // the page after the end of the headers. It might be cleaner to point to a page + // in the middle of the headers, when that's the page where the first audio packet + // starts, but we'd have to also correctly skip the end of any continued packet in + // stb_vorbis_seek_start. + if (f->next_seg == -1) { + f->first_audio_page_offset = stb_vorbis_get_file_offset(f); + } else { + f->first_audio_page_offset = 0; + } + + return TRUE; +} + +static void vorbis_deinit(stb_vorbis *p) +{ + int i,j; + + setup_free(p, p->vendor); + for (i=0; i < p->comment_list_length; ++i) { + setup_free(p, p->comment_list[i]); + } + setup_free(p, p->comment_list); + + 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 &= ~7; + 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; +} + +stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f) +{ + stb_vorbis_comment d; + d.vendor = f->vendor; + d.comment_list_length = f->comment_list_length; + d.comment_list = f->comment_list; + 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)) { + *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; + vorbis_deinit(&p); + 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) + ((uint32)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 preceding 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, last_sample_limit; + double offset = 0.0, bytes_per_sample = 0.0; + 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) + last_sample_limit = 0; + else + last_sample_limit = 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 (last_sample_limit <= left.last_decoded_sample) { + if (stb_vorbis_seek_start(f)) { + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + 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 * (last_sample_limit - left.last_decoded_sample); + } else { + // second probe (try to bound the other side) + double error = ((double) last_sample_limit - 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 it wasn't an interpolation probe). + if (mid.page_start == right.page_start) { + if (probe >= 2 || delta <= 65536) + break; + } else { + if (last_sample_limit < 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 should start with the sample + if (f->current_loc != sample_number) return error(f, VORBIS_seek_failed); + 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; // NOTE: not used after this point, but note for debugging + 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; +#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__) + if (0 != fopen_s(&f, filename, "rb")) + f = NULL; +#else + f = fopen(filename, "rb"); +#endif + 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) { + if (error) *error = VORBIS_unexpected_eof; + 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 STB_BUFFER_SIZE 32 + float buffer[STB_BUFFER_SIZE]; + int i,j,o,n = STB_BUFFER_SIZE; + check_endianness(); + for (o = 0; o < len; o += STB_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; + } + } + #undef STB_BUFFER_SIZE +} + +static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len) +{ + #define STB_BUFFER_SIZE 32 + float buffer[STB_BUFFER_SIZE]; + int i,j,o,n = STB_BUFFER_SIZE >> 1; + // o is the offset in the source data + check_endianness(); + for (o = 0; o < len; o += STB_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; + } + } + #undef STB_BUFFER_SIZE +} + +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 = NULL; + 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; + 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; + 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.17 - 2019-07-08 - fix CVE-2019-13217, -13218, -13219, -13220, -13221, -13222, -13223 + found with Mayhem by ForAllSecure + 1.16 - 2019-03-04 - fix warnings + 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found + 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 '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/modules/stb_vorbis/android/arm64/stb_vorbis.a b/modules/stb_vorbis/android/arm64/stb_vorbis.a new file mode 100644 index 0000000000000000000000000000000000000000..8f8312d324c40fd55d0c4b582bce7de23e0428cf GIT binary patch literal 91482 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 CBW{BL literal 0 HcmV?d00001 diff --git a/modules/stb_vorbis/android/arm64/stb_vorbis.so b/modules/stb_vorbis/android/arm64/stb_vorbis.so new file mode 100644 index 0000000000000000000000000000000000000000..77dcf3e737d71aff3e39add04f0e738b19cb0ddf GIT binary patch literal 81000 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 Oq|C7@G&A(i|Nj9orV9iB literal 0 HcmV?d00001 diff --git a/modules/stb_vorbis/android/x64/stb_vorbis.a b/modules/stb_vorbis/android/x64/stb_vorbis.a new file mode 100644 index 0000000000000000000000000000000000000000..1de77724e7d557c5ea6119671c15b4ca6d9cfa6f GIT binary patch literal 100690 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 Ts=BWh{>40F)7Mh`>)ro9Mf-?< literal 0 HcmV?d00001 diff --git a/modules/stb_vorbis/android/x64/stb_vorbis.so b/modules/stb_vorbis/android/x64/stb_vorbis.so new file mode 100644 index 0000000000000000000000000000000000000000..ba083ab645991cff1341a746ae0063bd3653fd64 GIT binary patch literal 87368 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

D| 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

`|Tyxh%M;zsJ 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 stb_vorbis_info #foreign lib_stb_vorbis; + +// get ogg comments +stb_vorbis_get_comment :: (f: *stb_vorbis) -> stb_vorbis_comment #foreign lib_stb_vorbis; + +// get the last error detected (clears it, too) +stb_vorbis_get_error :: (f: *stb_vorbis) -> s32 #foreign lib_stb_vorbis; + +// close an ogg vorbis file and free all memory in use +stb_vorbis_close :: (f: *stb_vorbis) -> void #foreign lib_stb_vorbis; + +// 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 +stb_vorbis_get_sample_offset :: (f: *stb_vorbis) -> s32 #foreign lib_stb_vorbis; + +// returns the current seek point within the file, or offset from the beginning +// of the memory buffer. In pushdata mode it returns 0. +stb_vorbis_get_file_offset :: (f: *stb_vorbis) -> u32 #foreign lib_stb_vorbis; + +// 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. +stb_vorbis_open_pushdata :: (datablock: *u8, datablock_length_in_bytes: s32, datablock_memory_consumed_in_bytes: *s32, error: *s32, alloc_buffer: *stb_vorbis_alloc) -> *stb_vorbis #foreign lib_stb_vorbis; + +// 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 +stb_vorbis_decode_frame_pushdata :: (f: *stb_vorbis, datablock: *u8, datablock_length_in_bytes: s32, channels: *s32, output: ***float, samples: *s32) -> s32 #foreign lib_stb_vorbis; + +// 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. +// +// *output points into stb_vorbis's internal output buffer storage; these +// buffers are owned by stb_vorbis and application code should not free +// them or modify their contents. They are transient and will be overwritten +// once you ask for more data to get decoded, so be sure to grab any data +// you need before then. +stb_vorbis_flush_pushdata :: (f: *stb_vorbis) -> void #foreign lib_stb_vorbis; + +stb_vorbis_decode_filename :: (filename: *u8, channels: *s32, sample_rate: *s32, output: **s16) -> s32 #foreign lib_stb_vorbis; + +stb_vorbis_decode_memory :: (mem: *u8, len: s32, channels: *s32, sample_rate: *s32, output: **s16) -> s32 #foreign lib_stb_vorbis; + +// 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. +stb_vorbis_open_memory :: (data: *u8, len: s32, error: *s32, alloc_buffer: *stb_vorbis_alloc) -> *stb_vorbis #foreign lib_stb_vorbis; + +stb_vorbis_open_filename :: (filename: *u8, error: *s32, alloc_buffer: *stb_vorbis_alloc) -> *stb_vorbis #foreign lib_stb_vorbis; + +// create an ogg vorbis decoder from a filename via fopen(). on failure, +// returns NULL and sets *error (possibly to VORBIS_file_open_failure). +stb_vorbis_open_file :: (f: *FILE, close_handle_on_close: s32, error: *s32, alloc_buffer: *stb_vorbis_alloc) -> *stb_vorbis #foreign lib_stb_vorbis; + +// 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. Moreover, 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. +stb_vorbis_open_file_section :: (f: *FILE, close_handle_on_close: s32, error: *s32, alloc_buffer: *stb_vorbis_alloc, len: u32) -> *stb_vorbis #foreign lib_stb_vorbis; + +stb_vorbis_seek_frame :: (f: *stb_vorbis, sample_number: u32) -> s32 #foreign lib_stb_vorbis; +stb_vorbis_seek :: (f: *stb_vorbis, sample_number: u32) -> s32 #foreign lib_stb_vorbis; + +// 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(). +stb_vorbis_seek_start :: (f: *stb_vorbis) -> s32 #foreign lib_stb_vorbis; + +// this function is equivalent to stb_vorbis_seek(f,0) +stb_vorbis_stream_length_in_samples :: (f: *stb_vorbis) -> u32 #foreign lib_stb_vorbis; +stb_vorbis_stream_length_in_seconds :: (f: *stb_vorbis) -> float #foreign lib_stb_vorbis; + +// these functions return the total length of the vorbis stream +stb_vorbis_get_frame_float :: (f: *stb_vorbis, channels: *s32, output: ***float) -> s32 #foreign lib_stb_vorbis; + +stb_vorbis_get_frame_short_interleaved :: (f: *stb_vorbis, num_c: s32, buffer: *s16, num_shorts: s32) -> s32 #foreign lib_stb_vorbis; +stb_vorbis_get_frame_short :: (f: *stb_vorbis, num_c: s32, buffer: **s16, num_samples: s32) -> s32 #foreign lib_stb_vorbis; + +// 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. +stb_vorbis_get_samples_float_interleaved :: (f: *stb_vorbis, channels: s32, buffer: *float, num_floats: s32) -> s32 #foreign lib_stb_vorbis; +stb_vorbis_get_samples_float :: (f: *stb_vorbis, channels: s32, buffer: **float, num_samples: s32) -> s32 #foreign lib_stb_vorbis; + +stb_vorbis_get_samples_short_interleaved :: (f: *stb_vorbis, channels: s32, buffer: *s16, num_shorts: s32) -> s32 #foreign lib_stb_vorbis; +stb_vorbis_get_samples_short :: (f: *stb_vorbis, channels: s32, buffer: **s16, num_samples: s32) -> s32 #foreign lib_stb_vorbis; + +//////// ERROR CODES +STBVorbisError :: enum u32 { + no_error :: 0; + + need_more_data :: 1; + + invalid_api_mixing :: 2; + outofmem :: 3; + feature_not_supported :: 4; + too_many_channels :: 5; + file_open_failure :: 6; + seek_without_length :: 7; + + unexpected_eof :: 10; + seek_invalid :: 11; + + invalid_setup :: 20; + invalid_stream :: 21; + + missing_capture_pattern :: 30; + invalid_stream_structure_version :: 31; + continued_packet_flag_invalid :: 32; + incorrect_stream_serial_number :: 33; + invalid_first_page :: 34; + bad_packet_type :: 35; + cant_find_last_page :: 36; + seek_failed :: 37; + ogg_skeleton_not_supported :: 38; + + VORBIS__no_error :: no_error; + + VORBIS_need_more_data :: need_more_data; + + VORBIS_invalid_api_mixing :: invalid_api_mixing; + VORBIS_outofmem :: outofmem; + VORBIS_feature_not_supported :: feature_not_supported; + VORBIS_too_many_channels :: too_many_channels; + VORBIS_file_open_failure :: file_open_failure; + VORBIS_seek_without_length :: seek_without_length; + + VORBIS_unexpected_eof :: unexpected_eof; + VORBIS_seek_invalid :: seek_invalid; + + VORBIS_invalid_setup :: invalid_setup; + VORBIS_invalid_stream :: invalid_stream; + + VORBIS_missing_capture_pattern :: missing_capture_pattern; + VORBIS_invalid_stream_structure_version :: invalid_stream_structure_version; + VORBIS_continued_packet_flag_invalid :: continued_packet_flag_invalid; + VORBIS_incorrect_stream_serial_number :: incorrect_stream_serial_number; + VORBIS_invalid_first_page :: invalid_first_page; + VORBIS_bad_packet_type :: bad_packet_type; + VORBIS_cant_find_last_page :: cant_find_last_page; + VORBIS_seek_failed :: seek_failed; + VORBIS_ogg_skeleton_not_supported :: ogg_skeleton_not_supported; +} + +#scope_file + + +#if OS == .WINDOWS { + lib_stb_vorbis :: #library "windows/stb_vorbis"; +} else #if OS == .LINUX { + lib_stb_vorbis :: #library "linux/stb_vorbis"; +} else #if OS == .MACOS { + lib_stb_vorbis :: #library "macos/stb_vorbis"; +} else #if OS == .ANDROID { + #if CPU == .X64 { + lib_stb_vorbis :: #library "android/x64/stb_vorbis"; + } else #if CPU == .ARM64 { + lib_stb_vorbis :: #library "android/arm64/stb_vorbis"; + } +} else #if OS == .PS5 { + lib_stb_vorbis :: #library "ps5/stb_vorbis"; +} else #if OS == .NN_SWITCH2 { + #if CPU == .X64 { + lib_stb_vorbis :: #library "windows/stb_vorbis"; + } else #if CPU == .ARM64 { + lib_stb_vorbis :: #library "switch2/stb_vorbis"; + } +} else #if OS == .WASM { + lib_stb_vorbis :: #library "wasm/stb_vorbis"; +} else { + #assert false; +} + diff --git a/modules/stb_vorbis/generate.jai b/modules/stb_vorbis/generate.jai new file mode 100644 index 0000000..3557070 --- /dev/null +++ b/modules/stb_vorbis/generate.jai @@ -0,0 +1,180 @@ +AT_COMPILE_TIME :: true; + +PS5_SUPPORT :: false; +NINTENDO_SUPPORT :: #run to_string(getenv("NINTENDO_SDK_ROOT")) != ""; + +SOURCE_PATH :: "source"; +LIB_BASE_NAME :: "stb_vorbis"; +LIB_DECLARATION_NAME :: "lib_stb_vorbis"; + + +DECLARATIONS_TO_OMIT :: string.[ + "STB_VORBIS_HEADER_ONLY", // No reason to export this. +]; + + +#if AT_COMPILE_TIME { + #run,stallable { + set_build_options_dc(.{do_output=false}); + options := get_build_options(); + args := options.compile_time_command_line; + if !generate_bindings(args, options.minimum_os_version) { + compiler_set_workspace_status(.FAILED); + } + } +} else { + #import "System"; + + main :: () { + set_working_directory(path_strip_filename(get_path_of_running_executable())); + if !generate_bindings(get_command_line_arguments(), #run get_build_options().minimum_os_version) { + exit(1); + } + } +} + +generate_bindings :: (args: [] string, minimum_os_version: type_of(Build_Options.minimum_os_version)) -> bool { + using BG; + target_android := array_find(args, "-android"); + target_switch2 := array_find(args, "-switch2"); + target_ps5 := array_find(args, "-ps5"); + target_x64 := array_find(args, "-x64"); + target_arm := array_find(args, "-arm64"); + compile := array_find(args, "-compile"); + compile_debug := array_find(args, "-debug"); + + os_target := OS; + cpu_target := CPU; + if target_android os_target = .ANDROID; + if target_switch2 os_target = .NN_SWITCH2; + if target_ps5 os_target = .PS5; + + if target_x64 cpu_target = .X64; + if target_arm cpu_target = .ARM64; + + build_dynamic_lib := true; + lib_directory: string; + if os_target == { + case .WINDOWS; + lib_directory = "windows"; + case .LINUX; + lib_directory = "linux"; + case .MACOS; + lib_directory = "macos"; + case .ANDROID; + lib_directory = ifx cpu_target == .X64 then "android/x64" else "android/arm64"; + case .PS5; + build_dynamic_lib = false; + lib_directory = "ps5"; + case .NN_SWITCH2; + build_dynamic_lib = false; + lib_directory = "switch2"; + case; + assert(false); + } + + if compile { + source_file := tprint("%/stb_vorbis_custom.c", SOURCE_PATH); + + make_directory_if_it_does_not_exist(lib_directory, recursive = true); + lib_path := tprint("%/%", lib_directory, LIB_BASE_NAME); + success := true; + if os_target == .MACOS { + success &&= Build_Cpp.build_universal_macos_binary(lib_path, source_file, type = .DYNAMIC_LIBRARY, debug = compile_debug); + success &&= Build_Cpp.build_universal_macos_binary(lib_path, source_file, type = .STATIC_LIBRARY, debug = compile_debug); + } else { + extra: [..] string; + if os_target == .ANDROID { + _, target_triple_with_sdk := get_android_target_triple(cpu_target); + array_add(*extra, "-target", target_triple_with_sdk); + } + if os_target != .WINDOWS { + array_add(*extra, "-fPIC"); + } + + if build_dynamic_lib { + success &&= Build_Cpp.build_cpp_dynamic_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra); + } + success &&= Build_Cpp.build_cpp_static_lib(lib_path, source_file, target = os_target, debug = compile_debug, extra = extra); + } + + if !success return false; + } + + options: Generate_Bindings_Options; + options.os = os_target; + options.cpu = cpu_target; + { + using options; + + array_add(*extra_clang_arguments, "-DSTB_VORBIS_HEADER_ONLY"); + + array_add(*library_search_paths, lib_directory); + array_add(*libraries, .{filename=LIB_BASE_NAME, identifier=LIB_DECLARATION_NAME}); + array_add(*source_files, tprint("%/stb_vorbis.c", SOURCE_PATH)); + + generate_library_declarations = false; + footer = tprint(FOOTER_TEMPLATE, LIB_BASE_NAME, LIB_DECLARATION_NAME); + + auto_detect_enum_prefixes = true; + log_stripped_declarations = false; + generate_compile_time_struct_checks = false; + + visitor = stb_visitor; + } + + output_filename := "bindings.jai"; + return generate_bindings(options, output_filename); +} + +FOOTER_TEMPLATE :: #string END + +#if OS == .WINDOWS { + %2 :: #library "windows/%1"; +} else #if OS == .LINUX { + %2 :: #library "linux/%1"; +} else #if OS == .MACOS { + %2 :: #library "macos/%1"; +} else #if OS == .ANDROID { + #if CPU == .X64 { + %2 :: #library "android/x64/%1"; + } else #if CPU == .ARM64 { + %2 :: #library "android/arm64/%1"; + } +} else #if OS == .PS5 { + %2 :: #library "ps5/%1"; +} else #if OS == .NN_SWITCH2 { + #if CPU == .X64 { + %2 :: #library "windows/%1"; + } else #if CPU == .ARM64 { + %2 :: #library "switch2/%1"; + } +} else { + #assert false; +} + +END + +stb_visitor :: (decl: *BG.Declaration, parent_decl: *BG.Declaration) -> BG.Declaration_Visit_Result { + if !parent_decl { + if array_find(DECLARATIONS_TO_OMIT, decl.name) { + decl.decl_flags |= .OMIT_FROM_OUTPUT; + return .STOP; + } + } + + return .RECURSE; +} + +#import "Basic"; +BG :: #import "Bindings_Generator"(NINTENDO_SUPPORT = NINTENDO_SUPPORT); +Build_Cpp :: #import "BuildCpp"()(PS5_SUPPORT = PS5_SUPPORT, NINTENDO_SUPPORT = NINTENDO_SUPPORT); +#import "Compiler"; +#import "File"; +#import "Android/Toolchain"; +#if OS == .WINDOWS { + #import "Windows"; +} else { + #import "POSIX"; +} + diff --git a/modules/stb_vorbis/linux/stb_vorbis.a b/modules/stb_vorbis/linux/stb_vorbis.a new file mode 100644 index 0000000000000000000000000000000000000000..08bbba39bdabd6508eb5ad7428f111b13efbad8a GIT binary patch literal 110362 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 K3&|5d1z82giU#KQrUtU87J*ni~h# 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

tjWG|pXn1GzH)zv1nH5v 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 literal 0 HcmV?d00001 diff --git a/modules/stb_vorbis/macos/stb_vorbis.dylib b/modules/stb_vorbis/macos/stb_vorbis.dylib new file mode 100644 index 0000000000000000000000000000000000000000..f6231a8d9576e105869438ff82c188f32349fbec GIT binary patch literal 220856 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�xi=4TKegY3Xuq9s_ea~k2fqF-)@SYpFLjg5Ft=maK=KNfk} z#gXl|$e6M?7OAE&k$4!&xgCAaS|`AGj=SY$osE$1^YprIonTCv?l*M;vZIZMP7sWC zYQ}s-4(#_iNE^gCPqpr|wU@dghoVl_Wivvjq4hi_^kpiqt0>E#B-;+;iy+KV2(rA) zN|uMrWFyOW>pWOzZ_Q7p9@i;zP`)XgOYRgw58~JSSeNVg$6b-%iL$(94g=rzu#VGo zp)2wlwGGN-`PK=@OEgwncvtFqUCTw(FA(xRtw-vS9{SLEA-#u%hdIIT4E#uTx=Y@N zpGDq3fpS~qeUkAy_jN(l$D9jfuYmb-58MUn@+H<7Pr<%_e4p;F&n0^q$!4TKG(mqL z{s`M8??-lM{!AgV9izQXuxpc_3ASsrK}+zIE}SXDJn5VCy&tK~UJ~t2h~ES^$y%5@ zy`h=ZH4A6(dTvf3o3y7?Gb2}D1K^Ans>e~}XSW^x;{1I~nD*|6m_*S;0}hV+L^7zpXFHr8u8x^5^xPtwZ29n*ZB*w2pxE7Mf$U(BV|L z??s2rzd?u1plhdoC%ghSIS+60|MzJz;J-kNP5(t&q_z0JM~lH$v`BL<*0ku>3oY8> z$(lA!5Di-T`@cw!vU||uOK2CO$7!HP)i+(e(j(?0yXo;K?C-MBqY3nQ$ci2{phpd0 zS|4z=vn%osaC0u$tA_`+(Y3!iv$f@T-^TlAJU8%M$MZS){my;^x--YJH!1+MEQ4JD zauVz_Ugm%$SObkY;>nmJrg>p!-1R->KIT3J=R8kcrNX*b=czP5+zkFschl4T>`qI| z*U)_MG+{n?mGyjZJm-3{K}vhsVDDSY4#Z;)c=9xVWAvNJHwQz$bw=7$&f6$cu=amo zpYkD`ftrbN;u>%`32E|DSbGB}xsd{StoE0r(}7|Ngy+6So=3f_bt-3Iej|qO6{l99xyi=wq3a2 z@bo*rX_GFDFuaU+hpaJ;shHsi-bpHnf#Dn)oITUNg6^h=o%Skhy@Ufx8R{g?#tg{r z8k`&B*H0CqsPUIG2Z;~X*d4U^`#T*Tt&oZSPx-XwVoa-my_E9v;k-LjFwWFD4>n@l zZC4>L+%etC=S69j3wc@m`Ml^G zp-`f{0mw_j4z@X}4sHgnc=!m?IjKVYYW(DtGNgm<JWYsa!hHlrpSkbM;X3OVZH5NUWnal?&^r4%ixOwbLe) z|Fv?5fw;$^{neC5TW(4RVxO!R_Da+K+M(EAJB&X+9P1y}(%Fs@+<9vWw}fHS@!A9B zjstH=y%09cDyMrMGz35pOd3XDXgo-*}{@A_!}na5k*YgJI7mH|yxM$PD=XElr0c0F(I2hLgD`@-%Y*PFR*pQ%d*-1+9!$)G`Lw=;vb>3> zM_!22BQM0m+}K0Om8`u2Yj|ofR=)>+%Wwwfr_hf#K^A--PO9W&bT`fZ8{b0>56vk2U_Y6-ILmubP9^g(6$4HQG5Q~tBYh*v~RZJm{$Y7MQz&$ zZR>`%-HNt-8DrWqgw4RYJMI$I-bT0?+#FNwmAvI=Okr$X7GOF<`#i$dI579mTpUln zb!^nhFVOZsqRnHm&#%t#2$UYCXCrqxH>2n%1`#WwyS(D693n zw2!epB`G9)YEp=2>^OONY`EMlXq^1i0Cq6cMRhPVC{%vRg&i!cQ^;2(GoLV7guLhh zyi>T4_7oM;sd}dCi*%U#=F>?joj=k^e2VyV5~O2DSAldDJ=4A6(;8Z>ZspTe`?MC; zjYK*JpFMm!2c#R1bmd4_-ZNba(n-a1Qc5=p>H7HG;M4U%y2Oy>XxC4qjz+?D4c1|w zb@noTfp$ipDf$ZSybkRO+dIE*>CiH)Kf*ju6L?U^NBUOM1#6w1jLp@Lw0t=bdsvSL z899|gK5At}$jJJ|A#;@@8qeuTTwD?ocWq&acU-JIAudjy9uy%jK^o8CSb1b{ zoV+D2UOrT&l)n(1AdhiT$QLQc;Tz-RdjlfmTa^*=#c*fA?>l9rd{*!{d3xM9`HRYM zoFf^Iv)v-)YXU~e!@nLMvRpYzK4N8JNJ`vDxqo{?NJ=o?$KylZP)5s-21KL0N_n4H zrTkBH{v_%(GB!qD2zM6T69b~;$;v2sSWt{S9p}c4`*U1KvNBBWS05X)S$V(Q?{G}W z<^a4`DnkM}uASyej{(0lPVcFnV{S~D)3Ou&#RalW6L>hzo_VPDWS}vqzsxx0v*epb zmwvpAG>uc0t-!g#l^BOJAYW8sEX}}}S&8u!Jn~>=KfG~1-84t5co;+ZcvW~)JW5CL z9CTO*kFS3{oD_dZ$dt+{|Y)9@(D@qC-BLU0siuN z!zw~{%SOphsT_Q+)QpfHb#wHgah=9{3C_^-M_VuJ$3mDgR9*#nLgmPXR5~Uh4}nh# zc^nyi?>soGJpMMC&P8be4y!RAL$VE(-ye3UW{f2PD6`AE$v12KSbeP@Yj*}+<|57t z=(!;{_pLvkXYmx`>2OR5kvgY@jDS4l=qB+|Kn~%SOMM)HE9U0s(+FH0hC2!G4#+oB z=j6NN0>6A*w8LSzlko099i`4mcgIB-9~bcs!<~e82gzE_s=MRjn|$0V#DzNvZ<2)q z(LTge`8uIqD^ZU_)PAs)`jTE-{g|1TH=ql^)^QUyoK6K~{6i_E*Z%fiOR-Pd0sHVBu^+z=&UEP8^b5|Kq5TN~*;rra#vD%FeHLr=@-cSQ&^m&Vch+Gyz+P4(uEVbB zUWe`3oPm80KH@rTN<(`w>tHWLybcVu3$V~-5bgd)*8k&zyN#*zSP60pdz}$td zV#x4Xsh11w%hpM-e}waL8ILoiybo{m3ZVV=OWE+iT-@sgnw$D7!oVW0Cm;?f}olc>+oL+*U3? zAy3i=x6-{{l=oDO=QtZ<&Aswu(6cEo=dP}O!6-`x&W<8mbSLcLmb`gc1$omsAFpAL z=~duvIL@E&g*-reil}`|m>U8;@oT#U)GaAr6L`$e7#N1W z1Gys@dX9oi3ds`n6N|h?JT!xNBxEe&qm@=NRtE7`D;X;T;R;TLJbKD}#9vA8(~d2p0w+MPTQMsRl?2q!)Y+&r`#=lYRd|0-zam&J$qJIb&|XD#8A#(x>`NwS-s za9RYt67OK(HV^$j8@l5%;;B};BR@V3Qyr`XPBRYEcU9ebW95A!jzzt(au_?Pse;_< zl-xsZ&8R{;cLApvDEmsB3yn27#zyeYZkc=#T_I#s$;UQ3ZzPq{t=b>+uFzC7~Q zHtRgl#sqigfi~7uEkPbV+c=|2-b!OIwQ)w0y!Bm_Ws7ZjKnFd_gSIA~4ct9Mwpfy* ziI%PRmeAe;%U$uq*zb}EeIfV*i$5i-NU|z=+bqWBU zTvjoBQ`SuN*P(6<B{22lKxME$_?)^5t!k$gp;RybIJIkKEER071;2*Sy*ScI8 zm?sPa-Rkh>+9HhfJqhAj;*7%g$UXudead&~;RMdXVfwYdRHp~7Z!Gr1`JaJg7jT!> zS39uj4zpsWJ9;b9wytkXd&<-Az2&CHwB_D@XW{G~J+|FJfPKjW5gM|a>_?z;v5zkbL5=VPY*Wpu|5-Km3ng7C1NYK*N@ z(FRoSYuIlQq|@5#b2f;>?}OMxVXD*vSKU}7;dv4G_BHHd2-4}5 zbXIUO=9XRaR532NqXg|6Q33w$f-~}SI7a(14^TYF43T7msVEC<;bE-D3PfIN%+HdI zFc|Lp5I(KnlGRWm_QDoQ#_!xSdD#xOd|TRkm}8~2ha@{z0uPwW zJ4tI7U7?e%;9REC_qIE^7|GU-vCYI24Q}L#?;V7fj#_l zAR|A^xlJv4w6J9lY*g2!Zb1(z{_Yhf>F-ih7TV(0hdo3#5+9uJ{1tFR>(Hp}o2u1j zXV4TsCj~iD%{lRMB=sY@C)si*vTGl<_G?F+7l8-*``Q@5wr5B5xOWWo3cwyP6ZVi1 zAH;=G8c8ry^ncRgs~!;7pLz8mgTerBLD69p8k9Q zeZ!sdBN>RVJCzN#i6qRYH6jiNyhG;Popn8^{&{?78J@AIrwL(AC>yQmbOvpkurH1F zBl5BFPd_6EmX&;pamzCk=myjd)6kGjcy@Yq5cM$U{*8Iod6%qU8HX@=Hx0X zKraYU$ZxN1mp{zSmjxNlN8c}E1!qTt9p5~7B zZ9HGpg0%%xeVA+RdsX#b1C~9@+gNDLDxLj7ad%=}>ml&wO-TC=>gkL-<#SMuohWBB z%Gr#)dQ6MO+ZgoN27TF;)*A=1 zBJ5?Fl?ObmK-&^t8h#m2bPTx4e_*t+S;NZuAzr@XT`#Pmc4^?;ic%2&8`P<{d|{{V znJk+BNE8OQs_?(ka02&LWd294!goHJ+Kxq`djXUXj>Q1(wEq4OnWrRPJbReISO_`Izul6_4^ri z`!;}FH*diJK|=3}^{j>7Io7@es}`-f=1V=m@?YFA^7L*A5T1=6fT8Y9w7MH)4} zmydo-bHhZpPvZQLI>f&QTV!4T;l|nTN^Uy)2y=3aIA@m^ohdKe`+{`uV6Db{G5*iE z&!PtL2Yn#9`7`F!U&kGlBe7PN^0h9j557zB1|we?@`YSh{Fqe6=c_^+lAQHV2i)I^ zI#}{#VxG{;_PZfZ>`Q##5@z|{<4J5^6rMqNz8}JFHsH*9<0$ag3dzh$X{KC9GA-uB zZ;fIH8l~&v{qZf>5KafeZgc{3Zxyg7Wn%2pOP!2#r-cM=>UZFY>6~|CS~TV+Q^EI1 zU!`*k=YZdpa86SfVQy;pOHaMOp{Dt}#p92D7sp-wPUe;;cXAso?*MJ)Nay_zljVTs zHS+bSmjZoQMxvM0qs4-n8F}?p7Vek^{hcXb*N_m z>dE0e;EUmv2^5EW>TtrvA%a^{3t9CCX~9J!xAPY6HEEPSAKxfF8_#C>P3N}w4p5xa zq_Hi&(;42E!rKzq1?-i_vsrp3UU56quu1w{Jj1&qxH5q`4E^I2;G<(~Wx~Z#l?ffe zZ3zz$jIfSTZIFqF8pyv<`awL!9gnb!xNC&qc(^b5v?U}VjzXvDe`UbLo!M|-Mmmj7 zlXls^Eg=IiLs%tX3FcZW2guT{3`pK7^~PD--doZf0yg!RvAO><5N(fhHH{qRS~K8> z@(-Z$SBdqZdQcsxE>sUHKh@>Z0KuQH6T&QY8e~%^Ose&)6Ye~=)XAB`P)Ceayk8%i zdR;<2lBhoOxao=u{)W#6PTctv>U9P6tQ70lNcBS)wS!D5)T0VADxGz}?_nN@`@g>H zn)T(&s-~;hzYM3Mnq%@LhkMjk{r*7QPcMD(F^k@2)aeG+TbZzy2v?2-)bybV2-`X%){ z27YOB9%>v29wNgT!GkbobXGEC>Jap+b?8?M(66G=uNuKOE=q`RfFBIal-Hqbl-`DN7HSh%NgNX3O81o#yNBq|kharw?Fx%IFdo_MWIv1>ITUWu&B>qNx zrvo^ZfS(eNAzqn{yew&D7YEmG25bh+@U((0iE5% zeDW=vwMaair$4bD@^lKGLcHa&%fy|EGg)bj9qKp}^&DDS| zNj6}gNpOZ5+dl|&LwXp=1T;5q3F|-}t^KhNxT62eRICqgNMS{rA!j%Eu%c_Qw-bHI z`1KXHm873gI+=NuI=}vk)wXov~dg7yy+vY%idjxXaY{+vD!w%nPJ6Vvm% zs{07`+=`(yYb)-Xc>?F<1mhVG9ZJvDdDUUQxD)fn4btSIoUl6FTf>S1-0QqZ*G`3h z6Ta0Tl@$fxj11VTg91k$g9ycTPeJ)6(>e^Y?N>-=)ZF*v~Hu(hSp&<8e%ub_L5T8{fl@r1!1e$&BCQq0i9?y z;y^w>0QsEPfqTg3DSdEOw(Vu zu2dw_G$L;eXvYukAkZ`B0d9cKXU#`mq<1sit_SgL{J*L#43>x$aI&VtJ1{r;@{`I(3IX}R@$Dzod&fwmQ zHTcL(Z8cN$T7`iSLGp&e+C|8u~{A>5Zn=gt8yyd1m+X(`Pmq`3^e`6ABlU5GN` zOwLF;M~cD^Nw}gTNJDZnrL*kU{t0m{XOG$9NcPXJ{eMN9n))nSeQ|?or{5M?foh9e zLCO}lu?p1P5AKn0-}pz;&cg^B0ayX}Erh)d_gip}+a@cRvCXYu<~FynVcTSY-3lV% zZijya++lE^h5v_epM@LeUESz_PH+Aq`L1)RZvT{W*SS<#IFl-wKa*;qVJpt1Qs7Lg zFWeRzmb;bl=Ten;EWsI7mQ^%KsdT8s0ka5mK#tQWtL0X}D*JK^r{ zJvs5e{=F=mX+>vWv8Nl;l5x(}7f-*Ob_qOT`O{m{Dj{1PeR^Bka@d9yPj5<7fJan8 z4phP47Z06%iA+^X zZ8Hnh$aj0X{*EmQU5G>3f3dTlh$gu{GW5)jhBhMiTXUpc6*TBUV<`U z3|LELX@oth6k+7ALAqr4DG~M|@}fRWaVVVb7W0CC=8?+u0UYy`oWXh{ye;+@M)GrN zXg!Cwf(6q$*4sx~s`PJr##_a9^WR-1es@)t zcNpD;v(757Rjh3+mF-TPAI8?dYa7QD-ZM@|czveJvh>ro-!nz`jK`Gq$9ZQ~t{>6zb**!s*h%hJni;|(3t zGal&aQcYEQfo;4QHf>uvw*JzI%5<%5Jl(jS`L&I!mwZ~8{RXu}ey@0IBkMQU(V33- z`0nn=`eiFH?_?X#9NDvcyQAtiudhsp4BN9FqiyIuFSo*PICNLZY|;HC+*zXg3%CuUo9+@@BDycaT`Rgjf%|#U zP3QT(B)aK5<6WZr1Grm7_xo^z&+*@-xhx!{&AZ=$`=aPR4mWr-?@xP5e-+(yu0O^M z-oFj*VWOMvaT+DMUxPauZiazY0;7Wib7Xy3U-EztgCB!$Pd9A8h$Z}lm_j)DP+a<1 z;y_mAbECYV%OIjeBE`=^{Lx1$;Z68d;Yr+gCETh0`*7o4E+XF7Il|v-U_?ffcf`vd z-XAe_S6IZ1xP*wpKTVGCZ=4;`vN}8B;rx<_nue-~+b(qxYaG@@=vQxy7oo8@c5C>d2?EH%6vEvn?`QvnO)o)z-)hV~$6@ zmvlBVY0Q<#M`z0L=bngHuHKNU{BFy`%J4sBDGf7o9~a0c{3w5X6D?7W2z@)#ps-hW4KF|F(Z;|WBwenI%e_C4KZ0Kx5m6szdNR% zOKZ&Blw&b2lRk(U=YKio>(6e)-1m1D>o~?KHgu>*Y}50@V+XxDGWM?vLSvVF8yD+* ze`@U8qaKd^oXd(`c%&#cuC+4u+OXQ#w7@qH*xT?b|any|w ziDR0^CjMz)T;hqiNr?}RnUxrA)+8=}xiInBk(G%hWi^SH9;r{faQwx@o9DJ9=0CeD zak%-l#OLI1Cx#C=lQ`tVi-`%#uP46c!NwPBW#iW*yN?fk)oc8FZ6n6-nLl>?-V3qg zwcMof_g$Yk{^$Lg@jqu2jt3{eBm8)l1Sjzy;w8dQ;5Jg8`AGZHOX^4v+<5VS`<9eu zs-G+<&eWHvOSIZt_1t1jzLwqb9h1f8h9qXqFD}*^O4WGdHQS{Pv7_i-x5uJ zVV+iPn4h1iEw;*m&zJQG^-c8UzoRZG)fAWVdFeC;gEmi{Ie+e4ZL#3*8|)jPH8q~`%?OX;!yyf?N{s{F$FrCK%NVnIQ1Hp*#R za^Z7mrpI%iK+VF(F)B1(nkO~-JWXbv_VKbOgh-a$#H#B+Q~4SL%can}^0oR>_tzg^ z$mc{b(;Kq#=JVvEru-O6;HyaRO`EPxnLc46<2y}hfm$TdtOCBZiuLn!rDO6mC8Z*2 zvc(9Lv^?}-ku z>mSKBt}K#u2poxvhiIcjPRAUW)EkSuGWs)z86%mK zE|5vj1+hM(r!j8DH0Hc^Hseflm}KbVjJxs&Ch^oThZXafWSWj~4mnJ=FqcWqxlFP# zk4Z}ln1gaLlQu444rU|kd*K=8P`aK;PQAd`(H9x#+Q6ihFEK7-E9-On4d$Rb#n_Hh ztj~zk%yIb{#x8uoxQ!4Jub*YyoDU(;o@0)?KVp(C7Z}(2F>^G3%v?@=!r0YMm}}ve zjMaR}WTPQG#(&EkeP%#f?+ZLZ4D=yU(EhVyz>Wbs2J9HHW5A99I|l3+uw%fE0Xqil z7_ei&jsZIc>=>|Pz>Wbs2J9HHW5A99I|l3+uw%fE0Xqil7_ei&jsZIc>=>|Pz>Wbs z2J9HHW5A99I|l3+uw%fE0Xqil7_ei&jsZIc>=>|Pz>Wbs2J9HHW5A99I|l3+uw%fE z0Xqil7_ei&j)DKDFmNtHI1}ND_`WW_Z;NkPq!8{YzJ0~_Xz{HS-xI|54DtO3@vRfz zrQ*9%e6JAS>&5pL@x5Dow~Fs$;`@yFwjgi%ym>Q)Q&TKH_O~4ab`01tV8?(R19lA9 zF<{4l9Rqd@*fC(ofE@#N4A?PX$ABFJb`01tV8?(R19lA9F<{4l9Rqd@*fC(ofE@#N z4A?PX$ABFJb`01tV8?(R19lA9F<{4l9Rqd@*fC(ofE@#N4A?PX$ABFJb`01tV8?(R z19lA9F<{4l9Rqd@*fC(ofE@$>|6;)1k7W!-@!eHwwK_|eTT+^<&ejw!&>Pr8MQj!M zmXvC;aw$wbZ@#8D8=l!^dD-xupQ+B&8?v>e{1RQZrc}dx z9azT(q>;>J_oH+L#br$8z^>Qw$@#w>{9p5W39{O~kNz(IiT;`|NI13LP^vA?(`ug7 zX0sw>l2@Q9Ww|9fD*OWeqw0dWKwBx(^511f&Vg;@b6n2q}r?k zLv{)KtCUHI$X=F$(lz;NwA#E<9q_C!VF#tGk3hnn*@&L4RkH`?=Ak9;H0MkZwVFLI zA#zr;uOua`od^OyP(=LgzC#1N-A0^oJ1V&zvR-ywawa*W#&gC|X{%(PWR;|q+buJ@ zwsAGm&>tj~+!k(?^qA!6kgJk?L)S`INjC!e!J*aRs?!C@4~X;wm)9ZrLDnJNnDEum z31){5$vKH`&MaLUx8Csw>3T{0Ic{jpkfB?gWU_#OfDt3`=k6ctMEUvywKXcfnCzAa z>mC%~feu3Wjx+%d6yc3p0ZtU*5xD~Vpa^$7FTis}ICPx=FB0L>jRI^G;fzfJ{AUq9 z_p$)LB*N=W0^BUZZMy{cun2$ED!`vv(w`RK+m`s}1h|i*P#^D)1lU!C-TooK_lfZO z3j!Q0!Ye)&;4l$3i*SMn&-qjce_Vv$xh%j7M0m$%0{kZtPIUm%@q12$_qhqMNrcTJ z{H_QW4iv&a6X8>y0^B9S0fPm&Umu}!eMDF#!igfR6X7RBc$Ek*As9R-HA+Zd zE5dU`c$Wz4MEI};juqlx6X8k`{+VFlY&Rqd`Z>D_aEk~J7vWYB4ks9OIx4~#L?8b9zT)?P0gU3{zwmRxcx(-O+rU9KaI6hH%?4K6z;kWjTpPH=23}+X zSJ}WdHt;hx@N+isMjQAg8`xw6@3w(kY~VH<_)Q!59UJ%q8~7s|xD3s(7|#+sOYv0T zsl-!-XBnPqJj?Msh39EJ)IVzQ)Z(ebW5h$GuoBNRc%H>Ws>32Y<#_7x{NMTpvSz-_ zT0arQS8E?pk|n{Km$-Wi>#4Hz5<`^7twU@CW9uN2kuB!C*3#^aS1TTelS`K=-ep(Vdjs2-ue`)Nze-Yd`}^f&Y2H4$EI zvaUn7Z@0qLYv^4R!Kdq`wR!(;Wz0G+US+rSfQnD**!-k?WHeTjO3t^hr!5cVMSqQYWr z3900F;_*tX5ZdiK7m17r*h3J&UCFq($OXh3JGPQ&+#I|IJ z;`i*iVrqOL8XtAmQG_ZX!Br%BJ)O1f){fZnHg1I zugT*xhQ+J21h^oh5PeQ*!A7xW0aF{a3-LYeJl<5n2NO{Wm7wz7ajOjl>MTuR>HK1C zp{5j87nGaOmswB%1Ds$ED9O^~X^Pc+&Y~AkuFsy2ob*(;60JHvI}0rU)XXnbmui7V z(L{AuX4Hxn;|?0WPz%eBT2IMQDs5r7T943B&`v?2jX$u2LWm)j8W07Dn6_>pl)_Sg zl3YD<$|}wZABWNs0f9*u&M(#SMO#o%4D(307n#Sj*=pVVxpVV1JSv2!nyf5s9&AlL z0(s_)T<05zG#HgEcYa}*`bkaRd@V99EI?KHtTn|vs`RDmOxW#mOZ1BX&qpXyQ)&2c z8WD)C@HB*?!l+Uy?KUpld#x60Q;I#MyDT;xq`T$~rS~{zcVR3gUtwaf)Xn2P8uY{s$ekUy|`a7Yh@9%{2 zW$m^Z+m;F~Xp{E0N-OwVan9dnk=FqXmS&LsH9SOK0nc<3i*+((7J66Pv^_xk&No+XAA*=vgPqawzj{Q6ARa_m;r zSnlwdzy36>2n;r zmh4-y=&6qm8dGaWzxBfaD4S(`P`p5NgsvGNH4XeA@zcl!L?qX@!)&q}uJ)M7etjFMlVd=VuZ#_LPeZR}e zue$tPztMlNxHjqC3(sDPFuxG;?d|>_)kp4H_@~7)zx1s)8z22($cTFFu=`3s{&B)f z{klee6s|ZKeqhFHA0Jq~BWG6O zyGf_BPJ2clNc#1swK=;U8s^yNBj2a@9vpI|Ou1n5Gr>FGIGZ2y&s9$hD*8gv>T;%I zv+P-eZ>VO**RMRh{QiyYKc=y(yK~*Y%p2jB9X4*w*4OhQ>hIt8#Fflt>xTd1FPAnH zU#=^7G4^kNR4jkKc+ML)G8&)#;(WjPpYN-CVddgMKYn^Orq8Nhi`ER!yY=0!SNhhy zFf?Gv%hRt-nsoWo-0LlQpZIKPUrVSaW0V`>sn%Xa5qR3aKf5X4y0QE?gPs zGU*S0tK9$1(U8UuK6&u5A+om&k8Jqc?sdwylwPULfBL!YyZYr{Jvh%aySXW~Bjf?) zjxXL{GdOXe`G2mR{b0;yrx!MT)Bjw;g|lyYJDyE`N3zMMse1m*vy+zoc>0#Vsde^0 z{Vx{J>d61-Kc%1lH2u6I4jRo6&p|id|2F8O*x}wka0B2-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; + +typedef struct +{ + char *vendor; + + int comment_list_length; + char **comment_list; +} stb_vorbis_comment; + +// get general information about the file +extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f); + +// get ogg comments +extern stb_vorbis_comment stb_vorbis_get_comment(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. +// +// *output points into stb_vorbis's internal output buffer storage; these +// buffers are owned by stb_vorbis and application code should not free +// them or modify their contents. They are transient and will be overwritten +// once you ask for more data to get decoded, so be sure to grab any data +// you need before then. + +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. Moreover, 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, + VORBIS_ogg_skeleton_not_supported +}; + + +#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(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__) + #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 + #ifndef alloca + #define alloca __builtin_alloca + #endif +#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; + +#ifdef _MSC_VER +#define STBV_NOTUSED(v) (void)(v) +#else +#define STBV_NOTUSED(v) (void)sizeof(v) +#endif + +// @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; + + char *vendor; + int comment_list_length; + char **comment_list; + + // 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; + + // the page to seek to when seeking to start, may be zero + uint32 first_audio_page_offset; + + // p_first is the page on which the first audio packet ends + // (but not necessarily the page on which it starts) + 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) (void)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+7) & ~7; // round up to nearest 8 for alignment of future allocs. + 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+7) & ~7; // round up to nearest 8 for alignment of future allocs. + 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+7)&~7; + 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, (int)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; } + assert(len[k] < 32); // no error return required, code reading lens checks this + // 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; + assert(z < 32); // no error return required, code reading lens checks this + // 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]; + available[z] = 0; + add_entry(c, bit_reverse(res), i, m++, len[i], values); + // propagate availability up the tree + if (z != len[i]) { + 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 + if (pow((float) r+1, dim) <= entries) + return -1; + if ((int) floor(pow((float) r, dim)) > entries) + return -1; + 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; + if (f->first_decode && !IS_PUSH_MODE(f)) { + f->p_first.page_start = stb_vorbis_get_file_offset(f) - 4; + } + // 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; + len = 0; + for (i=0; i < f->segment_count; ++i) + len += f->segments[i]; + len += 27 + f->segment_count; + f->p_first.page_end = f->p_first.page_start + len; + f->p_first.last_decoded_sample = loc0; + } + 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 int get32_packet(vorb *f) +{ + uint32 x; + x = get8_packet(f); + x += get8_packet(f) << 8; + x += get8_packet(f) << 16; + x += (uint32) get8_packet(f) << 24; + 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; + } + } + + assert(f->valid_bits >= n); + 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&255]); + 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&255]); + } + } +} + +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 > 2) { + 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; + float l00,l11; + + k00 = z[-0] - z[ -8]; + k11 = z[-1] - z[ -9]; + l00 = z[-2] - z[-10]; + l11 = z[-3] - z[-11]; + z[ -0] = z[-0] + z[ -8]; + z[ -1] = z[-1] + z[ -9]; + z[ -2] = z[-2] + z[-10]; + z[ -3] = z[-3] + z[-11]; + z[ -8] = k00; + z[ -9] = k11; + z[-10] = (l00+l11) * A2; + z[-11] = (l11-l00) * A2; + + k00 = z[ -4] - z[-12]; + k11 = z[ -5] - z[-13]; + l00 = z[ -6] - z[-14]; + l11 = z[ -7] - z[-15]; + z[ -4] = z[ -4] + z[-12]; + z[ -5] = z[ -5] + z[-13]; + z[ -6] = z[ -6] + z[-14]; + z[ -7] = z[ -7] + z[-15]; + z[-12] = k11; + z[-13] = -k00; + z[-14] = (l11-l00) * A2; + z[-15] = (l00+l11) * -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 propagates 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]; + 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 + STBV_NOTUSED(step2_flag); + 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 + + STBV_NOTUSED(left_end); + 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 = 0u - n2; // start of first frame is positioned for discard (NB this is an intentional unsigned overflow/wrap-around) + // 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); + if (w == NULL) return 0; + 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) +{ + // 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 (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 (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 + f->first_decode = TRUE; + + 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) { + // check for the Ogg skeleton fishead identifying header to refine our error + if (f->segments[0] == 64 && + getn(f, header, 6) && + header[0] == 'f' && + header[1] == 'i' && + header[2] == 's' && + header[3] == 'h' && + header[4] == 'e' && + header[5] == 'a' && + get8(f) == 'd' && + get8(f) == '\0') return error(f, VORBIS_ogg_skeleton_not_supported); + else + 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; + + if (!next_segment(f)) return FALSE; + + if (get8_packet(f) != VORBIS_packet_comment) 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); + //file vendor + len = get32_packet(f); + f->vendor = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->vendor == NULL) return error(f, VORBIS_outofmem); + for(i=0; i < len; ++i) { + f->vendor[i] = get8_packet(f); + } + f->vendor[len] = (char)'\0'; + //user comments + f->comment_list_length = get32_packet(f); + f->comment_list = NULL; + if (f->comment_list_length > 0) + { + f->comment_list = (char**) setup_malloc(f, sizeof(char*) * (f->comment_list_length)); + if (f->comment_list == NULL) return error(f, VORBIS_outofmem); + } + + for(i=0; i < f->comment_list_length; ++i) { + len = get32_packet(f); + f->comment_list[i] = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->comment_list[i] == NULL) return error(f, VORBIS_outofmem); + + for(j=0; j < len; ++j) { + f->comment_list[i][j] = get8_packet(f); + } + f->comment_list[i][len] = (char)'\0'; + } + + // framing_flag + x = get8_packet(f); + if (!(x & 1)) return error(f, VORBIS_invalid_setup); + + + skip(f, f->bytes_in_seg); + f->bytes_in_seg = 0; + + 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)) { + // 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_length >= 32) return error(f, VORBIS_invalid_setup); + 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) { + int values = lookup1_values(c->entries, c->dimensions); + if (values < 0) return error(f, VORBIS_invalid_setup); + c->lookup_values = (uint32) values; + } 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]*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] = (int16)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-1; ++j) + if (p[j].x == p[j+1].x) + return error(f, VORBIS_invalid_setup); + 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 = 0,hi = 0; + 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; + if (m->coupling_steps > f->channels) return error(f, VORBIS_invalid_setup); + 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; + } + + + 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); + } + + // @TODO: stb_vorbis_seek_start expects first_audio_page_offset to point to a page + // without PAGEFLAG_continued_packet, so this either points to the first page, or + // the page after the end of the headers. It might be cleaner to point to a page + // in the middle of the headers, when that's the page where the first audio packet + // starts, but we'd have to also correctly skip the end of any continued packet in + // stb_vorbis_seek_start. + if (f->next_seg == -1) { + f->first_audio_page_offset = stb_vorbis_get_file_offset(f); + } else { + f->first_audio_page_offset = 0; + } + + return TRUE; +} + +static void vorbis_deinit(stb_vorbis *p) +{ + int i,j; + + setup_free(p, p->vendor); + for (i=0; i < p->comment_list_length; ++i) { + setup_free(p, p->comment_list[i]); + } + setup_free(p, p->comment_list); + + 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 &= ~7; + 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; +} + +stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f) +{ + stb_vorbis_comment d; + d.vendor = f->vendor; + d.comment_list_length = f->comment_list_length; + d.comment_list = f->comment_list; + 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)) { + *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; + vorbis_deinit(&p); + 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) + ((uint32)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 preceding 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, last_sample_limit; + double offset = 0.0, bytes_per_sample = 0.0; + 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) + last_sample_limit = 0; + else + last_sample_limit = 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 (last_sample_limit <= left.last_decoded_sample) { + if (stb_vorbis_seek_start(f)) { + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + 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 * (last_sample_limit - left.last_decoded_sample); + } else { + // second probe (try to bound the other side) + double error = ((double) last_sample_limit - 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 it wasn't an interpolation probe). + if (mid.page_start == right.page_start) { + if (probe >= 2 || delta <= 65536) + break; + } else { + if (last_sample_limit < 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 should start with the sample + if (f->current_loc != sample_number) return error(f, VORBIS_seek_failed); + 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; // NOTE: not used after this point, but note for debugging + 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; +#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__) + if (0 != fopen_s(&f, filename, "rb")) + f = NULL; +#else + f = fopen(filename, "rb"); +#endif + 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) { + if (error) *error = VORBIS_unexpected_eof; + 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 STB_BUFFER_SIZE 32 + float buffer[STB_BUFFER_SIZE]; + int i,j,o,n = STB_BUFFER_SIZE; + check_endianness(); + for (o = 0; o < len; o += STB_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; + } + } + #undef STB_BUFFER_SIZE +} + +static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len) +{ + #define STB_BUFFER_SIZE 32 + float buffer[STB_BUFFER_SIZE]; + int i,j,o,n = STB_BUFFER_SIZE >> 1; + // o is the offset in the source data + check_endianness(); + for (o = 0; o < len; o += STB_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; + } + } + #undef STB_BUFFER_SIZE +} + +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 = NULL; + 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; + 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; + 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.17 - 2019-07-08 - fix CVE-2019-13217, -13218, -13219, -13220, -13221, -13222, -13223 + found with Mayhem by ForAllSecure + 1.16 - 2019-03-04 - fix warnings + 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found + 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 '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/modules/stb_vorbis/source/stb_vorbis_custom.c b/modules/stb_vorbis/source/stb_vorbis_custom.c new file mode 100644 index 0000000..2eb0116 --- /dev/null +++ b/modules/stb_vorbis/source/stb_vorbis_custom.c @@ -0,0 +1,9 @@ +#ifdef WIN32 +#define __EXPORT __declspec(dllexport) +#else +#define __EXPORT +#endif + +#define extern extern __EXPORT + +#include "stb_vorbis.c" diff --git a/modules/stb_vorbis/windows/stb_vorbis.dll b/modules/stb_vorbis/windows/stb_vorbis.dll new file mode 100644 index 0000000000000000000000000000000000000000..336980d714ae24f24a3aa263902f36a75ba1d5cb GIT binary patch literal 250880 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

se^YvDY?+c;u_lHGCH{NQ@^SC(S8{R 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 z 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 TGR^^AO~K71^8d^K$OHccrCaDA literal 0 HcmV?d00001 diff --git a/modules/stb_vorbis/windows/stb_vorbis.lib b/modules/stb_vorbis/windows/stb_vorbis.lib new file mode 100644 index 0000000000000000000000000000000000000000..5d5b82047985d6a24f2724dfd3b969dedee2bc1c GIT binary patch literal 152016 zcmeFa3wTpi)<2v!5ermLsvSi|i5i_^8SPL;i$Tq46F8?$N|9TOMXG@c4wp_ZierJ6 zv_d=_#PL2l%BV9sqpvzM4xpkoEzkl21-yVdT9I)IWwe4XmW$;3t-Vi@_VlC;e*f=z zzW?(W$jLr?|MuEzuf6tt?cGbq+*a9>L&W%Rg> z9_10gSy5`TGe6s%@5#w^Giq}QGm9Sc>2Z^NtcQMot-Wy0!hCv}FMG=*XE!GEoOxb% zj(fZ~KFp*{2u@UspEFJuA6dzbdfj9wh>R%fc}|bJK*}o+b66Ttu4fVvCRdjE1@y{f z5s@$xPb2}xPdCEjojJ1T9V@!W8OkKgJ`;OSB1}GvI7>c!LgA%nq3}1zE}EF^9AA(ldt4r#AEtIU_0SZS z0;5++M42d=#8@^MJFMu~D+^$dJECdiIkO9prR?!8CbR#K(iopVE_a+OSB#Ygt4CFo z1*Yum5!DNpH@icfP4reB!C($gP zJ`<6&T(VQnmJ9OTxxD9b3$uvn~^Sh=ti?~bJ57M-4gT-j3~=Kdenv73GsO(e%D7kKc=G$hfPC!r_sYW2jRon*9FiLpntmEzhEGdS9aArVhO-nhK+<6<`WECZ~J8LOy2ADZ=O?&m#O`Z)P8@d{bnFKhm|6KvAvIZ ztXaSAPMF?juu|&fTTyvi&!VZQL_0Wd29)rQ%Gt=<3@x)gV)nv7cjwQnFrDsNLFVXD zBl)sH$)E%*7NptOf`KXF|9Ag>nxX$RLub>T@ib;*Lk~8_W3Mjq`)P(Q{=ZxW_-Td? zHDVJW-871gpV>6$rx`k%WH4Do=OIy<{WL@GKKqY3gZ^oTF8(w_*A}*anxX$RL;q=p zuFcrH&vJg6p|g2Cn*qm~a2HHC79kh z0}BB7Ts^ZKOCxv9;%_F?f6OM+%djHo@flKSCtOX@{oD)HE9JmJH0>H`R;lRg&uMxeK$j5Jh3Ej+KSm7|n z-95l$8i-ug6mcAh#faWbi6+zEf%*0pj*FGU#M zFIKr-48}JD^VI_!2lY0T-;M<2brtmaL5{<#A&%sKLc?&RG0u%Z%kNMx@ud&MX-My3 z_)iDsTMZYh+(v+*%O5hC##01*VwFb#VRsYe5kkerNeD{=rcA@d$}g42Z-IHdAKdf6 zJqyg(N8!LHRzBt$4#cQf6sBT%IyjS=V};^G^R(@X8~|u zY1mlhu@1Q7!2JD5PAyhGRwH;nFm+FHT&(iwKt5j9FdS*j-*3UtV^4<>{MSe>6Vbk; z{Ly5ZNdm_wRz4CCun?Gg{>*WRW+-PD{2v46lYVfdaL0f-_E%0XH3q%^6-=h!OQ^$d zaa^o=DM2pT>rJNn-{v^H8uIr#{2$gZ9BGU@j6mrfwBzq`6dC^+$m8sol0 zU?XsA8aQeIevIfXt-GVk^|hofl1rW>BYj?5Iho?oBP3y2Cf*GNBY6d0PY!JPHDJU`G8nV z=j_0v+s8;Qo1m!Y1NW~Z90=7ml;4fWpnSq)T6U7-h`td$Dz`U)ssEvG+;A|y7MQjW z$Hl5gS0UJCN-)jGmp-xby9B{Yfk{Z@xU+yY;%_Ag_<>0|gX3b2b8->OKe?4$FB=?<IYW?Tyjc+X$8LYiB&&}5d01>=by`QvGmUe8ovSN zeGL~&&J#iAFfi_)ae7IJXC!B;zmEX3`#g?|H6D5a@h><(!PI~+ePYpD1ct0b5=`nv z9CtpjM(Iv~f5p%Q(*}I$6HCs65wHiCFE8OZbnk}rM!^4`VF{)`;Y%NS8l_A1?Ntp! zIQkgjvfDZccHmEY@EZi{A`yQC{XyArVM1BjIH4yWo2kGTi8Yb-Nv}QQ3 zF6)Vdm`x*ryHUeZx(sJPuQ*P6Gl47Xhu%=6vl5uUYBiX zdYl2h#M}ha+4#~Yk`Em{E5b%-7zV^6mi)#5C-p;*%C{7lrFxtJf2)CcS&!54NA$J; z^OYWFK+lqwV6x&%pT6>YH83~oaR&5?ftjtx>G&i4yHCTggz<Gy3So!@cFl+juNAi1L!@$Wt zvFNn{cc>qFR6hoJxlA;2G5Na;xT`g6EPbK;dVra&;rhyNIWUX+p-1h(QyQi}{$2xa zeLwW5{(c-My@S9V?S~%qAF28A$!{odX&N?`{3yR;ftjY^`jX#FV9NTTN9DT`m_O@r z2Ku}Km{vVbr_aRS*T5u>=Xs9g!+@R*m=SuMjvkdqE-=&dI0JeMfvMBu4Cp-z%-{7m z1A48%e5%Lk=u!C|*D!FhPptZuSb+WmU;0GkqN7LkcZ7yvKs;j6%L2~T4?QZ6+kv@D zk2A>c!@#W8<8=HHy?21wrNjdVc9%n%B!U^%!kE?;ZUc<(cAL(;pob<|otL}#$ z<@fh-(t8ECH~XPS{OtjzQ;#!{-`O`~-iR-KV&#|WM;0)W9%n$W6qs^7PFEg8Zd1Rw_3yWm)}*uJrxJN zH-Xu%#~JW<2$(KCPRAeV-+7Z0OjqJdpNJk9&~pJ(pvURxQTse!!!Uw)#46vrfLq!R zy%C7N8kqMq9B~xUlkXPUzEN>2L3qL&0*s)mio#UQ^UzaAW(SNA1%Dde~y#hJHTz}haQb5+vB8XnTq)gzVwMDKWY!I1}0mNGtj>hVCL#^y7I7r z-u=M*RgW{E*82J*#2B zD*MFJ=f4B@PCxW)pztX$C-pc3{w~C#=asbZiBGKZCHc94nWV=V&?^UKu^y+(FOAop z(lC@RePZSJMc`iVhu#>(-v!Ls({%YT;BN#lS$dp~Kg#bEU`q8k1A2A9tkUCj^r$^} zMZ>_!KC$w<3AkPT(6fO;CotAq`p@sxz+A7#>G-4iTL{ctJeOnwSy+?t2 zwjX+w--bBpwE*{i9P|#yN$)st18&vTb6x!){_GkCPWFjaKSltT)ek*t52nOP?@r+E z>W3cj_i&u_o&xU0IOuJPliqgVKJJGe=}T9f^sF-yOhfUdPha|cy@p{xJYtncHgNg< z(4+QcZk+TM0$0}$Ju2U4fmx%+8MM#u1JkC*>GY52odV{Z5}jNO=w$#iMvpU~Hw~Ei zdYl2h6~H{M$LZ*i{;kn4aI#OV@^}ZhE&b4={IF81ayA+t;>2U`1UIS*m9%n%BV-3TEhes^=9R%)ZKlCWSskd{P^hYlZxKSE5 zR(+%S%+0{e*W(QGy8@WU^*Dq4t^sC~9%n#rKQNtooQ@u~FK7GW%kP!IjnuHQ@=Nk7 z0A{8hXTaZ5U{>mJI{rvsUIu2p9%n%BV_?40<8<_Fpl6vGUw-YtWoXz~`6c<~$4Rdg zxblAJk^EKx^SmBskl#jNw(D`a{F3|*0drE1GoW|jEX=p?rBAHpX^4M6Fn`x@lzJ?B>w#(MhaTnkD-8oD`^2Jm6u89FzVl1`*))tsE+&5xaFhC> zNBw1aob(n0cYhr8UW}98>%cYiLvIxL`wWC0sr22S>gr7t6ayRjd7RDX+sDbwQ&^1Bk4 z-|KNY{%oMP4wyZ9oB_R~z$DJ;Kfg9$GW0kDdilUi)8lmfk^B|{vs{lep!a8B{;tOv z&}-E&Ak99p%A*aqL;cXB_G-|bXxH$iPo!Nl;Lin2fgY#hkIHvGFiZ6~1A420d0CIs z(SsSSX$vr4Yq&o385qm2b@|ZIBmOSaFmSR@EcsmvTy{V7sC-M}q*n%9bwBiozuyD% ziXLYmzxROIqsQs;Oa1RrV9uValZyep5x`{WaXNaG-zmV9>Tw42>VR3L#~ILj1(~d1YAi!^qio#7?^i7TwnU! z0?hmU(4+a$VGRQ(`^3ucao`5b*Xe;SztkSsfpO|_2IX-pFn8*4I(j6(<-k0p#~ILj z6PQhUoQ@vp^L}7X>Tw42E?j_i4PW}iDqqrP7ci6bI0Jg+z%16|bo>#$r+|4`k29dR z1(*-@I0Jg$0b?oC<->s9Wx!mm$LZ+N_{yVU;AEdz`ceqo%zo(EKw)W|^qvLol{o0V z2h1T2*H`^G3QXc}baK(zeLZbVc=w+Smm1m+?amoWq`u8IO*LF+@t-_BmH|lPI?W%y%z_) zgK^S33S44E-|}Pn0!)^M>r-EV$?u0AjbG*hvr3OMDBo9rc~g%w(3d^HwCiyO^afO7 zo`NrZVzqzN-e&;g(Qtj`cM34K$3d?Kn5XnO1ODCwW|JOgkl+2le5c15&^xCp!E_0} zedU+RcZ`N%Ks;jAk4eCl^h1x@gT-;u`yFsk$3bsBFs*u=L4Lmm=C~fGlOORnOMdYl2hXMuS|k29e69x$KkaR&5`12f=mT|REFpd*~o z4;@U>eQHbv4OjO(zF=AioL!?8hC2yY-V-e( zfjb+xv2oz2eVG&oj?T9%i~~pccr*^&jlgY)14ri!6BqR_7g|Re5eJUWwM~ixHv+gj zMM?z3LF-sM{cTvsn#Z+e8Ay;v`o-Z(l(wI@#8g-iOU=K{UrIB=BT z)xB`N^GoIXW*j&taQl1VdgnI_ID3sgAHCE4D{#fVaJ}hKdpDp~PcNfay(GOF*bCP? zT{Ih}VZCs@=@IVoIB+z7`*|;1?{o=wO`N#v;=mDqH}%5x&IhHN(+k&|Kcbh{3ujDk zd@o#YdeqNM?S(7oRc?g4BTn4iapIQ6iF+(g+zWBy*2alzjuZD$oVfqQiTmCN=bQcO zifc!q6!>QyI<7O9_N;Fv9O|^$Y}dHlW5vmyNgg@-`pfXh@lLv|r{{Q&D_``wC&JrZ zSTO$PN!NF~G%9>qSgbJZI`UY->{@c8Kz31^Q2-^#udmi_E{_H3cDcC`q{l_uMu70$ z?L97NHv;y&kKG6nCZ$~i-v@+W2yO)Eb{kpD;P5^3eFFLn3}0bx1d84`9xF7K{|t5` zxnXFpTgTZo@D=f4`3>bpSkjViSJ?Lr>2(`k9Pn6>@HO)6ruyzT?8OzKKTzD9hS^{d zY}5^Wi|;~wuQw&otqZ1{>x=K0Q(1iHZF7p}Etpv~cUDDlv|4v_&hSOAg}dG~CdG6+ zuFW!?Yr4WTy2cdw_0I8?FQ`~hT4_tWdAMzSS>>F0bACH#{vEcQ1@p?F_T{FUdoD7$ zlwBUBD6J|<_BDusRDYAO#$`{FeLLNO)Q2QRPFijmBq=U?hAUuM)uaS#znDCE@&`NH z&6}@)WAfmj(h_V>yn_C|L+uxM90`7rIJiX#1`k-S5CkDq`vsmtu+1_!D6}*=CrbW9 zHc1hklCoE-Z>Y?W9AZJm^}?DYDbyeZa-22C##jAHQgWOWI!bcn6jTh2hIWhuOBwAX zETzTY6{>1&_CJmnYDO~~B>x86ElrY=*9}qmS6RKAs!E=l>Av)o$W zaL*vdXU2?MZ)sA@j!r2s*Ipou@AL#J?PJRuaN$KC`sw4hDqYkesos`nQk%I>kC3UJr4h22xU6y<`RVAP>%muWP zW0Tb6^Nt9Go}`mPS`d!xlShOUdKBhC201o3l9PB)B0})h0%Y?h3bSg_EEEk7EmSgZ z>>ip#p-Gaz(aI3A|3E@jt=G{is55YqK3^Tmxc8)go~x!l=1p&;lylYO3yDTTx70y_ zry={>6RP$exD>I4sk=nwVEs{H<QNVUWh zsJ7ek)iFFp)xJ!%q)5J&@#=`{WYw}#a&+B2(ChfO;9mzZ$&O?6_J!c50kg8{3f%ut zv*^rFi@&8a)R5i@cK<*_D39-}d^PzGHaMv$Izyq5Cp{#keLRvNwA8Y zl4?2IztNg4Sd%kyRm*4@G7$>52!$;|irgt!6IcjPgTlT85sl-)-@vf1Y=yUtfg@fv z$scrj9q(5^>QN}C3guZrc0Ilin6T-VC|N;`XtK%ajS!r~G>9(O@G31~CGw_k2`do_ z%0k)${+S}Be}f$VPSd6FYU=%xV&)oTbtRF~G~%nN5Q2^%mnizeE%*+C3ZTs}Grh4| zND&yAD-O{imFX4`)fuKPk01w&Mj5G!nQMyGlAzIKib|@&wB$37f=aXwDglK@wL+a` z_3RvYWWv{Ck^;q$QNU#%A_YA5q{&mJij&02;uMi;Ye~&-FEF9TdX)9{21M~Fhb84@ zdkb?OP!fgVmG%O!?3Y^DG%FQ;j3(ODJz&Hl}*B{+eP8kM$x=kH1BY@k)hL|-LE$6vtFnF{11ho-bYbaA&NeyKvNLU+H zA8Hv{Q%OEq!Z4>PQa-XW#U?A3lSf3MaMU@}C8Y>y)EZhIhmuWq_RP)2G0~rO_W%Y zsLCKFgAf|`1h3$3aj7#Bh?oRoAn>_6vjG53E!czFaz<@=lv=U~8jkH=RZMWJ_Y$?B z1j>vb@YdoM+$R{LVD3H8W*xJjV@_1_Ktog)B*+qKYN1+H@CF;nfI-v^f=rego z$p#=U(gsUC_=PTkVOdEA2b(L;=REO7tC3I_hg zMoEi1HIUhY)pvYMUXQFc+$izu{k(L>lMD-=Bl2Ep8? zJqRXJ6U+$)7{Nfa=&8u5=t+?xMGq>U6KNDWxOPQtag3hPlrM4BH&hJ>{Dtx~`X%ZZDhE2VUZQ@X za(H+IOWndyMWLv>+Y&k8y6=_ zqn9zyM;bZ?03|%!0GZW&f($ADAX+Zv1DEmuHTlZ+od+;(qUiyfBuq9p@QFYo%?^&R z*+FKoEpc$rrR)i|Tg2KgX@Wqr1VIdbX>kqSBMMtZ|FML{*VAY?!=tQaNz(vURCew> z=t|!*R<)dinTmV#(EHrNxJH*SZi`!KrASLYrQSconYG}esT={T zNnsh5eY?=Nr8t7Zisi_{?ysQkwJqVO!AGhxRh=64U5Nk zlo?5q(&QZ+O>uu+MI)5KWqI7?DK3@4>@v9ZXdj(5UC5fZOKLDq-v8LBZ_HBe){ zYEZOXSe7a0kxbta5$rCwcuoEWE-vDuaOE=*#3%KBXQ&7>r(Ei`H*ml4Tjy+|?`#wnJO zF)6ytAISb71{NLYQpQ0$X}(k7b#zt_=*X%6@8X;C)Z{CLS3i`n0O18^TDB-xQmo|7 zA7UQG=MFol^^n-yfo4;veceif_ISb*h-!P12g?EKJsGUNzJUhZ1a)mFJ@S%Rvk*hz zfud4Fde;FFIW6K_p(SX(98F6GquE2-x$-X{CMye*&`Sg}sI+A3?nU<|smft{JR$N}XN@-y&Q>i;JNy;EDL{zTP zyZ4zJ8KnGkG1Q1jpWCrpSaBPKEJ4Ugv}{v*r~xcuCBvocY=_H)QHU5kZdO{|YN6d- zze`y8G)8fv|9FzH^kEv$1=h3Cy{I$^!(V5kb4)~sueYy8WS20!&c2E}R@iIcD0K-7 z*c<^tlk8=97TZhkoM|sW(EL`Y8{W_?;)!M+Pt10&zzjp1q<4iHh{VMph0bCNxvwC1 zdJ8#!K~7e<^!6)ydlx*iRBxa+kFvE?nBTSzV#4Tu{x|q`u0tu%OV>J@_#@){24PqY zoTgGyn2%wZ(^4vwZN~bGY=zIM&3G)>AWRCD3JZ3Y3Wqn83cKDH{SA=uq}{@lR(LnU zxd}lV5%dAv9|%(#;oT}sV$&q}Qs{>WY332O2$Psp;JX8%A89~g$`&y85uyf>=&lAl z4z~zX*h}MKp{!xg5uvPQ57^s_$G0B?+<=z`;`|h$J}l})gS}| z4Gl>9mL}4o6g1fu(`>k&V*SKRaJ|S}YvKAEb2Y;CC*~raUuUk*;G(4ji;0fktYt3R z?0%EEsFQz&xduV2d8i#O9-0Xk4|PtQii+F?T9N`delj;m7z#JQDNMzLx;66?4^5$6 zwA$ds5-ncPgCF-On}rk?dLujv=utwCG9jhTUPE#5yGr|At^K}+UpIzG=VUh2jIoBw z2Zfq2!;&41)mZa<8509)B3`$50_F)kZ>KiJ1OGPm`#Kw)d%{hKiK0!l-IKcz`4JB$Y`Jv7jJ=6e)uLTQnFW?&uJccf;_ zdA9O2aosrM1U;C@rnzV>#Y1Bwk=E1EoZcuaVp`R}W($eH)FCv}51M>2X*t$mE^-NL zEH|P9Pbj~FwZ(7HjibCTW;xj17TO$eJ?xaw5<6NKcevDw1h?a`pbkZQEc-Tz>mfQU zXpG77s3Yo$bY!^#jrp+J6Lg`qPXIl*b)C~xH7K-I z3bkPBz2qATpb-veV`y+hnftm^*~qF&v+H#y0!-!xW!ugJ;YveG|A~CC&&K_1#7~<9 z7Pb|@$NRxAEQ4D}Ok8H0s|I8TlG8eVhUaP$l(;z53d z2N%bkiiDnlS~-e^Qk~_YZE*3p|AFf|7J4WW>YO}LoFu7p?VC}F+mLkkO6)%0h6X<1;#8CiwsaZo)eeK+Bab0d z4;}{5RFhEHdRR!A^vGjiF_CC~CS#bVK8u`5%Gt8gBw;%S6N~D*ylUPLrK=>w#43{2 z0u3nyC31UA77$zo56>e{Vk}SING2(XfeH2ue8XYSP!yMm){$I~JjdYAvGq74{zoLf zXgIMPUJU1itrl9uVswc*YXx^#e~DHWm2{Kj-;^Z#4`B*$Hfk!3PO*0d6>}-0>@;pq z%fw#U3G9`bAt714QYk;{=QBK?dDxV@c6LW zeF>&esJ4*??kvuerD9+L?RlJT#AhhtsUH#XIYdl3y?B&VBA?C#lO)GhVMQ|a7mlrq z3M6InGL(!~b6|JODb`af*-HN%0X$G^#`py}~%w8{SV z8dqSHUG_KEu*QJ30=%QKsqj=Bn)-AVD4J^K8dJ|dd z@;12`u18oac`o8FWUel>XuKt+HMAscvuBds+HYzZ%#pi`Fyl-MZ4{N{0Y7T0v)IY0{c)D33E^K!tiVX=5bp4Od0TEQiCNbQSq2g zMrWVV&Hf*i4bY<0T#lCNCnZIpJbU*_^8#ykWU6*{;c?*|Hq@3{eSG4xq># zW+lghV)6LeX%c-i(-)7uEc3q} z`@dt32+RHp21o)}yLT(#BRz;2c!p6?lEDMFb>Kxw1`jS}FDxFkB~4bA+M4Fx@R}x! z8s4IuN84xJnx<>?&}F^WG&OO^zT*g9M}yyu#wE-$e?Bq~0n^fF!14xiljK}J>dcP8 zphAAGz?gL`7DLTaXd~&B?D(&+;vLqWVp2s*P~F$Jr$R7%P;x6=*Rx9IgNqMY zXrYUTCZb4gV4-Ki#Y3Ng>pXldrvITQb0woE=P_uDj?)_g7mx9;Na%jJoQ&RqNT^5o zlmanLY#=6;XwFj^!Tqs4&tF|5{zZ(9MQHHvp2Jv4!AyrXQ9 z0~J;|aPJV=cT7`AZ{S{AVDdv4UB3;1(WD4VVj~=lIqE1o#v;#PxU!9zXkZcV19-fO z@4NW!!1r@}zriZys#+${Nzqf)_5urkiMrZtFYq-t z*S1&TIceKJ7#u-X$%0V@w&j6&m783+wyk9m--0JcG9QqCi*+fE&BBT@YIrcAJ?Fqn z;M`sRUuK~h$pRY(nt!#9#qhz$9o?6RP>JWnmvukrlQD39fb z)^s@sEI+lBAM6-5&^{eYfzr`3@a2K$fu?oX`X{3qm_^aOs{02N`{+`PlfwL>$in>c z(jgBQ6-puJw|l{WUn&U}94!Nl-@zSMgW1KyV>8Ot;hJeJQN`=@2cH9prlOKq4$V3B}g7A>( zbRxb$5yL~K(~0;JB0{H6hf_*Q8!|N{$(WC5L#EAGQl5mqkp@mQejbdO5g$06rYMLd zHgIadz-coEPF}PuXOZC1Joyh;sVGGM2JDnJTLa#Q(Ahg(j(x(4dTo@{4kV3=+So6j zZ%K-GShrEpY6S7UNQ{i=Z_e9sZ;bt5S7Pv#8LNuNunwDfrxLqY;%beB$GBdOOi%%blag9ibGvs0HDcYY=+}y=@VueQQ91LVz0|AtR|v zl8C;DA(rUhl*r-|qKi*3X!#o}ifnafJu^?CHKo;HjI2!_$1klRt-^2p(Z%EWa`Gz5 zPdwQf%rZkck;^7=`a<2xNNCFjtE7Yg=s!4m#%PqbSIx$5VSA#iPPJk`daOFMo}%QcW7seLOnbP* zBqh6(tpX&WafRI|E&gKgTv8ikbLU!9O?2*jY*_6VZ0;PSxpQd%1JCTP9~(I@QBo3r zbYv_aW+(mV*aNUifu)xw3})J~*3gBqvFtcreP+iLZ~d;t6KLp=?*mtd}X zNLX#=GI-1MM=nCPNc=E5Z8;(tQ}5^qMR?J-!2? za*XsW151peV{_%b{$q(t?t_>d*r;hU9cA5*Tg*KQ2m9c71mN-;%&_ZJAX9G-itG6F;ARUkIDYl;o zYK|SUuU%B$7d*#2zVGWp=z@@^aB^gsfl5JKU_CNiVX&l0O(e{8QGVCKR1#YMqJ)`~ zI&?N)JjwzMuR0MmsyH9dyymSw%A@{>YR$3O*KDc)Qj9 z87!o5?Xi;vsy8Re&>)FvkZeJYFoAHbdH5Eg_}1EsgO<$AUiD^JWCVk4Lue>aBMLcN%?+8bs;NDuz3+zA zedgxO*4pD?0Ibb2cV)Jm4gzXGWHcgfA*U&GGsw7LE>YVRri&#utSgu@Tf{)_NfG3s zGQx^N2&D;@N~SBACb}>hU(<+QdWa{pA@~KB*x?Pskj&&7CD?Rs1m~O_F=E%OG_XhH zlmdTXjd9?g)L}@0w;Sk3VI-u?jZ(n9Q1aEcGS6ck1)H*yB{}%j86NZB_JA9&4~_N% zH3;_l+FZigI*}>`w&KQ~CCzD(l8DwaqD*6<#8Owljs2!7tK=J%5T0DZAatWRdH~Gx zgzWRg(PJ(69cxK%%-kh@e^-*^!(jv89%b3XAQG6K6mS=~RLj5cV)DWa)eg(mB;nO9 z=|RV`Rq$JM29{kqM31l4Yu*`PkvcLZW(fLfqZDkz;RH#bjhjKz8+0fGA3^ee(J3i> z3@N35;ZY~qou0ttA+nmhOF}>XGqNFXSS1IN8)b6~+5cj98s`6R?;$3X_dJ1FHdw1K z{-sB$k}^NZt{LMnRs9TBx1V{HjWRYiGk38@22hFGm%Y`nL9DVW(~}^u=@8H+NI4Ax z!Uj~m8?!Ibe=Ko`mruT`{TjtZ$!s?Lfug)0wzre&-?`O zK;Z-m04wcDY~yafnSzf}W8zV~R%I*9=H(>OJP@n4$NX&x0k0|Gws_Ga*3*a|1t+55 zI;r54Wy~DTyq1cO?Du4tkq!zhBl|s~=YKbB!}l(?;e!$04wg}FOZosshb<|KK(?fe z9@&z@I*oaT&lO+C?sLq6E{ z-AC(}l5Y#FIsL~&LfszdG3DE%Ovm2OWN6ba>>I;i979e^s~oVL-C?1y%%jrisx)CG z4T!^SuITt!P|5UCR?KeNY*t!@S9j-PwO2H!U~~SL(2r(N8{!e(O_oZr{kSlnc2Bb; z6-utSC5S_wvy(*Wq7jk!2D%56WPXfSG%|En-Pk#G*= z($3?7$y7{~6DhO_77`9HyW$qe0qe3!#OR7k(DO0Nbzx;^cLn$oFH8Y=`8T2bkri{o z6XN$L1CuSNkF4;&2Wx#6z6XVWR=DtMfd0Ru{GtA*Q~oa^Up>nIF?hsZ{&{_szZ=!R z&%#d!vysBb7PQ40EhJshmvk@s%V{`8TR)*BVZ~9b2_5(Xn&!rqM_`^aIzvOl=t7Cp z6#X?8z8?+OY%dmQ>&XZt^C+4cVI}Rb@qH4sH#eGu`VL4yYtQ#|Zx)^jHw&=dfps~n z(En$fgdD9&$RW$#_?m>>;U)-80__Q*Nnl$V-I|1r$RN%xSg}Ah1X8u3NsyG}Z?*Oy z8TCtcd@HOt1)-uaEUbw}Q!Od(Gz=I6lQUrMBCIR~6&G!bkB0+&xhLQ*Wbz|Xf;1|> z8{{`*e+ZikCGfGKkkeS!KG13M-&%E4aFnI}WbvwSR-h{@i5TYs} zd3cmrvpvc@r`G*ZM~3Ck3}hGP=w2+ephv@qi-vF{6Av=)AuGK^Xe^0a6D9BYLXEH^ zC7F_9N;v(w;zbfWqv78G0<&h5kXKB_dbAwcNct@Me}I-}z(a8t@D3j7E|fC)={8B> z!x@DSXB0l1QU6qfOoa#X)5(fy<#k}F#~2&(f_&WR+aVf=1k$NTBvVv0m8#o(ooK$! zhl;ZLEyU(0Z%=<2ml zxOgbh;-UATALXG3;Nqb+D8jE;+%Mqbi?oh`Fco5c;uM&XqlhZ)Wo~6J4nl}KPq;8? z$7Zm_Nh=<19N#u2qFTGGDW(4P;s(lT)wxkSes=oUDc;&dCQu8-bs&quA)Pr;FD5LV zImw_FW-e@a=CqFiW1{eGg2((92~cVVOOVDRqu`H2d9Ciz^;vKVD@%}jS~pCS)knr5 z|FrLKBhz#g_DsI0P*}Q3SThLJEOIHT+H&g7+``)RUfRs16NJK=dW~+I3o#2s$2UUV z20|$t+{)+f^hQ_uzc9AI*!~Hu$cf*d2!@9F|8q*&6KXbhJ)w{hXXcjlEl;2(ZB;rm z52qi7slx2^Z(WY#*tq-1aZpg{)@me#*%*oeZ2Go&e8*{8W2wQ>F*u4WD?L71R!*_3 z^g5aa^%}&Gm1a4;fuEtJ`Xs9biL&wy7PDnF^-;NT{4ZMEEo#ZH?4rDS(egn@_vbN$gB7CbKipId-u zz?B5VN&!x66EKN@=8rneF7s|Z3^TiwL?e(kfuPCxaw10y&e_-tq@!ANTrY=JW#|_2 zy~sgz2&wl=CKc6m*-?p-Dkc(7veHTkOX)i?`-Q3; zgsL>6Z+H;Yx{y9nrF7b9Zd}zt#4hGtHSORsmBbVJNP9^zqBub3gEDy4g1^WvTQ|L^DUL8`nid|Ep8qp9pQj;Zbv^!Yg1StAMC~E~V9lfk`_4?{qtMxP|;eDU%|5c3d`~qm1({rh6|_%F)lZ$0B&Q$1vfTYW zs$lY8R=Ld|LqA-OPpZwX^iLdHakALc3{TWOnDp?vR~M~&1RMw;W}uij;5izVss(tB zp-9~$U=jh%o2c$J>tU?!8G)jN^tEmRY8`U9=$A;YkC;@=RLk^F3z@ zQ(2Qpn^ComhfankRo%Qm}Rr2xj)U2;_WrL^sFT@l@o_4!Q$mW%Le^ zj-_A|cYs_8?$SATbSDo%^^c|cabDV`53vGI2YC&qtna$&XMl7m>_2NJ4&jOM{bVBg?a|tlFVJx``=)zFjWItOiaZF^YfuBfge|k zE?}x~c@I?xXQ)qoLSku5yTzgc7 zR@LY(j)cgmYvgjpL^S#xmy@<;WHxZMfRA?i7e$Qmxf-CTZY4q4KKvh4Kd?^4GQImh zyAQ%5R~^UfpEJbEnbzIfM5U4e=~+zq5tjlNFSEapizs%! z2H=}K1Tz$j=XMhm>$Vdvk{lBY?jDQXE84uU!K6U8!aCi9wq~t3q?DH1uw;4Ra+m#j zIbiMhxd((L6=nr*UIdyhHTx^392jRMRN};LxPh+0fN?yQN`Zm%(mRCuPVT%6&VO^~ zNCwKM0E=jN;nej@IgPJI==<3OWDuB2}*y zb}FxKmO@mZuq(Kw34>#8LQ8ER3B_XiE1q967a7jeT8G8-H$1Oku3dQYsi=9EM;^xu8$-;G!=+Jq1cqKH@+s?hm5H&D#+z2DQ2~7{62C;<+JKhVZl3bZG+Z>?D}V z2iG=Ygb{K~D5)?j6H2Ie;#Y=Y!H4uAE81dI=F_Ok@qKw(&Ar8@N=s%#$A#gZ`Hb`& zsUx|&$~&6NGot6vdsD0WJ8_KEs3Nn@ggRfmM{=)urXvSj_71r6S*~Wo#Y>BZEj*N( zGaiZ&oS9_r3t~ITi4Bu1OpF#KYn$=HJC>v-1SCQwxCI)5g6(IJzrW#(Cb$Q2_aK5n zN{fC@zezpd0*43$Pv!1Z4!3oudI1l*fMAz!_a#jif+($mTTFE0Fn8S&aV?Fwu&4oJ zYOimnY;F{TC$Rr+S<24xY=aOa-y}O-ru9e?@DhyZWgKrxZ=s`NY1;6U2HLbaE5lyJ zDq4iJFOCSs`-HSTn4T3EKS-OGJB76OF!h~4_92BX@=75fY#fUasmKYB;ue~I&|3-K ziiSw$MnwD)5mIJS1S?KwVCP;)+ec*WbWWx)^}$Fg2%r>FcmgzSC#)_3&`N%=M+$Vn z=0VyG))GQQ>jb=8#qTI3q4uxhzO>1NLC~?$P3x=JlF|?85_%!7}|>8o`O3h`43=6?GxdF zDOgy8=Hv8fA!{khXk&gg3Kdo+utSYD(p$x7HG~8d)~bEbk764hg;+TV>lQ2ZqOTyIZn{;pjpU{27fcz8{>8*a zh0Ij!bW{p!0d1fb)vKZ%M4ags!WuyR^9XgWUz$#_R8Ci)KyovfEQ0E3nuQm(BC)r7 zDx_YTO0i^4SDip~DM#NWVZ=>H}ml>y0MPYbF zJ5sies)hc5pVwI^=?EPg#GWs2acJrLzGG-j5#ioFFgMjE&tx}?3$=#lts`sK7xB2| zaXfs>p^8|u!4novcrpVLm<%-_X>9Qxal>$)k}WtXlI=Wn%h^Wnu>MET>`$o~gQM_$ zdM@mwpoJUAUA70$LaB}1&i5!Hsb3vC?hZ9C{FYH^=L<>28-+A7=`B1+z6FP1J-G`J zi(APLcN5?m5G*sL`N0 zBnH0ZCkluO3Z$mxc~&y;*Z~0E8Z-(gKp_S9HIWokW>ag5rn{IfI7xA$5hGLMl!A5; z`2a3t9pc*vS78Gs$U>c{PmSxdBY9)%Dl1*ML33m|XU=8!FW@m}WL3X&GPkk(3Xh159} ze?*bGkPoUUxFieWC7YlWCzOS9ypbp^d>>>eqbW=|QVKSpfp(JiE?bTjSCj@c5l^O- zX-q@YW-@c*VrF_gi7w$t!&xaj>+CfUG2N{|1{rj>!fO2Dz&zEXrpb7`!ut2$p&{ii zHV}+h6XWRaUga37m1J&`)KN>12F-M!X+Cy043>d{p+stx|4OYg4koh>U)ip8_62-- z6hgt3rro-Fk~eyLe2bqz&(y7_M@LUSk%pMMcCDj_Q88YI;7fgd;io{c*xmYgbn&?F ztuXZooDeVGCE(H$U=)iA$*%-{NP)U_o&qUvw_cq{8+PiH0#r8Ir_Tg6sU(sDC>9ms zwWtIEg`Y||-3fzbTZpyNlg;&`ZXK+W+%!ecb+O=}twNnsdV{4|+8k^*fs44K&d zC#TU`~TBr-Vw-4qD7*MC7+*agqob?P{^8T$prz0JTPeNNU0B14w8I3+VO7cFf*H= zx{l?Lgh%-y;a*ImSc0@lX8V!E9tSbZBL4@M;ee>W20#9`u7sQH-YsXFM>J_Ixv>eapC?CJUy7a zz`mf4c0Y5Kx)a0#ZJ*aohKB@gsPn*qvjF_;O7ti|_?Q6Bi?9<{G}UP4Z6zu?%qGid zP=`UjOZf`z8$Tx^rK5O$aKVti6&M zJ;;e02S=vA4MFwDk8l-rM}1{SND)|p@#7=x6iWl{ut0SjcT#4@N5U!K%CA3xJPMFs z!j>DTJ3+H{6g4ZZKQk`&FD?%s>4==;h!hzv3!0C%ijHtV?(Fymj&7Xp@eM>_$2VY; zhtoE&J@{u1ZYAr^Rts05%JZ;t(Z*PAWtrql8dzkdeGD_cnHbiiM{?pxm(idDE1~|Y z3?0#O1c!|QaDW0gY{P@rqb(+qH+K!kJ9n*s>m?*>F+BnoKTy*M7e7YR1s6Xab2f_T zcDz|kH^9aHrbhglBYq!8{F1>aou;#xegPLhfO0Kd`~b>LaPb2ubKv5XYa_1b;No%L zh3jHQrH6?pRxr>d&ZSkWKXf8nQsAFm?B{I?5r+TsHM|MK-(HO$RHk~W?f6w|`0r%Q zwUBAVV^*NEy*}*l?QgPwIS4GWufu;6E!|)b<$fz$8t(=QL^m&6sAg2V7k=d!TABaddvsuRSYm<9oNE( z-l=;>4CJYQ3r^%(R9*H{ur)0lue{z#4Ji%`JdHLCO)Kn3(hvf{OfJEYof*N%%63?K zNRGpmH%CpT&@(z|1R$c)SO>y^7e3{e$cIhtu`wPbOaVPi5<4+l$i`o=V{XS43yoFl zqD_=K z@ryAVD1s8n-9reN`*OsPFrA?hIv8eHb6W|8yFN7( zmP={)A`XSTZ4qQUEhKnwIk3MK;|hqid=kYyZJ~j>l?jfQCKoOp>q!F5ikESljI8Fj zVK4p(uR@oFKyB(t8KE;Cb?ALE?#5mE3~YBIO6qTGlWwR1LRhMze##1LKBkmN>6^Ou zOK8Ax_?RZet|SZ1x$q7)ifJ}bd_G1|L7Ky$r^vBT(3yDP7%<*(&m!r8%y^DSSB6p+ zO(4G__!aIZWC}%;lIdB1Yy0;iG2HE+jGtoMxJW<6cmptx{OF1nyc9YCuRcv2LalE*Mk@0rc1nu;ir}Xu zWn)Q=U`eG#k{ZF2O5;gUXi6T#ILQl10m_qtgXL-i$jS|oq()FucrC(GNjRxAO2jz| z1aOJaC_ekN7Gxj}=?4@8PBwc?$wMfSw>mR;av8)yPKK7&>y*}Ok+eopT6irgLV%Vn ziePn);c1Ntr6A=P9k#k+jB8T6irgLV%W5mh5kWgU)x06eoBla5N_PcVvoURBb+G`= z9x9_yd@~%8%1DM-bQ*{139V?QxGwC{iW#ws5+W=DS40;A6_WtIe#E2!**8 z;LpK#8u_MBTaK-vM$+*@69fY0$PI%oO%7N)MJQx}R+4KjRn7@`D=Naq(g7PK29u&g z6l(%TdbkZ0dx`#wG0M~o^p)vWH@e5r_n!nqxT1J#z>T5ahjf9gO+&zxj=j3l-KhYG zxaCdxFcRCsVk=F}SWmY?puw&)zW-cl3AmH76UO2J&4y(zWsw!M6mPOSy%|)(F~Z3) z5JJbP$u|KP4tA&G&VF!%7@!y?1{@Y`mvqCq(qVbaaS@Ok_uF8EWx^HyJCC{5g&~~B z6;_hrflHlmD&Wl$VU>sT9X64MxIN|xI~#GF1ZKZq!X#DPeGhQ5CB_&#F0?{TNDz^YeB@FrMOLM!7-PkQBc={Q6vh628g?x z#q?H`7$CTld9tmWof@)?d)CC=Ke(0uxRq^UaDy3A1YAWk(WnAv-_&`|7*5J_tlkQ>M1g-CK3QNfz z)~im=h>qVxVeLT0vQi8_=nbyjQ9AV)I69>>+ascD5wX%hW zpXA}rE)JkqP{4R;tvrAuzS9t$96_%@VBEDh*NN#xUd%Yd)(5=C}yW}irH48CI)ioJsH0k2CkJ)af~MAY$j!d zF)?QcT<2J^Q*w@sk<@cI*&^Z3v#`I215{^R zYNfRREo?Ilqp2A@NDdmurnR80!(aq!q%>BwmIL(};ONGLqGRyJIE=kCqe&d3|8cXf@o~E zGlJC7w$Vf*%pvxFIER-(%$VlU+#zLlGMoGneXQ#oK&Sfw{z?=|2`53szY`Tr1%k!~FgcaeWeTnXu%}Lm!T~ieQX(1B>xLaM3NM7SoF` z72$Rt+Dd*8Q$CNcwjE|kZ$nS9@XJg*#5WNS=VvxndRAZ@5jsN#HtHxerqvRrQ&F0e|$%aXe5AV*Uo7giOuuywxq{6Vj<{+7O;tx8M4-Ws$hUV&amtzOG+(yyPWejc; z>Zn8Pu}VcU;Fc*#WQAxY3lG>np?_?uM^H900)tckp&`&z3@X{Kdpmw_+YdcNrL?js zQL8X~lpQa>L6xGdG8vHK-?a0cA+$`idxU*3Y#z~8vXBBwDHDK23y9WFC`Ki=(oix* z?1YQ`A*cLV##vdKyH~1jgtH9{3JB4YD?Z`j>Gf;mxXi4}XO%l^qC9WhauQKx$Anw`#|Mae^(V z{ozFa8&u&?+4c(cI}x9mDzioYA8n`XX9kO=szvz2i{ZLL=CaUVKmTireC2q|9esyZ z?F%pFj+s~$`AZz&&3@GXC74dAyu8`ZELuT)lb_kS@|tPunHo#>0Q^kZ`0m3O$F1Uanc16Z_Pa>6>ME_=stT1_Y7;{(f!a>UgefMBSBG-RfN`zafc+T^nn@Bf znl$kdh*rRDh9GS6kY>;>5^S|!zJOX={E4Q3pL}b72q991HJVC5q2wKYVx}6_lT521 z8qF}4c4f~ca=q_ZXN)Nuoy*x@8Pbj&Xok2mnrM@cjw@PBAHbE)YR0EOKz&Zc5Y>wa#!3a7cbom>X~2#!Jr#zLE!)FhuEu1f+zEV{~Xpu;lN zte^ND!eNl%YB2|4l;?cHzwbdyyDA$*Pr5x~OG2I9k zzyAMEaQz!!i;4QV{mg~4kqN@uL8bW12NeTYtAx!?dc#I%6PNjLBoHl zr{kiq_4F|8&fapo|DQ9Q#ve)2M9fU+N5Tf05~Ko*7*8Ahxhi3$3wp|% zrd)uzZS!n$F&$d~m&9C^aB*$>GhDnK(T!rd|MABR+)z{lVCE-Y+>__O=CqEN*vz=!w#=DeRFHkfBSMF9OE+nF5MDN|e#aMsh>mq zk$qBf{0#XpDT~%3w0x+zZduHfXc;H{-(u}aQu({BqVhpF*#jL!!o7rUMpdbKKw+TL z-k`Xfs9dnkF!ktR4^C_;?kCyFEhU)le(e8Y?oGg>Dzd-f+v!fyK;Q-lJ3`QaXi$*^ zNYVk)qyyd3fe45=qN2eFt_U5(AwaMbOwXkO*J1uT>Nqose;swiK@`-4Edgg_bHP0# zC^0T^4=&{W{p$3+-GO!-=lh=LeH+q!ZrwVks!mm%sycP*6cWEw9pq}kLAS_}F8a@F z!A@-p=G7POGU^z+!KhbAUqZpi_qgrloIRM}V%GSjepwyXzX&+Chyl1p<`M>g0^Bgp z`~o!G#tsm7hu6?}nsjzWh+T&5-Agc``~uIz_BD5bL#}-v!^XO@t<7z>iUvW7gZ44( zeGvRZH9ip=##Jsj7{u*k!;A~8dzd}BOP^S9z`g13@mboui4n@vf=ibtES(hL>!R_f z)8;eqg=SFnglo^jE~+W83PVfpY1UOkW2K@(LrZ^;74!XVMayBdobJZK-|A6Z;#pIf z*i7<*JY%zl9)TOg`noqY#LpG_b3HotU~5%TxyAkg8dDqY*Vq%eU*i*+&hY4WWSrNl z2IFDHaW;$vox+$y!cKh}?bN41cu3P!cI6k`WIjSVT#O_A;|Xox;%#T}2u5mKbY`NuWK7BnnQ~}D6}ahzId5nK zrNO@8;7YwMS!#8PSwSDK9g5M(zhX*& zI|+(i-&Oo0T0Xt%HQXp^6y1;;q~y?VErJwLBS6!OcrgWxYsH^KP5)Tg4()3^)87Pa zg@_Z)cH8Hy8#I|kq>%@~5z&(y`FOGGTz$Z8+g|3E$X*g)TK->?Pxv#9Xp(OAYl_9}C}gWmc#V_J@EWiT`vQ8jXN;YG!U zl;nRc$QyjN5)bP1&2F_uQXbE2iV1!r#FxRX$-zUdw)0{AwJR{tTe@N`0&$`_)#F-m zC&1;sJRue4v)65dx&+EZA%(*u`FNk8h?yw`;I5`1ndW2)8H*l?+#fN`WLH$;L6W7# z*+4@@&D`oz$t>lml#mMYuJhS>LPbc7j3#C-2hzC`D8)e?IZ}2SCil7C&@^<%X(bEJ ziZY5*so}CbviM2>d^V@*F;Uz|NLoh;AmJ&LoXCkfe}FaHe4I^PoE~+f7G8f4@&%J7 z4UGtsrUuNIc+Q}J=M22-@Kr*C?sbbf7c~$EEsAI4s@I}n!{}w_3MIajcPR6yE9WS- z43OKnlI!9133?Sqe{H=(9CWR>!F?j0gD+4v;^93!ATA|S{s7E1@R(nqS2y67VvB2- ze4L|8^15b}Eb3Fg(rlCUEAK^=Q}Ney`)L>wY@zA`KfGU2M)@*a|_AhKPnUr1GslQ-U(xC1qMx(0q1GnTm~_&wdu(WxqZZ3tJsj#`uBuWg1eZZGW1g`x!BIR`V5QUtburi_>( zgpwGG7j~J2`ng|yBd#{wX?%|>K!P9X#-0O>#_rI{^&p7g1C61ToFs=QejjX2)^F_$ zCWprhYy<52UcZ%x5KQ9ks-1e(Ll{)e0On%VplAd>SDf&CZOpSL^f*V*V5?oPejtW0 z=tW-DsMaLSBqoqe> z`VlSHEUT9X4POplXcOw82{2AWaR>Hfl=m?D5Aqp5S&@y&z0DFiblk7vg->ayuz-Y8 z)eN&MBB2RzVRQXZEc*I~({`XDqKSnj;L>D}uf?3d$T;H3y*^!Ey$vyZ#ye&re&%Rp zB?56xxHI^Et8Fq2hHGgsd^e>sMvc`sAib%ah0X(t0theM!H<26G!kNnyT(V_VkT+b6#bp;;DH&_EE8a0_0L{pcmwJ z4y6ob(}F=bsn6a{waR2UW=SAMR!1mRx0OF-5+`d9Ko9B3xqemvJJx20EbkwDf%2_~ zUi~y)OZQ7dK+|9GSY*IxOZ95^b9DL%e?Z*p#Hm?aJT?ZgDzVaX8$ZGK=WhD`R3{xP z@w6Wl85YmMjCGPa86-hwh?YEOHM+{cNouU?fBv(ARW9k*;x!5eswy0Dh|!W;nm z%hvkEzonTQzkMT~@Weoqs^y5lsX_|$jeDqW zeAyjJQps5H#8-v&X!-(KfZ+nUQy39Y1H!gV+u+n*I6mK_$8#i3=G zXu{r~cjQ(hLq7$s;;o}rYj7Kr9pRZadLU%K&6M33dNPnMjVmhk@JJYOdBUhh7fQC~ zbUfk2gmJ)U-vd`%(kwuxZJXQp(c^l*;yF}lGn}wbcEE?KuPEpGeu3UmPC;9O0~ht< zcRF&~ng_MZ%<)>#h433+Rrbwo`El)W&H}OP?$%NQ+Nt)g`&Sv zUv&^quF0v(?4ilf)R5yZR3b58Utl6M7xQGKyOQ-)IEMR1VZP{r7cUq}w40umtY?=fh=88MvfBZX#c`^fO?$L>VB*Es0Kk>#q_ z5T}WY$D+{V5q5!l<>ll)`4eFoESgk_4z>OphW!DwPGHzdl?97oQUZg4!V|SG5-DNx zh}dGQ#D!gMV>PqJEQQk=Tr*M^IYTp26?2N1O#_C`P9joj_(s;~JGayirsp3R)iJ&64Yp3T;+BKkrrdF7d^ zjMwlolG4wnfD2}IlXxgfTy>qBV~B&U@(0XB=Q2F(b;!Ws3$5lGzp)La^n}t;TvgWQ zBzdod#d3e7d-b&%BTMCwio;shMlZyoYvX-s>1O;Mk@)SRcJX1lr4nfu7fMj8>)K+v zE#{NHFs5z#i`&)R@wnSTWvWAwp?YSsqsW+no8-Rd6&lN&?&tX1+(9{grd%pECO`&Y z&i5}hbm0E@9NZsYi8qQ2u8&tdH&Qkkb#iz7zN69m`x@fhU1#ir!#rJY<1K{N{e%1T z-Ob5xTRPN8+XTG^rrQe#8e4I1ynn)QV;eI8ahZ~HpwUiG=Xkx~eV9pLB3;CLl*%xM zHz%qLKF685Dec`g6Z+&Q=(l>lZELGS<*mU>V5+$a2gZ~LC+p2liA$qCkCp`=uQp~w0BZ~dIn#s}K&lboE1u|fmwh$g50znG~s zD^qH6Fa^Ru6~5K6bT|e*yC-yx$!Bb;=~c;)!RF6O6 zX68_G@O|71k7-EFWG;YIYj#&I>tk~pV^L>)_3B-0V8${BW?bM9j5Q(_8ttq+V83y) zmB&G#aMMCR^E+61Y@;y?ETFfU1XNne#AAsKyHI#d<@*#`gy4bav7>Qm-GRh$@BKM@ z^D zGd3=Bc|#bd5B(Az zHBkj{ms-}ZsOoS4(nIxd4v+M5gX>t!D$6hP)DNvXEeA#SF+Jpy4z#)uW5#d^Ebtf4kQNFi%VnF-*CjQKk+^G zlHK360Ja~4Uw#Prt@<;#T)~)-j`N#!`o*;F2|V60b3!UiZfGRrsDZrc8^D2; z7B&)C8+eQc_zeZaCilEiu=~rV44eDG54Z|{sarD(x zE_%cFZN~%M^QLn*JEz$A#@b$Lmws8uUIuST`mG0X9fH?bP186ZVX(0l-Tdhki5#a$8 zg~0QabCov!KqGPst;_^(-A6ERbzIc=#j8)Fcn6)Eip&)O| zs1N2K3XAK>Ic?FbwZ78rtW6d z*?Zp7y{5iI-NH);YbC05#vMZMCwN-JN$uKYr+~i@1o|_cRnyCIK}D}x{ux`h8#(z< zgd`^A5QWIzs;MDrKkvY&qB^DX)&@1q>-0o!V+m?C# z;UEi(_prFaM05AD?pV&1xmFc2cwv&q_|gN@E!VE4vEhpl{-(#+g}W|c5AAxrVk?l^ z>OD127ZzZW;iu{I3`^pQ?-18X4`Jg#D|b$ zpxK^6o`DXRW1xP^&J$y{)tco%9H(jkX!DWYgr1lpE#5P*b4-`41Qpcvz!aR#NB1pr zKaaej+6wR|?N9o@@p93KZxsPlF!BOV-|7h~iqv*8$OE%G(sS2-X!n)wDN6VnR}`ZH zJC~p(dC<(B;ME7RI)U1}?vTSagFX)Qss!}0lUJoH;wjDK|+z$H2iB6B}XhowG4ZT`xdKghTuR4!HC*o8P zZCSPe@(@^AF)#(S@vo2{U4A7^b2(qAL)$Gjj&N-awcM&iwlu`R%!lR_#o_Gj#rAJK z`k#+2%rd*fQJ^AI{(-%5yQ>4PEs+X*+NUJBR;w98cy1GR|3QPE0r9TPUGGRDgOLQ< zGcK}o<35jyKO@R8)!f_am?s=%TXikuDT6vk8o71Rl2V--(`}BrLw0HN@w6~`=ml1L z7cI=`s$)d?k*efSPlUq3|hfL~omKu#Sbj&w)vKy0jwc_G1$M?^hl6ZP2g{-PSgZhL#hB2td* zcz6b;7MJchFO2suBoZ630dGwbiwYvzWt_$e{r2nEl~9v{3&*=;?Oi z4vt;!nl$GhRFvQ(b#(P7F?)iTuFF0`@{(k7f%02w9iCA9J=LQptW0S0%M zOI0Ljzr&6K3p`R}v8t%!4``PGMLbe1wWoT5aG zy}{gb+8^*nG$h@IK zQDgGHcD0j?9v;!UK*a0e3(=a)`CqdG-3%9>))c~MS^_D**P+Pm`d3+7t^Um3vQT#@ zXI=aBHEAdwr+oVZ0St)|8{nuC8GHZE8i!6zt|;zKc;(S;Fz#^Ty}mIm83e=Ij;OAd zY=ePqcq1P2_UcuSGw>PAsW>%Mv)a3w9hlx_wwn!--BpNLxg^yFmM6O2H-)J=fc2mU_(;a%TI8tM)jUAvZP0#gRo4O(Fta;7wgk;J z!%@+Mgg8}NbZI*lsRv&v4uM7FsS`}ZSl!hOV6*RvfOOaDTD;Q3dk(YAm{O~z8?IH4 zIOfNEv{XDu;RKshk4rT{ebs92fKZB?1lwxe#yg>vEog#nRneFhE`<`}TLdV1>82f7 zBsW|N)l7`$j?b8nTko0M*zuw)I1ce~TiF@NR#^~jU#}iuW|)0K59@e@)5u_blIuQZ zqGF9nEx61<4sm}Bqk+EqGQ3qLBH5>zMvNTE_Hd<(ikLP06k7QJVpvQ%7+U!kJR7UoE`4<$B>462j;!{G(JI;gB92Fdqm{ zwCPVwz~-+#G$F;~I=IN;30;b#d}{MX3!G=HtU;=|s+xJ?;bJt=I42&A87Yyv@~+rA zAMMCc7&sfodyQ_b{RWmGFQ@|)Jgp$S@EAuuq3dV6jr!*9k=<`;HJBc%BOYP3md_GP zahg=q&Ikej#Wrf}&7W9Gz9k3v_GKu$-1$9GivYLU-e^}5*fO@O9>DW~i%6upz< zV02O#xqu{%b%3OmJl)-dx?(jb<@ErPco$hvz=D1UNO0e!la zP^JZ4YeB!YAj5**hi`M?klxRPasWy0CtA=<3z}y^aDN$z7qXy7Ea*)@(h^7YH{*Q_ zNWuod2u8}b7LbIMzzj;#EdwMxSOZAn@g@{`>mF!gTmneKuC<^Q7Ie1-Z3ZO$a)%Z6 znibY)g^frz>CLvFXDw)#1-)rOnS)G>3oYm>3%bdIYAk36Al}P{tFBHp%kiKEeP}_a zpJtZa2WWu8D7By-8IajZ{`ChmOF@GGiMjd(fSNU?5d0Dl#K?pY4ir(>KEbaqv0`7|TxL9FDj@YSm z16NiayQ=(ZQ_+J{x|fX)p-eQ9}dB6JF7ONjtP20!Bz}8HR{~%Ca@6} z^gJCbCoVpWMNSKwbKR5(XvnMZ+nR38^RE(B1)tFHqYUKT~QQ*U@l$-Z=A%J+Lb)CYOA3yYk#;7@Jki5}NCfe~`vH`ru@(r|H_=m#tFliL-LJ*y7w`aSjvT&L-7phTj^NLsMVnSFo~60H59n0YohZ%( z`qqMuTTlw($XiZ_1(y?!(-bZjoEhd-Z&Dq>&6Pk_r%@utGAcKi3u)&moOD1kFmeYa zeFhHP!tKRyukoeNz^>pv^Ab*MI}I&1-d9wqUdaPCb>BnPLX{ICxajah>z9uGl}J;7 zQ5M#fsd#62aoP5@xNs8f8~4&yz-75{%w6|U3N9Xky_&<&Ldn=qfG<+}E@dnoq0qwa zi5AdRo^j9<*=_n8zKm(uV8``(wUHbJCfJYaPZT=rIBD$|=Z4FGK1FukT;?l%&1;uS z;MuWed5so@`!W>gp3FT+0NT9?5h~@+;n^3;&XDv@;vS5bQLi&uuedxD#o(UQTnLci z?pc@Nnykp;(rmlllL%~LlWj&SKvVng7A~eL+D&SF8v>{if0!-d`zr;l#<$EKII2k1 zZ36UzdiyTE?W#K2R3xkmo+DKZNUC_E1@R!6yuI8CE0{JzUHw)<5ms!#sl}I&XgCktw`vzK=$n~JPtt8yy8(;K?6 zz#DRxgq|f$lk2BMad`}@JvJQCLod(fvzVIzL;Yxqa7gRP@Tj`;WcVX?chfWGM+m~^ zAJo02#DjSxFD3PQ&{*NX#|w2>ib9`Hv>a6aBo^Bq7t|% zSNR4hzX1_co~&0qpJUdCkh}{dVYO90Jy$v3Dfj;z(NiP3`Uq_dI=@7_IbVdcm843+ z8`_*gQM=ixzPZ#cs8JFZZ{{#8N9HN0p2a8C`frfkVzf;Wn6e(vXfwvAhul!cj>owiH@aBeHbY4=k!MI=i}>t`oI4FT z%^9*ed+UJN8`=S8(bgOlGdKx38~8Gy7fj=Ie8EqY+{CCU*Y5@5$W7er<_%Y6)Bu(9 zzNkF&cp=XUIDC5J2s2K$c?pif3*V`JF${VBy+|uy{}z$P#9~Dn3`0QD5K0~cLm|Cg zP_pe*-9SmUJ1E)U;LA7&*>;*gobnIgU|iVhGrW~h=t8d1lq2L-a&2G5QTxu&2Gy;D z)MQyw4&%GsAL_*k(P9{~$)G?^FaXNw&>ciFhZelJ2+2q)#xV#6wr!&k`+NL3w5#zw0}Yjz)WVw>t+{(+Dy6Q1cN z1ojvwdWbM3qH%_T9lx;ycVV2(9VZ-stMM91@Q1lcwRtaYitq(L zv6a8#!32a88BQD0aSz0Lrr~;L=}12w9^i}8HlN{m7sRsmNAclz3XWtxWTdr-WKt=z zy}%NXNff%A&dM zOWl{CwcuU!p$_SZPL{y5WBM1Eysr*n)bxh#l?VQ>r-X(+7pRe z;~AXrVUYC&k7HlzHsrK8JmE(ljNHB9yDL!R zHC(Q-YQeO~boWlxUeRPQ<6WgT>flR^0vPu?JiZ-L(=T3HTfLO@^1MR~cA9&axoc0G_sHD~7n(V0fD0CkyGMv&o zq`Eg6f4T>yU-c-qv738f1PG~`Ztf^MacFu-Fw*wW{7c+$1`ymnlRbdTtxL8o0kfpF zzXeFf3~ux#T`D;DKt&~5; zH^v&~IP)t{W}O?CEqAQ4a0KF_jexQXHg%0jz9+n+NZVgBaR* zifT{hdnzJsjR41BDYOI5tjt)Ht0fT$8&IR=aN+u3ZwUMu>(s&{R|lo zBE1VgPa_TZG^xrM4ov6|XbR{>_$Gw2GtcJ3LG^$VDUt}CsnRg2G8%z}=f!CMv(!se z&DAR)T2w|LBpx6tbVsLglKCVb!u@TDeCv|Lm%ESvUo>}qmcf#1b?7dT&dgwuoh}87 zyoxBBP{Vz>O6q`YYym#(F2a~ysYvMWNP8{FSvMe~vmfO1itXegdw4e>$XuS-i|dnY966#E(^bq*a?fMbkYGe;?JSw<6BfZ z1s7l)ig{A_v5eWrP^Tw1o$9q9=`V#Q4(dK-YD`fjxI9(W#!gR0h3HtJ8qJ4WwN1|=%Wz4zMK7ugCH;GL zG5<=;kzqemiDvIdB|ddhCGx0k;GQ_W9{xPN#5F zgW^E?trsu6IfeVa>-`O6U19Y1R3ySDoonL~E;Hts$mFoJ6J9nLPmeT9hX$=t9Wxx=N4379AZ zN23hfvq9r`Z*k%UT5;?QgL;li1goJ+O=Hc;C>B7R3uRNpqBu8v>D6z61LjMvXI|n;DQ6t}?I1*m({GRKZ9!JF$(?@OS6+aE zaG3)3YR!Md*+5u67c}2#v5A$sG8(1nCX9jRR(Whc8U_6GLByez0Fo|zA)sqe{|;>y zAnC$4T5maxy8T0C_Rny zXG<$KUV`IfG)R6<^81MSeEP*|i)S!i4_28e1|&sNiC~ru-XJgZz=r;BDqIJ)OOuK% zYh1??h?`7MW@UYv`$zzp)~oLVZM8t-He!L_xUqmr#w1VXjoxNGRzr(DYGc|=`ud}X z&J|lZ+d0ugCuLAN+8l=p+3v$&nkKC^19^Rc6QrhOCdt`0v@ePmMr$s#Lgh2e4PxvK zWtc5D9?8J4f}Cq+VTbc4I^SG^p4sN!}aJsD*H5og& zq{33~q}qfrU}Qd!1xQBx>j6oB;P#X>o`(TVR?X<2fW*Fsg_5@%TIKCP#1Y(VK=O7W zpbroOT1`Nw;!kc473g&<9&KqQ2d4eX8&bVE2ao@|zJlxATEott2Ar6OXBO@PaJt>9 zsCx{X(XpK)@Q5Gq6>g_2t8S}AM0!jaY&m$W#!+XY&80*vUtNEdW4e^PwpeE z{wER`2Vx_8h~=Mnavvp$K&`A>I60((#WWo{4ew5TlmIVKO`62!u*{p*n+$+y@f3XJ0jd(M{mQL7JKX=8+^%xQwnew`6N%y<6k3U zV2H7qGm~}&G#?^nD#l*;W!k(Rv2bj|ZG39%*>}uDA6Wfqc|W5*GsxHQAB4l1hJx+& zcxp~83Y`Pv^^hYYg1`nolTErLaBB7b@&VzLf_iVdy~%r64_k`h&OFGw4Hzw6~+NTGLF0hNN|VXjX-oY zE)W#*P^mkiQcv}T7WP&OFJHJ2>Tsyp3-{t;q82=U;^mC;074qD!i>(X19_rKG+y-> zojCo@F*S%(7*c-w!;UEijtTCeKtiCJ%BlV%`wk)i#DjXtW!rL)Ss4fy0TSgL>84wX zX|(VapUm#W7K+}F`v^A!j#!%I1a(4;4FX$!xA~Fw8qv#QRr+O@UbPpeX(ay z*D_D;V};uh5ofa;K%LjfCW$;A1dkaJs_%lxR4kJ+g zBXn9%tG&Po=U)n!v?RY{v=BtoC-;f{P(oel@|00u~#FNkX)>m5ZJ#B~AUI&)o z7D6}+nqDxq39EAuDsNl>74>XiDNEoM6aaBjE zCvz_vIIim0r@yGH+dSYE1!eNrVoo-B{LZRul{?)||K-g3E4ZW34A=XnA5;eFCZ* zE}v>~t7!tR{U&b3VQ#9he{yu1tLg!$Gfg>$8l-G%!$vIxBkpUpW4p_VdYtJC?u0E2 za9E*?qXecBg05-U+;h_7J7~hjPGo2^bbW~Ku1`YwwB|p^?79bFn5k+kM?~2E?0n*# z`11*WX(6^>?o=`v2XnENxGJLrg83*&(8_#cp1iq6} zJOCdFHat}Ep}adELh^uL6@#T#8+;8ovsjdaEq#6Edm!z@P%eh0m{q{(D}9AvoLCm{ z8)MD2?mN0u$;U%qXg5- zwjD(^DV=cd5yrZI?nR2oJB-J0p`b5Vi;CFla4m6EJfygcF5t*eB?ls{7T{6#&J2a5 zEI-m=AZgmFc_Hx@X=Fnh192y~$mwawl{2zFD&EEZHk&$=;8Y>}>=bR3&?bS3I+1PJCbFL@QQ1+mVc{JK;~lcO|+EnnK9Iv7iv{F6sa0dLGk< zz2#%7f4-<%0UbAZa<9_@uqjCyn68M-Fd}qOK~{vD-Z3k~-YTp{G0*fF zuXqi*O2KLzOLr9;$*7ayDC!OePDnq3nI{&iOgNK<7`5y{;mu4H<3tzi-FV?v?Nx;f z#PD*bYoUVzQKkmQof!?7YQp|wFMcpfIRY6aMkY8YS|6lR6*<$sJLsuV?=n9RDdlMB zQ76}85TkxWS*GU(d3~2&y&JJH?IEIG^(Q=thRmT?aoyxG45}2BJx0(03NRwD*TW&# z!kcMIxgJqqi|)?cg}WC$dSO#xIOWWc)3s-rBa~z8u_@%H4TxnJOrJBd#puhDkF6l) zg0+OqnJao=7_`IT*#3};8%k}WhcAzPAIwiNHz0mf0YZ#OMq-NVwr`bUMoJRs;LhA{ zQ<}=3l^6>;lk*hy_yKHf8cMM&(@)54PVOV;Y}Lrb=M~$z8ZcK)+zC{5_Rqc`Bzp?~ z0(23W=g|72N@U$bdr?^*&9uUSt5CFvFKnGry2(ojW= z+f#7Bx#1wPqF3z$b`i;L;P9%iu46XPkqfxEnOSUn*j|u(jm^aK*?;us-jo_BgX@^i zZsRk{u}Y9L6;E!!=2(WK*Wa!+lSlrhq+0nSR@;vDNE|g?*V-Hv|1@!M{SM0_j2AZ4@4_NqCNK~b&!3qXPS(5p7%8@xj4IQi9A-;M8L15OmwipOV%&mQ65 zS)lA}mljhOv1P_#>cT=VBmpRKgBSMJYv{8`;hN!*xp{T1H(c_gPxrjWm`+^vp<-cN zUs2DMhD&m_>N;jVk`eg0F_?E1lV)VBDkjG39}KQKh1Do-N|qMSKh2Y`3)C6ptkA6H|4)YXv0aNa}c`rq)_a!7!RBjnuE|MPYOL1p|vN4 zlF@t3(BP7MjSE|7h=bdQi;iAF+fGGpX=&!rrdrSq7WAbBQEe*msA3gpwFNz3K~GuG zZVPI$puP~Y5h@nsv!Epwbe{$7wxG8y=t~P42>~tirdZHC3kq7$A1vqz3)*2pZ&}b6 z7L<(UD3tpFdLMkCMehlkD&rFvkj;+OR28)bpXGW8EdYAiqP^bG1r2(&2lYUAXyK83 z{J60L$BqUTs&d5fUI&hi*q{=0;v_J+usE=Xgsn#in^xlqY^qUSMhkm0J zdmx9o2U4o`Kq9eWr4Ao%bi(wJt8k`%>$8aa0_sCEj;}S-|CRfRm%d$7bnt~Pb z0yj+&9ii3fuN8<-K#Si{CesFXA;7{TQe;Pmdv-rWE#}96a zAN)m};1hy&N2?dhmMXZ%`xq?caBJ zn6&CmZWzTEMI|rd+Ao1Ltknd@_n#+bt28t>E_AvFih`v9v*%mr;6_5AYk; zKr((x$#~64k`bx~7ES`!?v;uo-L_B5b0>Y7Q##8?*2zMCeio zIEQu%phNg`Xq*ckQBaE&Mngp2BX3uCz!Jh(5(&e&Ye94qB5#9$gkBOvq@>Xe&|pR7 zEDQ2j(8U(Cz=EnR=w1ujU_l&Nh2HxX)M`OGgr>ZugCBu%Eoi0%-C#jnEJ?gSTF}!L z^pXV~vY=xYL}@Fyr(2M^V^Ed%d@F2@1>Fot`0@atLyF^jthd}(k+il1UWTqPD99J2+^yrMht{<3diF@^Wkz#uetz% z5v9jxZcLN))o&x8#l~y?P&N*x&Ve&&(Jpeyh1u-E$Zm}nE0Ew1P^5A7TWpMlVdq^= zBvWjx)(|o|oN*VPFkP6={i4+Qq&ZGLuaV{WtE7Vfh zJMZdi{c60PI^9Mko97ICUzC8q^8w7{8d zNMAIy)f@a6{>?9P<4N%0UAiun=lkWFIPP4`$Jt1~k%k%84@+-o?gfLzWphtp1(@Uu zJMxM%{|SBAt;Lx*2)@nBVl{v(Zxr*s<*XWLfnmg6cdw`+gJ=k$hI z2hYq{3+=>)cW1SMuMUGwrfuhC6Vmh<3VdL7t{8%EZxytq`haBu;ys5&P)x z#jcpf{bD9TL3@gxnyhyXR-!P$KeI@!Mvy-tWfH(UI8#9vxy25wvO}RU7C^2=LxuTx z8m_FRktS@VX}UXG^+{}AGg<65752uaG`6R4L)fH)cudE}H8!>jH~GTTWEqdm#Uu^{ zm*L9Fs*Fm|pbDJ7+}(pU!7N%6z@8Z`yTIJV=J6W5l0z_4pdVwdWiy-Szm*HosD_b; z@cMYDKF2{xC?~)2@i|61ef1PXDmFeZ4o|W9zI)aETr28^WKaM& zyzqcR<;`tydeaHuLF z+~N7qa_oWC%hm46R_B5_`h{=#!tMdM6~cGg{B?4-Nsp_&&F-mm*emF z8+_Lq69C_RyDMJCn*(L~4O`3fg$EJ+_+InDArH&;+FLyE8DhK#6KvcEyYyNgE|jx3 zc{4eqPpE*(2v@!r_4j7(^TSv)_;Et9z23X;W3Te!c|OMef;OCGP4L+F5?Rq&D@_hT=S^ z*%bGov{{bd`&~OL4rjF$W#Z~DkO}oE&vv`qKL$!8wGno=nH)_C>8Vx9!w>EVa{p*l zNp;~ob8|AcKZA8?9@hqzQD1c_xP&8xegji0bZ%%t%WOU8!!LpZk z)}J}wp+BQ8P0ie!RSQFsJ8QQ=(ncIccC{c|#{{k8h@{~}JCk3LPbtXTL0nUAMD3ar z&{7p$_QwtaX)2@%(#q-pq_ zsbVo?EFkl9rA1F5(hI3DTL*{M;r7Hv`)tX@Stbg8%PcH`h_yzA4RR)E&OoY)Yhv)N z#KVq91Y!)qV602=XMW<*rWLVW8$^dTzlt{LDkWcpcs$zo2bk4B>L@hEcoQ6 z+rHK8?Rg8Z_)c8XD5jepMQzf9)@%!BZBj zJ^7ehpYct8l=yIR^}&O8ZW6d`kbDu^|XDhweR!s zdi}H*dh--6`63YcvQLHC*blOkD6Qr*^-_LCK37{<0uhVm*{Flw9kt$bQncRFJ88YM z0Z&b9>DHL4C{&v0_`SxWAP_0Mqr&7rtqSfnL!Q!R+?TCf;vC;rS&Jo+@eNB_khKw_YSI$mR9Fm=IbpNe2G z7WbCSPdwVmLK{(HbHbJ>vD>F0bV>8bFVO95(Pio;FMf`$@PagH6J>tl<+r<{8#_7= zGo$18Mo^FzB@lDpM=;FMbiUN`$QY~z7M4K78YuZE&*xxN!pFqmTZu=W3&ffg494O) zKl2lh_F$pS(ezi*Cf$->pq(kD^*A+8c8b;w?Yi57E{!SkJI!W}?lQB5Ump7qUJ1l< z(GdisN#BlI-+-?5MN94r3VlJT@9jMsiEQvI@(EZJ1R{meLZM5t*5$#Djn2JEwQ6LD zG=KsV6~E;cwm`%lqp$~cc4(cy?x;Dl*-x-JrM{(CN?h_=AjS|Z#@YpZ^AnGLq0o;+ zDTw^CRYvn55bIXxlIEMgK$knS;9H+Wt|U zx#Ab-Qk#yFcXw*tr+3l1V}{jzf!@-&vD0kk<{W-SJ~x4qlwKf~{&LBcl5A396N7Ih z9>WD6OZ;)?MiIYWr?HdM^g~Gq`BK9YQ=1ib6re{Q&D1F>wdc`@q8l2 zt}Yf^B^HQfS{N;HWSlTD_*UYv!~(Izg27l1;?MlVqs?Op(K{z$?%#fj_WL;l zv^CQ+w2rocnmr0BuCfEFsOJFA(V)k|Wh_@EV_Q)wg{0urLH7#%(8+ z!4reg%fb+d7{3>c0Ufmg=#2wL^ljhlBppPF%@y0J#BN^_ zp-Y;+U!c3$qRZ4to1dSfD|{i%jlV#*PSLe-m4h)}&+ek>Pf4Aps}$smW|$%q1!5`c zB}bV~EpuIh*1N{8b;Djp;#}xI@JUzSqEQeWa#SF4RInMV7Jud^UOK$MBq}Y^BT-rM zXkG+j+Yq|7fcE0g{KTVsKuX@h4mbV1HJNQ`TDFOT-&3qo3&c|MP&RTir>8atTdS8I zwQDmEI<)g(1?Jh5q>Y6Kj&s&IwIMYfv{M#$)Vj~@1T6;*TcecO6@(ts5-10dP-a*I z(l9^q^6*|ej+i+nN22)@h#V2Rq&Xo*4#cB-MA21iG+S4#Ym464d2grM4)dL}lS@P= zH8Q3(4Y0T)5V_MVIU52FtaE7THHlis#Yt!rP%YtOVy6KX9JUF8*d_#{2C#t*5NzgiEOEDLkX!sq7An9oWF-LaP8^*Pm6{9x>gE|1g5QrFP)WkSpjXq40 zQ@E#ESOO7?76K<@-4v77X%?11#Oe_j%hcWwIm5ydh*C*ERE?IF>T>=i-JI;aMnp_{xc@cp%#Wf z#K<}cV=Q8spEE2BfrvpHjP|wrwHY11XIdBn5o4TS)Ht;oltrHd4F>cN`UsKR_L%fC zEo^~^U35}amJleEd<;aCb7Wg%^NjD#PH9zra(@N*Rp-sBfMVX&?w9AE) zG4kfH86CgpT3i%}d|DzHxTz{_P6sV*I)2e2(?*D9uPp|9goP~-u~$f0I7_C_A$&{> zzLj{a1A$lvg27n1F=dHI`_>4b5EUPjE=6@T{b&k8mo&%4NQQWH!%|{3Z=yyL{V>x1 z$QARGWtCPSmgf$^9PQLbA5PTHfpm)1N-v4Q=I|hWQ6OT|?iuy2w9?Syy^^9OZig-& z9}|=Ok@y^E1>!g>n2g2sm-&g8#{KPhX3{0kqWKVrwIXy$b2aeHPdvJRm6A{Fs7-`C z9=F}8rDS)~Qbt7exR;yg_~qy;r5A{$e^heDmIA#CKPCp>N<8LCAaX)57^@WY%uhVp ze{WZ6lP*ggO+T7~&?U|7zd-jHDfQ$o+GNa+$76mxAiI|~;Hi_>X*WsZSD73Is#1D^ zSia|lQW|;~#<4WW{cE~Isese4e0+GVDDF5hy03Q>BZzUf2ClL837>xB? zOgZDx-qntOCS9fyO+T7~&?U`1zd(17l)8V4)*qUP{?POF$2zzF)ZQ&U8`Ji7s}&jZ zPo!gh*nfq00t39HiySVQMw z4Lt;F=u@$VPRUNyQuaINGY`Lwp*Y5(C=e-rBotxdIb<%@ho=$;^J)1}-<*#KcLXBV zr-C)Wp$(YZ5jqc=^0vk4f5*C?;LDwrKtYVtbaHlIFBu zpi3VV*dw3SyJ+(IPMU8W>^y5aYq^WNXd~w8T4rD<+Ro`{J4004Nk5_OtVdee_=~ok zZ*)9HJ_QyJ1tJe=6o9sKRg!iU`t!vYHIo)3G!kJRzapRU7N$VNq$L+d0?NWyq*0g{ zd@J!-c7fQJ1%t8f!=L$yN4u-g?&s9{ZMQ>PV$-_93N3L?qRN$t&GALBIlc(Qb(~-` z*72Cu8ZVt*k`7|V<_dukYVAuRbV)NMrWWJT<)xyW9m&V!%g@mjzK|yI%uhVJrzyI& zE=gLK5th_o!&QD?P0T{8wgh4+&X62YMqtG67{Is<9UDJisc%hV4M}|RRUqy>?zt(WauTWSmTYxZ`m zjgH=sU?>t>K(zgjmW&`wOeRJ0coc`2E0=Io%^bU6OzVs>Ek#SaU8MRNg(qJ{3J1|O zfrw4tAm}~4leFFo(i%nMsjK?9HU@Kog((m*Cn`+oJu>W?7 zc(jX!HkxbKuM;spOV(ns+EW#L*0^Ai_HSZ(O+5P3gg#=%(nVk-x9v+HbV>8FU!Z%D zMHi$LZT|ioUEv35e)S7}F7bIyH%;~6=V9w`!$}yj`V>S8{ty&U@rMOZs**YM9 z^f`9e-ay`Qa*2;uek@qp7DL5C>KcXJXGR~bXw!MxnDvvioOOOJtEN~xd+}uL%(+vv zA%RDJiL$V)+2H^qCnp2c0qS{(e$N?B_&pR{Z4Zo>hl{5unj&D?HDqYP~(J6L~ zA}Cu8!8p&#&?!mUDOfvo#F`*6&{5%-m~4F#pY22-N(RAXtXK__ya&-pOy+8- zq@m``Xq7P-d@C4imjW?8!64nc@MnJF(GCi2uDh`kNyOSO7OOo~!DlH1i?nCN)M7mP zA)$|$v2@#)Pw<$Q&?QY?nr(jK(OqNFjpfJB(G`A>CUrvQCm!9qEV_(k*5S|5l{zHN z!Hg35#G`wUqI;rF?*vU>zOJc3L zw*|8#39F|4hVUyNvdhq?i@WWQ(Rir1>|YIUrF> zv7M>GhA^_zhP`yeW;=}1`UX$tXNpBjAkx~PXeqnGIm1;%6N7Ih9$Sb&q%9bX6}yIu zN1JDCqw@)qE&?Oe+NU6NN%Ii?%uhVJFDkmWGn2G4l@*cGvLf1KqT#p1Dy=|FZHHhM z_RtD3&(6ahru@?^EP;siy29!+FcGdj`fF&75nEK* z6>4Aqb7OKa-J&HBX}zOp4a)7P%2iiQBlg&*4`+3_?W-)~DO+}a zddKY3`gYHr{Yd}phhHC(J?V*avrAlKvghCG%RcRa8QGg|pObyTbqlj=?q8ApW2fI` z-{H6;d*1E$W{-IBq3m&Y{XP4RfzM|jp0_LeZN)q0oVxmgAL6USw~RXcRl_Ko{k2iEn?D#eVDp!w9xSkpZhol4=r7iF8@+2_|Iq`A zhKwH5{oK(5?#ds1!)xBr4}NgL=2P!RRN>S~2>C+e4!R!P`fF=)8CI3&S27 zJ@MF+qi?=>%jn~q8b(jt{_5!4*MBg&b>WwzYx~-A?pW3#=h$`Ka+1F6mvcqhkenIs z4bM4vNq)}l_jq%@{L2M7S+|zvTwk&v=Rop`oNKNQ<=is!_M9`{x+kZ@kAKaXyW`0m z*Z3_tXDn;Td7%2$oHwrgAm`|?FLRo{)^aDz=#bl`uv_l=+xzAI5iCZqHrvw|jC+U;1nAA8vaxw{xd0xn+e7 zxt%7ynmgjO4{|>}@OC&^)qi!Je&&;|L-%fWb$hwq)ob@FuJrp3xkk?X!u3#4 z%YXPCXa2gaUGr~o^~<+S9h^Tsb$I^eD_r>vPfpA~^1svbk5*if|4R0a`FrM9=HI=m zCO_|Qx8>Jn+>^f}_pkZY-#(Fl)D&f*e|Ldb6xQ(V`lX^G-luKmN6ISXk%{*JI7{S*LCdL z#=c`u{~}}T*^itv_SWvMvAbOp#}=PGeeCGg%g0tdJb&z(!Ifhd-dr>G(1o{+eS6pc zj6HVnFJrG;^TgPGtP*sJ%600RgTjjp(`N=X5g;?fASH#0vVy~ z6ge2J_yia~>RY0i2qdFE6iSp`g<2k*{$BrCq1ppv{49{95fwtU6}l zFQ8q4a~O*dz5vj?NaziSvp_3FtoU)x#yjjhXlH3-fkE5=;?4o3E4AwZF90Q`kgkov zzjSRlVl&O_ahJ$7+9e3d$6uB<0^z@H_jEb(!n|IK?<*9}#oEmZ<3vj7(1VfoWNix4 zEyTA+D+0Z15GHYdIe+oXP^!3erFN4l*&LMPVr_9u9?bVR%cD4O1#-ypFGN1(p^TRS zx)QuM^TE>pQp~Z4&3J<>uFeMs7AQ(l9{ndJibo+`tH8f>i`V}NouMd6I`)}aPiNpe z%6}=#<*1!&!J$&^Y~<90FGH=BqqJq}fRXDwcZC+Qh;5R)xGHic*mro%dCnXf}0<{~HLo^O0-z#j#dj6n>Yg zUcLaiW1nSRu{J3U$VaAcw%hnInGg2BSWa99TII<76`;BR_&@)S`AG+t7AQWFL$T#I zb2t}ougAYDk)spaRy2OPmI+!zRqqR^);jdxqze{t*4u*guf_D)tY_wZ;A+H*K+hMV`iwx4yM)iThCg86|BWJ^az; z<=+l`@5QuF@5xF@p4PPCj=rtuhJJhKrO%DO?Ed)TC%o5wecMHMEqA_oMdP1rzAYz;spsYlJ-V=9Z)^EK-Yz-o^b0QjZJ&?(?fcV~59WVVx9!32ep>b7hPQIZEPvvM zM%UGU*#Bq8hUUJ#&MN=hTbl6xs}KM7*!BlLS+wmh*G~Mf?9wNCR9rpb)JIbruX}%A z;(Meb-l;84BqLz_qU%c%1atI?=tuQ zsqHMlo5;SupHgI@xI2Xwhf;;2b?Sl@C!}p!N|ib;WpNf?+?~bU-Q8K};;y^c;_%*k z=FHrjOw#4|f1da9Fip<=e(v|$+)O5uN%ZsEdH3B(Dc^0~%MynZe*64mSgrDR-Uo%x zPYqb{fz2oGo1hV<#C}Z zM_1dOx!)wAU&x1BXSdgRlqWT0d#|(ObG-7dnVM6v{&L&LU-M=Dv+7^B9lOtZ_=S5P zeKN3U{2T8B`jfqfWhH)%bEy~EZo}TI-E>FiKOb{oOk%g+JSHv4wEcMakNJIH)jUvZ zQrVdP>z{0j9l5mm*#*^J+*vZW!OepwO5Yy7x&(w)6e0R`t0a^5SdpXWOT(nB^7__rA^a0tLJE zFOwbrr>EQG`+G_iD7?Wp{Db$*Yo1p-6}ePAvtH)p8(Djs{yOK#r+r--G_`t@TK-7K z%dO{bw%K~5RQ_R3)4Xr=ymX~TqvvC4&7U?iPya^$+$;9`gu4lTzs(sLH_OLvbcrob zkJR^?_}b@F{{|jmxBPR)wvMbjvwMYM&OJWAbRV(iUym0#DQRPi?a14B-(u(E?|q6D zIiBtpaX624|Dv^PeEOqb&Z{TGoQAFLP;vN*X3t(!KezI9jorJBrSz?KW9m1%<%LeV ztk`z>$EQ3szSb#wYf?;h|3af2?@Y~`u=r9;Gp}uPiah-#veiq6Q_noCz4}LN&T*JM zx%Tda&bO;x`qAuG@8*TiJ#Sg;^z)Gc4LgRrCXJX}>bDj5Q#7uxYaP8m^7-eANta@0 zyuI1pa_;GJd8++$=l9kdPxZH}_UUuwQFgnWABRkSHE3_X0%`v?INdGz+unSKu6(%h zqx_z+ZHB$*`Kw3yXXpRw-}1@uj{b$m-*?K%-}K`Lhf=lr9&h8R&scJ6(t-*zU+fvX zV?t(mk8AH8-w*U0Rc6?ZdCx;a?jMdSzyEm0{u4&%J?15!I;VMx+gzOd0U^nI6*ycd}_*Q5QL4dex<0a^fo=c$d=re#^FpZ8HWZms(J!U6!pb@nDmR z2UoPX^RYxzpKi86moDGhGa~PY2*)KW8xLLZOP<&*_zuKM6| z(LMbJ?~FOKA#25AoyDP{%^T0TFrY#8HjiT$)##S!Iw<*Cqooas+`J|C*TC}@$0zsk zIPj#{$1cTB4fE5~4_UV$c4)J#*H6aYaJVocPyX1VnRQQ0?ozIHuLTzidwr|#x%JnA zZ+jKG7<+bni~A*_Z>=1(=wjE|wJS}^pEDvP|EO9OnswQt^_0sW@M__tswYm)8xZ=@ zM!T=k=#+08hxJ+KlHuEG*P2u1UatJKbKSdof4V$B*zv;f_{X#2@-)0S#bsi{Dfxn~ zMYLVv5IVbk>1AKNr=Q!txZW>w6R-a`XMONf{PH@NtG?O$z`2ZTLVeq9H8!n{IukX$ z<@f44jt}0rF1oAb^T{>s%kHo%uRl_@$FjAzK4 zt^qrQ>H-It#L1&B@Ws8rQf*y z{jI9xUsthYg}Gt#DwPa!%vUp|M8|jIr~P`f{OiK|GE2Oj@UTT6C(CZ~eC)pF{1EM+ z`UkCMpLMt}X;BsHOS5c}OXcl!RulQ>z8i=0HXIf6Po1~(-dA1PIe*cpVO5$<&u-ju z{ygV_SFg-o=;YMsNu5?JhAz-rR{NegY3kzLm1Ow!eB+ zCi>*g^fKo*c4#wow9P`x@4K(IyWm~i!}<4x6(_8g+k2$A{pZbpm)Lath4tK3A$6|| zp0YZ1{+OdBb=h;~&ZyTar&84kl?RthOW)_0_u|fKS;gf3u(-d<=Z>G-!eS)?_N=M7 z^{z|X1&z}fM&Sn^-fQ> z7p?vCIH%_wQL1IDtTJQUgjz0b-qY>V^|HzFkDGeOwEt~G%FqrM=WL%GFf#wZBe&jL zxlIfou(d||-7>-5JOg&WsC~@oueY_r3WqdVljSh2i&&K*eSB#{M&8TH!{kBclSd>-<@|#mFkBXSNAB zTS?CUv~}sxK7-P&cdf28{{40ByIWJ6mDDbi^V?=EoMqefVTn;aF7&v)cig>! z2dcl?W9i(oz(%Vn88b-SOk2*!}+1tAGl`$np1lUxr)vsp!mwiJ# z_j#|LI@fW)nSs7Gk>}1|E;M>^OywK?J{^`+cxushc6j|gwpN$YvlGHATyY#&>hH%z zAHID3Hsf;P`K>E!CY9S+`*w!afbBk;CV%nq_?}bh(TMoP8$GUktGYrz(JODG{rclU zn|J)XSJUTZs~Rgqj~^QKrb|}h%2Tg*Oe$8@An_XM%;udXKJmcfD2CmaCjhddnxBY=O`wL~dx6L!p-)hU+ zN{^d3$>a5LsomHwM^Butxp&qdl@m{YliSn(s{N`BAr{*Ry;IKX zT`R77kA1NEbJ?|f>iPROwAcClm{qCrlDD2l%g>Ub>R@b${pc!qwmb$Eooxb+`;*@~f`D#B8jz|u9)u_<1le6Xp=j5DN zy{qxc{5kQN1)^J2b(s-9ETF3Xz_ep|qJQWc4P80Zs^abZK^fzJ9I23A`evbzUuy-& zX{XJ8=bE0}%(Z#tW=s8-26#PPR{uxdZN=Wy9@fC>;Q2Z|)=V0BwNl`3;d2stZK#lU zNwbLwYx9-vmXvN?y3(Il=iYp`XUeLwwO?j^Zkiq+eD%e!J0Dkm`zOk3-{^M{zs&Zl zQ2WZg-|u}NxuVTE?{!Vi`+0fHpB;C7)u~m!CB_}=Hls#P)vSDH z7Y$uH%f@ZjDgSyC{rrDx|FL|fIlX+o$Mra|wxOV&75fQaI-aFDJJm}PkYZ0~99~m(8N#pb~@9aAduK51ag@KE_o>=W^ zP#}AFc;RO!FW)Men%rUDjgH%TPt7>+yMLj+TmG1_^h?*jPEA`_IH6&B*%}o;x7@C2 zxOQ#X_I>76Df+PR`O24FkDUAaZMlNm-g?aO`xfk5ujRo-HO577cIZvEkO$(V-QuT=aI6n^bqt*9f@o7F#a(6`sBcGWU9-OC(2;PCnS z=r1=y^o6qK-afb^;YqpYIRmcublf=Y-+BeRmE0e9xp21Uv{gCBdw2|8<2-2Rlgl#- z{QInM$h#qru7x&v`)X)i`#vLj-`>~}--l_sMwj^DTyMohj~ipxkG|9|N@p=(#Dq4j zR_=WnGTcgY?ncD;oz*H=_RIgzg|j8Soy-2B+fyaFOkj)amMia$ZeQr^k*xzt#X(wuteq?TmDL>BD;`H4$ z4L(fMb)37^v3ln9Vn<_Yee9-Beq7A%(8jeJrt}L~pJ(~~;J*V})~s1HCE4eU+vyLz z++DBF>*Uqe>-zUQMSJY<_89gy=yO-klhIS^?5x;5v0IskwOunteX_Ocm({Gw=%~%# z?Ykav>Nzc=Th~)r@7LK@n>0D^u+@1hXMOi+xASF`P1B*he^}+wO}6Pd`L{O?u8!fO ztLI%X>hDigU2nhMuy2+7;N;_l$7svGYuW$lmD{DurTSW}>|H4+d;gf4br+ZN@`#zg z=C#eJ!HJ);5^rW#o$KLLqEhHfx&PfGlM<5cVxyW4$!o#h(6aa1?$LT(nw`DVP2fK!3GebPE%2Oy=1pB4`$;`swxK33*IBr;El*vO^UqOh;6$;-ewNSG zCpRuPq2X69SX%H)+PTBPfP@$7a`?GrOACJ4HZO75T1`Q{o$lG4Naq)PyhF?TuX|a`|yr*nRW!+F~N`mG*+wyXvi{9I!)|3Jb|3H#! zdRJ+_Os(M`gIikgkCu76ikh2Q)|kCW(V7Hjg94kY_*18 zW^HLv6*Y04VwpKJCjG-djJLGlm!R_=-%!eHg1Q`jgH20|Dy+hM)?T#ppAfo3$@a?RSYj~lBs)}ZlYTV9L%ft|alHPt~Q_jBNo zk8CF}u5%60EMZ$-=fN9%S^pSoY(SI9!hFwvpRsPQT4M_ue&G)vizD%Wu_PEFA8 zEl;|XMyxB1HMLj{TU*$c_j99jg)XW!wL!x#72^^#GcEJ7Amz>t!V%n{>2C; z(^TI$d6rt!5H#L=%l_}*&`Ph?*nx&OitRL-yUCesc#YfD2sHc>e7^5g-#%iJTEjm~ zvb5kAjdHr1dx1Au(z#|boihVWD% zQ#+l_qXFX#pC35nE06XszF(+iFcq(6Gq|<+N(paE4mb3N-u`fw!h> zx9pN?4gUzj(!vWh&#JC7(Jpt;SfeK7*0#m!ay&r8dx?8JjB9RUP4EPbmTh_4*IfxY zr7nlp#FAgt1ZhEBk#A~^H)!}}%4~7cM4!8LQLXU-4gdNNFDw4yfSGCyn^Me+j|JE4 zd1^IZt?>m7{}MHy^ZK1%*u>;5G@L(tWwvA&cS`MY9)Gc#TH_Cz!3^a`9s`HIF|oD; zfQH{hu^@ZYWan`c;}r-Re(@|DD9!FQ4hz&?L7?F)9#0it+wDHT=@Q z>(rVM(C{M@p5iK3WV?uQ+e2B7r3IhWJg33(b#MRyQ&Jc2S8HNH!!K6nuh30*_l_D~B(~)_ z>!J!DQ)}Wu!v-7XnD3b>ebt%-(C`cL`8-^^asLmsCJ{7jF@^qFnUGOO(y##Ras01F zW6g4-lalp`TKQ-JB9ZY)seBM1K_o_>#z$955J}PN_*fc5QuTV?LW4+}KAyKnMEE0K zC!X4YJAcG`m8W1O5+DWGMM>O?CqCDC@>3$oQb5yQiHyfcs1jil84|x#N-F07Mgo+` zJ&Xh?k*^r>S0d#sq)?y|vByX^CBna!#8X!#(i0<{l}I{9x+sy!7||+`6&UHEM7Cq3 zrxH1f5uFlwgOLa&QdVj(yJ@A|b_a~KRU(}*(ng8!+o|ysu0;4x$?()ciO81%cTytv zP}312(J6Xm_DFLqK^GsNq)Z@QA2xjqLOjwZH7O-cvSM2v(PrvWQ}uF?N8+ROS@O6` z8huJiQVLR)7{&JpcC822$4QA4monI;B(kOoM)>73(!)9!@lYboFygL60x(imiFCk7 zIVBQ-k-QK|?USxc!T#`qNNju(Uz#A*QK&?uDk~Abvh!rAL`Gtyh!WwqSK!G?iEP0L zzluhB$iAZssi6|NjFDnWw?uSc!OJ#7>Fu zFDUZlqC~o5#1$fJv2m3Ye2jU0Sj5Q@LsjJnU*aI~i|Z^ksd2H&)bNA|&*We7rF{7XAL`6!Y77;#o2moU;;iQK_R4J9Ifb)>oy`HGrq zN~9oL*?Fo05!QBXL~I%?&^C&uENYr55gUyBqC{F@q@WUMkCFUJBnl(!OF`H_eKAr% ziOj`FQzh~TMk*?iEf{I8L=I!5yb`&Dkp@cS8AkXeW76nYvR7H2>OmwnO`oE5afXP4 zqN$7;ezBTFHOELJCE|yXnh=Rf(niN8Nee{=Ht`J|!@cphO%n601Z!F=DGk zI$)%>5{bbGzl>69=|GG$Q6iHtQbvi)!$?sjvKAx7mBAu^dAQ%Q+ySR_@i zyzuZya#E%&V1IceHC9<{Fk%}N;^2TPKlV4jhDDTBi@&pjh$DN;3#q#tY1|ki{1^u` zE;8n?MC?%$C`X*+2!DS8l!F}M?@Ayd?I!FQf4?KS%OU>mMxvZC#E++>h`g@ycN`FD z${s-K$+i%2k?X9JBXYs)noZOwH4Kv@N)7pYPbf!jsD{5Eks|W3AAdgx5og(+zl(&3 zqiohm72)p?LF44gI+`Ep$H)a)a;z}aUL@R+?qY(G@R z58fH_Ky3_zMq`&OsAQm+1?(^L25s#nD0ielL%jL`C3`Jias6GW;?)Vmpdnr<#H)Vj z@;?RDA1TlfFTRIZT2y9R3-*6p)9+s06|cESfrfac5w9-+_KgL#7b(yXuXKfC4>UE- zPGDc5$HiQ83n|bLuMCCaYtG2b)CfTp;BUNH0uAxvd!r@$!lTsl))|#Y391oNpdnsa zK*{5Euesw-r8_L2XA0G{kEd@fwoXeYv3iLJBm*D;p@@hrC@QtlGE;3Qj4qC}@b+aG>ON9mu%g zCMa7gmdO%mh}W+yD$OXK@7eD~WS}x$en^3ac#TjfUc>wCV*CXaixg;x*GQn`K6HD~ z%v(^Skpd0z8b!Rym8xA?P=6o=8sasYcwNlnJWEh#kOB?y8biE}&b99*sK1c{4e=VQ zc=7dc;NTzKx+#5Ff)5Bwpdnu4SXAuGlYZP9C@6cRKtsIvxd$;`HP3Xe*;VlhK?*d) z>oyr#VxwLnl&NP&iUO$Q2J z6gB)9pr_*1A1TlfuNlOv)7x<~1vL{X&=9YgK=D50QlKGTvw@OdzrGLay;D#{in2_WKtsIdu&5ZX-K94U5mYmzKtsId0>#_K_mnny zJIxVP3{s#WUh|08u7;!D2x=-)pdnuKfs)txu3hDq-pdnrhh?nMEm$HI-g%oIr z*Fxe|uR@;}f~r)EWwHbs;$!V{b83aT?wpdntXh*#5(iERZn5Gl|QuRjzo z_CPcJZP$Knl|EdE6ljRoYT`9*XU`Zxokt2Z#A^*u@@vYl)K2T=DWk3N*xPJy86`gU^kZ2j|umR2ovCAzmAR zlGmtjb6=zhY6()HAzmAa*OAX<4hrfjQlKGTn}Fh-#cOC$=j22|{Zf*JSON|4+RUP2 zU*2PFGfhzJ-kFdoxys7XkHhInlQ%9?N4 z|Lkf#77J<%QlKGT+kukD%OmNJnu5wf3N*xP2T*b!&acz6o1iR8u}qdgL%epfsOZC8 z&uwoDsy0%fAzr(H;_C)aH?-wSbW-{-7%9*YuiZ>5ygny~TMKFsQlKGTdw`PHsD4GO zZ5Py9q(DQw_7bml(=xsb>JCz%Azu4{lKZgiEQ^_fDv8Yn4e{DfyoS%&lqx81q(DQw z4ge+hVOH2*%Q`B3n1Nx?5U+#8i=Rso)NG_cL%a?tUVI*Y?fSNZp!OjJ8sc@Bc=fuJ zSW!?9kpd0zIs%m3hbdFi3v1}t?%3N*y)ILj4YqfZai2`UjO&=9W^Ks8`n3-xD0w}My|BKdpn{MB z4e`1_yb9WkPjghfdLsoI;&qXDH7OOcM^HnN0uAxH1XN|Vk3eO_v8Dr-{bL68sc?_>y>k`=jKe05R?s4pdns& zfs)5-=cwxLf@+QwXo%N6;#GLLkcv+>%Ky<2b$SwnoI09&-@`vaY%uNcs*db zqFp1qk7R9>sS!wlhIl;$ss-P&|A&5e+a{<5NP&iUJtAJ`-QU&~)E=ZjL%bdXCHG<6 zw)5Ksbpt8T5U(f1>(8UN&I{@TQlKGTPl3X0%@)^EZS9oaC|!YNvIH99^^8SDAFc`S z5+|toNP&iUJqOB~Z`uDzXJ;%Elm}9vAzm+llGpi`!RK}esxwlcAzm+mlGnq5zrrGD+y{eQlKGTe*-0t*M;RX*bQ>z8MP28&=9YGh}ZekXX*-S2U4IR zUau7|_CQlR!ex((;&lNj&=9XT#4Gjp+cgArA1TlfueU(S#~b`So3-Ng4k^$OuXn_& z)Ag*+g0iT{GFbu*@p{jq(v0Hy{Csa!#j6NXpdnuWDiohlYX+?SMNpNH0uAx{pit}q zc-2z8>L3Lg;`LFXxYy_z)0PR!1u4)FuTKia9)Opp;^l!9Xo%Nmh2mcPb0R^7AO#xY z^#v%y@oK4fbwLU=#Oo{Zvc5gDxS&#y0uAx{rt)Gp(q=K9Mk56p;`N>7iglxj@3MY^ zT8I>Ah}RFGIhPxAzoH0uj-1|Ur2$5coimI6>J=01@#Y7pdnsGfRg8Y zhiw-QR#UtzD@#2K8sb%yc)gyN79^62p=gB_=<$)Av zh*t@P;%#_PbmLna#j68Spdnr*6^gHi7vd_o2`U;X&=9XuK*`4dC(p&C3n~LC&=9ZE z#B1lZ8Vvc+*i0F(dq{zXcvU1`v+K_)AgB*WfrfZhQrgAm#`Sv5+p(WA z;tyG}sv`Xb4e_c>ydLEbWIu;0Q+7y!hImy`y!ebNc;4e_chFS@ zh7@RsS6!gwbzZZ->it4WAFf3TG{mbO@v6DNqq3k*Aq5)ZRUasMJzSv=b`;cOq(DQw z8W69s;~oSGDql5eltDwh8UiKv;fa8 z=egkP1(ZJ2A_W@aWly{|t?^+O+RE$3SfoHhyc~d%$Lm7XnTska)K;WGL%bY`*Sq=a z9|-C=QlKGTPC&`yRcGyxGlIH~6ljQ-Gx2h3vZA}7ULXY;;^hLAJYMC~9~)3VkOB?y zYD~O(+b?5pGvq!ji30)};?)Ewd>PO@O5Ky)T%l?r1sdYzO1$_nwxC)d1sdYj6sS6E zZm;s~Pdyv1DEaLB%2k8sgO)DBg!W@wK;s;x*VBf*Q~euNK5> zTM3u0f|`dEXoy!!pm@7@Y8(G5xSry*+Zuuz&=9Xy#H-JoVygso6DiOTFE@qa<)+*U zYv`bOeM1T~#LHcw_=?^A&)sbWRirvENdrGS!`?|5TubbsP(1%mu>dzi%RtN41Zlv^K!5UJ#KtsIzh}W^+ zhdcyT6)DgVFMpuqIe+3`-M$Knmm^Z3AzlH*YvQgY=LF@26ljQ7AW-spxTS}47eTc{ z3N*wkh5&2r@d^gYnspYR8xOW#+aRb+q(DQwLWozp))PMpYBW-yAzqV_0(h*u}#H8^6>EkX51 z3N*y4Gf=jyP3(atW!PEaWrdJvxsLx1&hIn-cN?tb}1Rd<(Tk$H(o68bth*uBd^=^yzNI^Lw1sdX| zRoZ3AN#h{P>2&#Nd)RVB<`@k&DqG{mbn@p^HwST{jUMG7>;D-I}k)+Y8qQ$KiWw72552`SJJuXy6+ z)~@+TL7hMfG{h?bDEYiic4X1ry%euoNP&iUB@(YK4kgwL>K#&`Azn#9$!l-su@8QN zDp-p(l_k&+uVmtNr%A*XL0KaO8sgOlD0%IDx%_>Ypqd~B8se2gye2)}>@27dq(DQw zQh}29G)&&LiH&UP>Uj2wy z<9AED2r7SVX-0vDc=cB(uHc^`#wl~Y3R0jUUIP@0uh``_o+>CP2c$qlyaobg&5c;9 zY`3p*g5u?k6ljRoAnN5(p{}6fkpd0z8mxG+2b%D018iayuPI1@hIkDjUVB>XTPmp4 zNP&iU4F!tNdG2*5+0M>Z@j8qYXo%M^;$>HH>^4E&MhY~>mRa8(8NP&iUjUZkH%B+1as9>Z(L%c>RUaSi> z#cCfrQCsQ5SfoHhyhahPl4nZg6I3=*pdntPfwJdDEIoU)C9;L$H3uos5U(-B>%vjD z0fO3z6ljRoScT$V=`q7QHc`B;Aq5)ZHBO=U{?(-E&Rc?dixg;x*La2EULE?x?kJ;p z6|Ku-><1UQhIsv^P~7Y3nrmT#vOx+o#A^aj@|-U|rhU1hidPe)KtsGH60f4WidqUP z6e-XUuSr1h114U>!|gBc7gRJ-pdnt9iPyS%{b~woFjAl)UQ>XQ=ls1kop%aq22!9Q zUQ>zJ@Rg&}1+@Vw&=9X_K=ES$_CPai?s)IwN*|s?3N*y)cjD!7e$PLGdWsZih}U$* zi}&Hx+EJqfRiGXVu>>08HG_B^(YVhORBfa{L%e1JCHLW)X3zWu<%<+(h}SIQH94jC zYeB^z1sdWt8z?>xd79RzRQu9OAC5!{G{kET@%p2J^Cv+qMG7>;Yc5doaj(Vn)168w zUI&o^4e^>sysRd+IxeV}NP&iU%~!nmcunuoDO6D9>O*5Spdnrhh*!YA63YbTg%oIr z*Fxguc`B`fppuXR4e?q;yn1@JJ1VHzNP&iUEe1-S8_PPht|q8sNP&iUEg@b%3M}d) zsJBRghIlO{UXT058c@|5NPP$z;s zPp$*%va6|O>LpTKL#eeu;YV?r!jnE+6I2&$F4s_M9Z+&_^tw^Ikf8Qpm}@At9;jAQ z1vS6DzRb?Z$u+FoND6a}6dTVXe5Oky$aB}S2=7bvm~McQaXHXD-dc*y3AyCGSTfhp z`fLOW4+u0L`!r{l#mQ6+d+w;wa1Et40mV8O()kKavIR8)DXyW^W}tAQXnt!oI$cng zk>VOkZ2`&;y&6_xr>vA3ws4TbTqD)`4;HazL3RIZg>vLe&<+)A^HpZpofokjuA%PR zfJ#R93spV51ZC|gg}Fv@|CL3oS--2@x07;gzdr6NGwjE%u^g_U?mK|;ME429n#BvM zf|C^H8cOXX)REHTItr>EQd~o+T|jxG*W|b1DT2C<6xUE{H&Ak~o_qD+fuKB`rNX#| zQhR`s=jznWpV;N1@~oSM6xUE{FHr7S!~HhTTmEYs`=aYHG+y{CGf;G zl-du}Dk)o2JvM8LppGHMHIzC46o0+tsnV9cY%8~`eq#t~xJHV#U=e#|w(#6w7U`)( z3|H)fP;yzR2u(#Bs}gc48qFXqnQNqy&tQbhX$=oSIm`l5%ZAZgWrkh*gA~_L>M)@) zwmcj!sHaGA4W*6%^$U7kxK;j%pgtkRHIzC^sP}sg4ii*~CQ@NsL#bngdT4(*Tu^n9 z;u=aF2TJaZzNZrn=7tASTtlf7#H;q8N_yed1}Uzg)JftMb*z!Cpkk5Y8cLlaUIo4_ z9wn&0NO6rc?vpUWdx@5F8pVOkoh8(l z`s`=WuzniNYoxe_Qs)R2KJ0NvL6yhdmuo0>o=~4h)cGhVH>9|RQWpr7l>Kt7prVoD z8cJOx)U&d>S%Mmm6xUGd5}}Gu^p6nKW~8`=QkMyJqT1FWg33XPYbbSvP@77f%O|Kj zO{Kx-8cJOy)W*?g4UPfoBE>cAUZ&CUY3Zr@D4a&T9DdWg#?s<@4a(UrAGFCLO&BXf zt4+}-vsw9+kq4FbHtR9!-Hyk46W9nJ5MXOtNoYcdP&CY+p}+6#`E4VWl>WKxt~ z8=ay{&}&TzqT?B5GDk+4Vc$0uo@b~Efrh5CUn`1D zN;J&m_dAxFV;nVpu1!tTvD?@hbVh0#y8&*3mQ^Drtrr_O?CR9qHLM2{qlku&lGLN@ z=7&0BA+l0?@#zzr$Znx0-djr1^`-`Y>F zVRu$#`&WiOh28KP+Q?MtiOIUiIE^kUO3QW~Hm&$CT&1V!wR{3+CZ(_;kR!UtNPWCM zg_RVg?Uf!KouFgC+s%5KmBJtXXoac$=k8OpWcwer;PH8`CR- zqsd9EqDnPc7itZ6=}2928e3zu$+|Q)Z}`M#Qxn=U09%-SbzbaBYx^NM;M7(%XDYB3NH(aV1EN z)Wz#kpfpt$?1e^A)@4Qor0J7Y!6?1hefWCJe&9^Qsu2|%$@+x%qb7>gUmG8r$bPR~ zpBfvLuEz>#uwEF|#3n>BCY6~uY5DDK?X_&AlW90Hk=^z-#au>e?it$nsK)G;xv_~b zskPjW_oWtR2+lLC6`vfjx_AwZN<+oknVM!YM-E0aoGsa~0LiiBbhZ;l$EKv>!lYp@ zPMN)u*p$UmS+}K1uSk4CN%csPY2MFl7scurK9+75jv1+XT}mV~PD){=vKgtooM1ky zSQO+y%VD7g9lS!uBx%!H@I4jSdpj1)0&Y&Wug8wKr_A8Ku-QKcke&bo}Wue?}>l>GIQM{*2OmXUa!A=DSf* zDL|78Y-)jmijhO>Tngap9vps~Sm_K7!__4i zW~wXCb4}D+3Y(VWp}ZL<={Vn1CCwf0n<&Vv)WjS#`#u88C3~rPu~f2?;qGc)EKSm% z6q}gy|5Y+s5zLFFlF4pwUM$u5C&ea4UNt88R_tenPnN2Sg;!K~KP63f=M`Qal9U_;M zd$-AD<=zartp8GB1C37j;GSMW5FY*K>77@t8xR24RI zH9Em$WN4g=u+eEJgp8v`PR1vtjI31I^0bh9P9>0c3$p^L1ZP{b0;z;t1X2ku|5ZXR z0;z#J}wZ>Im&!op9gZ&s9ax8~G5m|`_IqWfJz>lLLB0ZKfj86N?8sjj^jn4|B zTosl}&+VkKY?Z4$5b zVMN}UjLUI0ps+IJoIX~F#!#p_T`$h}BbJ*&Zdq;`Y1idTn$ZUX22N5re0?&nk;=(k zW3Ex~Nrk!gNSUTld1@F{Og?<#%RZ^GtT&M%wUNI7nj}nQn646h*dhBE6^40|m7}p0 zAn42~kGb;b;K_0&iefXLS)qfuTvIT7vV|XDnZilFTmbtxh5rbote2n4*@hpe z8SwZym`weLO6qA>ThbV_rTw=~DzE8JmiON}xv_?y>d8$bF%&Alc!?tMT&kI)t%yhy z&oCls8mlyh5lPcTr7?_18dsIZFoG4PpFr}%DgL=6*4|8}+!Qm}a=XlAOSF@%nQVzR zn{Be%h98`otU3|oQiSP-8@K9c_wqG+nGwCz~Rb zE~c3h>1?`KskUY^X}_vIkfvRv&PLqa=hldu%|={0K9v^K6nQv}g0!Oe**C4895fmM zIjoxEe8-Vr?3IqCYE@V&+ePkas#b+1bz{?NRajCtF|AgGCAF(*wJJ=zPinc;AvlSp z5S5v|bb$7|c^NH^%~`zCfbs@$1o%NPd>kdNL_ow;j?@#<0k>(&be_aHzyY>t&UBt! zN!7Ixavjwfh=7ag;t9meWFl(n3JU~HW+6r{!azNZDMIPGEj*nn?}hS7BPA?#nm8q* zWXQ{m8A6;KG9pZ57*~m2BcikdD{Pc2RgfP6o6eV)0dx5hFU}DeU7>>R=JS=xo4S%k zsk_NcBb3#I9aWjU+{LJz+>}y#_**o|GdHc&H$SJ9%H?m_ezx47(@N#?@%!0we@-iv z%g60!%l#=WyFyZ%ri)rl@ycQ;!P4==uPbAqiS-^TDwEZ?MwU~m3Vr{uVSGJ!u&;+rVGNq3h$yh7c5!u*3; zhxrDBM4{oO-6eL{k~0(`(D zo+56xt%G+xvh7IQb*5FcQ1dB;MN{Kz9yTFt@QGg z%JVj8J3NE|fG&o?ho|0L>!Vn(5e)MU^z#bwlSWYLM!EZxDuDq+|MwwQyu3r*gFSr0 z0s}lfpgI40QM?*J!GwYt1d}I|c}PbUurJ^NhJ3ZIv|A*_#7LJF_R{O3^eM^|4s`bn zV?*j0>J62OhNhA!45J8RCT1^8Yv@|ogAzFfPay*;6{9rV%ildT%*#K>J4hPG{~sQn zzV0DDp`NY%f~DQv%~qNg<~li<*BB-#>~B)FMU8{q16q3p`uT=HrJ$_f=o=X7Yj#G8xem)e%omv9P&=5y zun`j;2sam{;XYpO{$W8Z1+<3Fl@@m1Ab9EN#UDuwv{EdaP$cAlq1ex*ec#X^$j2kZ zDuqldvv^7eQ4_w)}7@xfgP z`T#mq%uO-)&|$C#L&HD?Gbl&?BymOI^sJR>FRW{ zC$n|m$2TOzH^f8Q$&9?AKGISGlf(34#SV+KTK@!gvA(B{U0ct;)TWDfcZ#-$B%Zq( zJ=aSD+zMTEQ%8sBh{i^7XM1}yap$J?(NPgH?`$6t&9q8V;!cqelb=Vbb>a$q>Dqg( zHY*{)9ZPb;zmE9V0sq>w0wq~AYq9zNvMky@*MBH;`j3P%m;Xp8lX_mRu)V$Ub0e9Y qZTuHyQD|!JFUq2^3FiLFGVBi4bMVjjuOgGWHku{g&BlK

rN_Ax43(n$(gD7FANsX8q^iuuyhoG@x3e5pyTYmO!Jpa(^c%XhqXCzRE`5LK zd|egfSm?BHBJ$8+Z}s6hEKHJ;QE7Hr@F=ueuiWU;i)vl^+d`b&U7WsKnq0olK1t#9 zoGh%k5EA9m{XyAnlIJ_>$x1O`02TbE@eG8cMV+%G@n=lFw7dzO8)W9p+$d$z8qdYx8tkZfsNv>IU~o&J#3iGiD3 z`_Kvtj`ytuI<%rK_yIslKFt@hW4+5;BzmhxRP9!m1+rebc(5<=I;Y1Ua30&>v~11V z8td&^)(?a`t6L;IcM`ut-D&)eaQDzMc4;ej;(a9`ZVgxNPuEs{b%i)NTv?Y+io_n0 zxJQzfv4sf36=KF(ZTLEE_-ESikTznUHhi;ILgdy?+RE=cX&H4|3QiJnyPZ5@3pFKM z8H|-_=sZq2bGK?Wl?-y|JQ-lRz~FkB3|7)XzRoe;-wl0QQd^|;TM~|F!;$}oJFQ2w z5q>1@LSCX#Hok_pGe!CY0GuPxex4lB&fQ-5o_@rCk^?${^5L9>T}tpNEu;0V8QAMf z*^T^MVwOETneuVzoa~VDQ4S>C(Wu?AmRKT;+Brm?j9N>oSk)laP;kXN`pCsDd_XiM zX>(Hm6!2^bX?EZrZ2@T##RIfVqWD^lF|e2V?OjD5k=PYoVA9YoR>qhne8txYdl%6s zN^4vlrI9XDqA+wxFhSym&yhs4KH+6Z3NN&i#xvZm&N3i{5?Mk-$z}=c+?jOtuF^5+ zBq3Cn*rGZ{Syh+VQKhjOwGm2f(ny&FRhg6?Q&}RPv}t$=;YM8}I?F8V5Jj3Rw^sA8 zU(ZQPe70 za?K}*0*$*QApBZ_4FZkgLFZwc9UCmgBmxS_((Ns%Z9x^M;n|DY-r*bias*7S8Tn0 zK+k3_(bugz?kHX5n`Uv8!gGpLOz;(`8D(v{RmgG z9CVa!;c!#D!*k@6!@o103%u!;1=@rpT2zZZvPesclON~Xh)D8bQUzQy(%OV5IE7dY?Ff-0&xo(Ij2%423JFozEzu=* z`AoL`K*3xfF}#i^O&R_vDTTb+!FS5uDL;4)E%}IxXX~78U#;W$z|vTcms`)kaW~GoZ@fe?|`oHR_NTdq;kgZM(IM zl}7QOw{dn(inqdXec?ck8gPR9dt|_LscHbCJA`ZINwZfSZM-@p71Ebk9Xv zMtzaCvVMnMOQ~fcc#?&nHWppkcgNFa(wH3i?I=IDCLCr2lK63^GHx5S5$kw=ko9@5 zwsP+tErZ^SV5M!;R@Uy}m7+_&WwoV`0zqGED>ujSzmt*OLdN?t>{`ZwBGzZx@%^__ zY?^Wo7o;dTDLn#Sq~sGKx9*Xz5MPH4V3ZB8J=)406t_c)+ad0eN5Bx&CeyI}+K2<% z#ov?s2kqjcTFK|y#kk&W(ncKDO4d*f*C`}BY4vA-rZys=t^DkHZRP4|1X6#UHe$JU zajll|G5J5E+D(STx*@c2v$k>_&-L^Xj%0T-iL?=)Y9%`<^jiuY0}pamq3tkhtz~de zv7d*^U3=^m=F#PSK^7G_ZP5iVQy%C}gDZEl%iz6TUd8y8--j-*p&s@SP5jfSs!qku z5L&}5n>YUr9UbiSH>~MIt(8$1m-P??|hY|$PSQ!*SOG`vbHS~6^MVl*kSr~KM`TEU516T}0Xjb-~= z=6fd$8*wFqE!j8lGyMig3b-mzKm0WR2bjhXPcUHwbO-EVycv3!n37GrC#UpO6sF`$ z`4}p7i~voOoe8`Mg?KQLh$L4}#V^=;9!S4DFfFq7hW0 z8UaIRw81Jv#nnJP6-USZ1-!KOh}wRF$zV{mM_y+PQ52kVmadQqUC2=4BNRgJKjrk@ z#(%{Qr|&^p)_ORW^e9)Wh3Lo0#*ZuclsrvFdAVhlYP#?5Rkx(iDmn0#9qLMzOn%Vgp98>T7I=z&|YZ`beqLpybY% zNTHo)Gwkqw%XV=5^yR5qufJA4GyL3r;7vr9XuX%oM9;b`*ma6xM8ejF+Q_ zsYTu#7iaj>io98}MLmHyn_Nuzqutwv^ID@(Qh!Q(Qb-#o{z6i4ai`52C@OD#6ZuoT zhS_3cJ9Uszdtwf~Mr*}&=Mgn@b{L-jS^GyjW&EW5<1dIb`90Z>5`A{m{;`kOW9~)i z9@#VEv`XO7PYun~=cF|4ALRmt1S||Ac~Ld%Pn#Q2>_fFO_o0%ac89uG%FBCN?Lc9J z7~X%XdSCX;P%}ILHyA$6q*c!*4E?eZ;PI%vrtmqNpRj+#udSS4yn`)I)XDDlMkCo@ zlDouWhfYNVMIjk&o(cDyiUfxwR&WkF*^!|B}ZZFx0fV5#}46gb%4V>sfpIalx{ z=dpk(8}~@qEvM~rCeW^bp82^Qf1|md*|l3%IZKN%a%At_Pl1=lxu+EgWX^)~DboEY zqVT9ul&0(fLf1u`!~PzdES9Wh9L*JJ_7if*&}L}@*)cZ5UvYo(v#wa@IN`ay*Pf8O z;np}yn^+WFABZSh5831`^lpUys(NL=*s%~3z0eisE*~38(K%OtgYGG&?DbCXj5G?j zK1SKCi#kH`rLq#cRF=$d2+bV`XxDS(nP%5}DEs5kMJ7nOI~lWi5krSS+0ttormMzL zzRK@Hn^9~XzZ78i_3A@4P=Yv2zYWFKmOV|P_xd#fM5h|jizNDXlvaWFh>i}S*fU3{ zgwk2+Mr)Srdl|7O${ zk`qPk8O(>V|M{=sw`t$}z;08$+|s^TwufY^C`8!P=sW6)0BnWq{(~T?!OC zDj4kLGoq{cdQWIi;CiBCp$Yk8Na4{{t+bj=0xr!~ZSKds$Ynx4>!bdI@yImbdo+u( z$0>x56irZ43c^mTfH}utFtubNOYHKMOj@`{uyJ^uyogdQB4T1VgItj&KT2-|%a}Yu zawQdt5bF?ObLboxrWSP&r9?o9rV>7rNlw{?Py(}-^q5-gbA){wKH8{<7(tDq#%N8EnYXM}6Ypf=>%#n? zaXxsc9E*PZF=3jSanw6Pi+)Q`gelaj zFGaZ>%i%r#-(v8lP)cMKs2K)Xbotadhp3|oqZy&eijkYgfpi$T%EZ`Z5u2{Y$34>5 zvoil&=l>At{3|Ux|6kJirLty3IxjLyOy|FYFa4i)zMPe&W#`Rn(rvR>i5*sve#-3j zv)j(y?Hxw9V+PB=JE6#O>gT%syGXay07U0p4mW%t24In1Ki#s|a&PGWyw_rY6Ycfw z^fS`y_{nBLH+}G=__VQ@| z3%(3)D(ZkR!cu4eR$9Yz^Wqa5= zCBgEeJ|)5B{bLnlgSTUG1e?Z**U}n+MjzX&c|IAoSywnM%Wb+(LPH%nxY@x`+7xKq z0#}D$tu%2w%!ORLi}WU3(4NBQe6jx0CfVAy{AklBB{;n=RFPB8@0_FTD;@aQiz)j; z%EtX|;5Sk{J6n1kyJ}mV`tzGad4>~}wp7w+4;Niy6kY4S-dU;|XtS&-%6nTi+vc#; z7wKbNCedTk%gTPi|AeODf`&ulQrD(HcU9NE*hHzp=_KL+Ml_>VEjkkA*Lbvg z*{W6FAusrYm<#sI;n|DdL>aaH4e^|R~88LX;32eez{;>8RweS$h_C=@2Dxv)e z)$UkLM7?%L`((BxCA)U@3Q3l@h%#F5Cy;UwI_2v-^`%PmgiE9q|3xsXx!PxWEnN7{ zFQv+)_J3A+sG9r_sf5Ya*NC9O=r<9BSHvSETZ=IAoLd07lnZ(b84bXT-iu>fE=3!g zo-ut&*47Uot}P76!VNy7yWgq0&F)SNw`hpjqExd*+8wRCz&J{0trLwFi61!63adT$ z$n=+O-bomqq35!Eb_Ou^F##RlwFaDPPjr@vi@>8mcLI?2;}ReT@U6T~SzX8-NJj*q zOOFSRd?8TEL57wowQBKkO!qltI-8^%pTG_EI&`QqG5j<5sjkun+!!nSOmo6ypq=#P zFsAX5>Edm8>uZEHzMaa{^vf0-U?34!NJPI#1d~F~U{ZFaM4p3l0GQAwIHlHay7Guf+##5JLiz-3leXeLFg z>ZE9!aR~u~(^=wsG3;{k}xq%1X+q-GoryoKVr0<6VNYdK2Vl99IW$ z8D6)yAl*E>Ok_A@F7H?mue?^SK5P9aiQ=XGV)Nyqcg&YAADS=SR+ul{KQ&)^ZIBmk z+1o15$QC;H5y&l(;jl zRsKahFWf9%{$;#Gosb_c7cXxhy!?;~qY&;KC!ACJp_L@(Udr+>th~_W@-M9tbxMAI zkSv6kH>fbKtTgK5g7Rp63E}#9*?OA)AIE9;9pXdoHNUSxULtiQNrC)Cb4y5rgpg)E zNB`I3K|m!b|27;|zJs@W>!nmg!dZ#qf&B!U*Yu72e5dZE@w42DRa5o5EVjP<-U{FJ zAJ=_9dk<&5FVauW-t}kx+J*FO{_o>w@8Pufm9uxrnQ!037vl5~Hczv6apd~~{~qh? zJ#yl^-8KnLn7ykxt|`vHCt>y;IquzVn}0>phVSvj$(89-*;%mQ=fIWQRQ_~O6p+!$ zRQg$#@1I(|CEoBa<_O=tERF`UYQ>j!Wnx&D-1C}&EbMK`$Ckr>) zCsDKm_yBlSemXv>-r%EZdb;HvZg((V<9U6~cx`o?Rx_Vh#GUEsoa3x06i*LbZuVVU z;K;jo$OG5QrEY0*Tz8>Vq2F5=x=K|q!K!WyIRg7RD0XJ`Mb*u2%~k~}CS}QqutsUp z>Yzm`JLk#6kL9X7D!<>Mf8odk3-ECPKA1i(BFH7<4WN!lOarUOCZ^+t;+%dij%YLO zi5aAEC04U8-cWrnkC>}%kg-pU5W%%BC z#ibk5$`HmmJP#Mfxi56I8t7mmhKNs@OO$WLPuVf(;vJM@@#8)tMQ*MTD2l>E=(Xtk zhmhh~0$yCUp)q-^E52x~M0hK5jB7d?K5uFcP7=~Bb??U@Yk5MQH00<0Eb+1qwD@D* z)eTJ&@lF@NHTEBYJ+8&S)heHnzaROFeDLxEf3e?E_L={}v`Af2P}&*)?7zju{(~T_ zbeVQDSXHNC-EKo&!_xVsbBT19T*oE^UrNsaV`Eo;yd~;m$=6Mn`KFP>R$o+_?(FoN*Mbu6fyQsh+^#jr)T^LeT@AVG8y|P7E-bQLOEmq<1F#fK?)IT4FK<_ORE?&Y3jtXQIjht-Cb55*WxR! zAWfAxs=_^{+hl^f-xU6Ym}ZAr^$QCatxsxqZv($tpO z%O;PFE5BR%FlHiybDjDPmp!p;@;&bHqb5uqb@zkrvWm2Rsswl0q^YB(j2l-`X0+cJ zzENY#N~er1Bk=_HgfSB{Bvi&q#`I?&Y5>)ojJkV*yCSWiU)tojO0xC5A?=2-6PHFp+<6Y*)+F=Ok%3dESV~zWfP~4DZQ71%gZXlsUpoRrVD0sRoEFn zX;){)U0&L~pknHn@`^H5v~>FJDO2tZ_rIca%)~L}qsqrT5NY&4GfB(bY15~tJ(QN8 zCdExDcbAPFMXSpvaGS0S*_p+TEhDt7d}7&{`^#wg)Uq+rwnxjqHf`L*DPtILW5grf zicW$GG6v<$DilPXv(Xuo)2>SEnQ094{Zl3Y_>;z#GSu#}sXa$cpj|z{tSM6k1|v;~ z9XhjBYU*OZ#{{T<40&ouRQt?fE{{y_S;H3vhtesNrdGPkMoC8>m{LBrA|rOB1jKS8 zb8P|~^9#`5dGAOjrsoZDGCw@V+&^Z*#4&eIEW7i;kw)?N%Hyo66xV~u$Ad9D;>95r={!t)++5V29EGL|=l$8PfdW##TsCY7ofRWY8ff#_k_ zA8Wvv3XV+P*+8EuYe2zUyL+~K@<>nbo0jbSwDYpBy!68C(SPck{l_n_${zH3R`!s* ze%VtWb7o)p;_cZ>o*J7yY*Iz`oZrvRK6U=%*-u-a&Ytkp^Vv6i^h$RBXWqzuy6Xqo zyC_FnJaGPc*LZWX;Ae{goMM|bJHrf+$wSIyYxd;N0WE4_M-d81diz|vk{U$?r~ z8rv7WY}f7Xbw~V>UQdj(^uFcucD;YB>(F~)ap&HF%ByWmc)rhv*S^x{rsIqIJow}z6 z+Ro0o_g8w(BPCDeT)p+VoOY*P&KbXAaZcWVr8${1>vLYL*_5-TY*$X;+QT`)AL4Rv zyuDrS1p_+}}L8IJf=zOLNB!tj|6FrcJpwT)8Xv`#pzpyL=wkxAk@H`u0fe z(DzTj?$r09zjf>T&I3LAPCuB}_q?kdeOLWrSl{m~rG2L@yRUEF(yG3}j(Xpf@lW;L zI_tT!lu5z-?6iA+utARJK|4qd23s@%e(9Qc%C-3-|Pv+h9%jfcJ zzj`_E7gsON+xh(ac^%fQ%Dd#_jd^Lm+nLv^{QAW=3es-D-KNUclDsEezX2_PQN*iJlW52?6>_&+P&QG@UqwYHD33A zzgELn^_x_@vEPV}JNvEsxS`*jIdKIK_!0_wPD(DAzvI$^UmQv=xb9Ea7d&=hUctwC zHx(3LH?*Kn3?$cRFe-kI6>j*M`mH!7n#wbs=Uko(%9@+kO8B_u=2ZH)fT!G#kj){q z7kO6ys=0YT&!O(-W;u(v`+n-@`I1h#JgetYE}F=pPc%1Ab8|)_ z-(Pbkj_26z&CQGD`E7Iar#$Vunwxj5CmoK z?7OqA+*j|;5JRDEqlQ!piPfrzLTQ7FC9>@b^uF2-brSq+jUGH_chf!@w~ZkhP7G>o(D29~)##CO-#-`J!vg^xX8e1jvrBxkIL-Ec&0<~A zd_4+&hp%$o%aA6Sc89m<`8K4#2Qcf<9zLf)Hw(IP%zvNkrrqx7Ovu~rm+Y<1gjS+@ z2W-%rTU__YtcT9%^3G^%H_g`{g(yvPl<4ruf_7}H>+V7OzILIrZcO%?%GQPJREE_+ zJZ8Y-5dPuyMIXoG1{(*Xr&HiDy$%1p1pG)2$lM)mBbmd07m-O%7h+wG!G4~A9rVd7 zdK&VoDRO(0T~R|c*7TpMPQ&KD+KAVbPv?<07TcLkLCCiom6KCoC-J{WTv z@Vgi7j~obxlb-dliHus?Hb1fv)#?7F|fx~s`iwcEYXxv+0yJh8;a&B!$cUdytU zHDQ%2k_+2eX?sG?jCSN*_Xys}JQKOTw$#R~6XF}$F2wcy#VK6R8|f_J>*miI$wu>l z{y*AH_`&Pv&WzXNAI0ksc+Gvob?IFBA zUOs)@)IeKG(Hd;SoL}}`*S*v?j#z`Vo@EI>7g&NQqx}%=1Do%6-Pe&OId+G`FGQPR z6t0gp_W|06@{=fk)!ygee&{FGE`zEayiS5w7JEu^RwKJ3*QNd8$Y&$k$ivLQOlB3x6ualtu=b;V-fTf zyoIu&(H!xwsb?eh(MZr(909K#$MAj;jfKCD-!#`=)5q`+Je>q7T|YiR-N%22xytiC z@>)pm5@-*$4EyV8yvRYnluUv4dMkn5bi#EzU`Ks(i0wG&kvx?|*=e0s9u#vyZ3PzQ8r{CF^?WjM6oc@M z3s)!XVAy}n=tQAr@&B*?Yrv|3S)OE59P?69^nXq%w3tXW)5Juetu}=*`p0|-)%&cQ zFV=Z_&`yC&9|gR_qr-A8C;Lf3%HLaX3zVPdhG|(+=wJfcW>TQD1PWO0I=svBVOi)v zwtxb|xKJ2*Wcu&rgsfXysubXzufr5~Oz@N3agp;8rh_@wLE2lu_LP7}m>!l$=eauy zx92*)mdo)2M>=1X)3E!WeaCnlf(>rq@!ibvbsT3nzJ=pG9N)w7!yG@w@$(#?;P`Eh z-{-iAZ^F;#cm>BBINr?hbsT3nzJ=pG9N)w7!yG@w@$(#?;CPb&>Bn8T6keD~vvs_Vj!FIF)(%mQpI>&{rFjGj`i=yThzQ2Kf7vA{Pa;Z#dgMzpQA1utXF6RSI?8%Z1}mV z)iUoRYN-;tRq>nm=u|lFsyS>pR|1=yiGO_T#;HMTIx)6u!15FwMStyJ|T;Ka=?ktY=Hly zrmxrYy})hqKd$McYJR}9cp35(p20`+Utw^)zXbLd#$yXeAn5%t;?wvL{rqKyUhg4+ zEk%}a^&Bz?`d$+8dd3eP*09p|zDUx~0*6#o9b0?2GDy{@TYR!Upb)Uezig_tO4cQ&%BXbf(tt7r{gh$ z>+>-rKh5~DD-EvCYLScsC;gme{m4Ftv~F83J(|8%ox0JCi{WOzZS>bL|DgRzXuRIO z(F*|ZDz3Au^sWHO*_^!C+oam7@p`-Wec(%>huEJDxjv6T@@d9ro;3JQ=5|!$obg1j zG5s8G&}5(a9^=Jl4Y59hMUu`qWvo4H)aAfqUVzhEHGPXZ_=*Aac@C0vzG>rgdjotw z@K)$29MBK__?(T;qZ)^P*uc=e9feJ`SP4;Vn7fg?H3c!K#S zc;9(0Hr6(IR%sma95Q^Eo$6^oe*@De9y0X$Oc}{L7%%?G;QCApNqV)#*6w3MKWFIm zSrd}id2lxY$N-!G{g_oQ;L1=jRiKTAw>3xrXrsD?qMC{fu`oy*`Tu z{kX=xEt>QlOkaG<!d1$QrSsP>{8^9l}*FJE`G&^FKo0EIT`pZI>}Ng zIjP<7CY5oWOiko+lc?g!X%9yqY0Wv*8JQ?o3OUFpZkF(Lf4Gre<=BqmgdYqoY zZpWd;P%b!d2~J^*o$eb3I|sIO0qq^U*6HbE(!TDi0c{`Xl1jb(+ctIfJKHvIzNTlp zv%Paue~$z8h$pplFqh61N|WA#LNT4kQbSvrQaaty(c8aeQD-I*@-w}!adVR8GPz4;;GgQ3&eOrF((~|S zR~QsHZZ{+@SJ2a(Q}g_0)!2l=IBJ#|sBokqN3VXhqo&uJQ)MdYY(R9!8O;^o*-aJ> zQ?xvuC!t4*leH$+w0q^Lml?(?pDKH4ND7*G;<#?p4_wDbw5`r*kK|f&mgy-oM)%0u zkk)o}gfJ<+g(O9~RDxv>AD$S`rdH#f5S<%Kmd8{) zHJL|E6IV*6gpWIY83$#hbT&y9I91G6R9xHXIFj+v0zJj zPbw;Jl^_p&N$EYgJ%d*PuRY}JVkza z{t!-@_FJXnTtWIR_1{5)DBA?!Sn3Z2aKqKqp(4u5-1U;~;P(4?{?PO5t@w!iVt;9U ii0t0_2Xm&Sby9%~rG25L^Bi0KmnRJ6yF%EY{(k@(PayLE literal 0 HcmV?d00001 diff --git a/modules/stb_vorbis/macos/stb_vorbis.a b/modules/stb_vorbis/macos/stb_vorbis.a new file mode 100644 index 0000000000000000000000000000000000000000..f25b68ad1d342378ebaa6ddf787c2bc3c04db201 GIT binary patch literal 189344 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