From 384cb34a214cc5467d2e31747b5f125082c436ff Mon Sep 17 00:00:00 2001 From: mikolaj Date: Wed, 4 Nov 2026 20:33:19 +0100 Subject: [PATCH 1/3] Support SF3 soundfonts and update TinySoundFont Vendor stb_vorbis v1.22 as its own translation unit and include its declarations ahead of tsf.h, which turns on TinySoundFont's existing SF3 (Ogg Vorbis compressed samples) path. Update tsf.h to upstream (2025): sustain pedal (MIDI CC 64) and tsf_channel_set_sustain, velocity 0 note-on as note-off, LIMITATTN unit fix, realloc and packing fixes. The README notes that SF3 samples are decoded at load time and that stb_vorbis should only be fed trusted files. Co-Authored-By: Claude Opus 5.5 --- README.md | 11 +- native/include/tsf/tsfCInterop.h | 4 +- native/src/stb_vorbis.c | 5584 ++++++++++++++++++++++++++++++ native/src/tsf.c | 7 +- native/src/tsf.h | 91 +- 5 files changed, 5664 insertions(+), 33 deletions(-) create mode 100644 native/src/stb_vorbis.c diff --git a/README.md b/README.md index ef3adfd..24dd787 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ [![GitHub License](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg?style=flat)](http://www.apache.org/licenses/LICENSE-2.0) Library for [sample-based synthesis](https://en.wikipedia.org/wiki/Sample-based_synthesis "Sample-based synthesis") to generate audio data. -The library allows to load `.sf2` files from memory. Is basically a KMP wrapper around [TinySoundFont](https://github.com/schellingb/TinySoundFont) library. +The library allows to load `.sf2` and `.sf3` files from memory. Is basically a KMP wrapper around [TinySoundFont](https://github.com/schellingb/TinySoundFont) library. The goal of this library is to allow operations on .sf2 files and generating audio in Kotlin Multiplatform projects. The library has `batteries-included` so no configuration is required. @@ -35,7 +35,7 @@ mikrosoundfont = { module = "io.github.lemcoder.mikrosoundfont:soundfont", versi ___ ### Usage ``` -val sfBuffer // .sf2 file bytes +val sfBuffer // .sf2 or .sf3 file bytes MikroSoundFont.load(sfBuffer).use { soundFont -> // .. use soundFont to generate audio data @@ -44,6 +44,13 @@ MikroSoundFont.load(sfBuffer).use { soundFont -> A `SoundFont` holds its samples in native memory until `close()` is called, so close it (or load it in `use { }`) when you are done with it. +#### SF3 files +`.sf3` files store their samples compressed with Ogg Vorbis. `load` decodes all of them up front, so: +* loading takes noticeably longer than an `.sf2` of the same size (seconds for a large font on a phone), so load off the main thread; +* the loaded `SoundFont` takes several times the file size in memory, as the samples are kept decoded. + +Decoding uses [stb_vorbis](https://github.com/nothings/stb), which is not hardened against malformed data, so only load `.sf3` files you trust. + ## License This project is licensed under the Apache 2.0 License - see the [LICENSE.md](LICENSE.md) file for details diff --git a/native/include/tsf/tsfCInterop.h b/native/include/tsf/tsfCInterop.h index afd9a12..acd572f 100644 --- a/native/include/tsf/tsfCInterop.h +++ b/native/include/tsf/tsfCInterop.h @@ -21,7 +21,7 @@ LICENSE (MIT) - Copyright (C) 2017-2023 Bernhard Schelling + Copyright (C) 2017-2025 Bernhard Schelling Based on SFZero, Copyright (C) 2012 Steve Folta (https://github.com/stevefolta/SFZero) Permission is hereby granted, free of charge, to any person obtaining a copy of this @@ -185,6 +185,7 @@ TSFDEF void tsf_render_float(tsf* f, float* buffer, int samples, int flag_mixing // pitch_wheel: pitch wheel position 0 to 16383 (default 8192 unpitched) // pitch_range: range of the pitch wheel in semitones (default 2.0, total +/- 2 semitones) // tuning: tuning of all playing voices in semitones (default 0.0, standard (A440) tuning) +// flag_sustain: 0 to end notes that were held sustained and disable holding sustain otherwise enable it // (tsf_set_preset_number and set_bank_preset return 0 if preset does not exist, otherwise 1) // (tsf_channel_set_... return 0 if a new channel needed allocation and that failed, otherwise 1) TSFDEF int tsf_channel_set_presetindex(tsf* f, int channel, int preset_index); @@ -196,6 +197,7 @@ TSFDEF int tsf_channel_set_volume(tsf* f, int channel, float volume); TSFDEF int tsf_channel_set_pitchwheel(tsf* f, int channel, int pitch_wheel); TSFDEF int tsf_channel_set_pitchrange(tsf* f, int channel, float pitch_range); TSFDEF int tsf_channel_set_tuning(tsf* f, int channel, float tuning); +TSFDEF int tsf_channel_set_sustain(tsf* f, int channel, int flag_sustain); // Start or stop playing notes on a channel (needs channel preset to be set) // channel: channel number diff --git a/native/src/stb_vorbis.c b/native/src/stb_vorbis.c new file mode 100644 index 0000000..3e5c250 --- /dev/null +++ b/native/src/stb_vorbis.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/native/src/tsf.c b/native/src/tsf.c index 72dd685..2d30277 100644 --- a/native/src/tsf.c +++ b/native/src/tsf.c @@ -1,4 +1,7 @@ +// stb_vorbis.c is compiled on its own; its declarations turn on TinySoundFont's +// SF3 (Ogg Vorbis compressed samples) support. +#define STB_VORBIS_HEADER_ONLY +#include "stb_vorbis.c" + #define TSF_IMPLEMENTATION #include "tsf.h" - -// stub \ No newline at end of file diff --git a/native/src/tsf.h b/native/src/tsf.h index 38e0c86..15d2ae5 100644 --- a/native/src/tsf.h +++ b/native/src/tsf.h @@ -21,7 +21,7 @@ LICENSE (MIT) - Copyright (C) 2017-2023 Bernhard Schelling + Copyright (C) 2017-2025 Bernhard Schelling Based on SFZero, Copyright (C) 2012 Steve Folta (https://github.com/stevefolta/SFZero) Permission is hereby granted, free of charge, to any person obtaining a copy of this @@ -76,14 +76,14 @@ TSFDEF tsf* tsf_load_memory(const void* buffer, int size); // Stream structure for the generic loading struct tsf_stream { - // Custom data given to the functions as the first parameter - void* data; + // Custom data given to the functions as the first parameter + void* data; - // Function pointer will be called to read 'size' bytes into ptr (returns number of read bytes) - int (*read)(void* data, void* ptr, unsigned int size); + // Function pointer will be called to read 'size' bytes into ptr (returns number of read bytes) + int (*read)(void* data, void* ptr, unsigned int size); - // Function pointer will be called to skip ahead over 'count' bytes (returns 1 on success, 0 on error) - int (*skip)(void* data, unsigned int count); + // Function pointer will be called to skip ahead over 'count' bytes (returns 1 on success, 0 on error) + int (*skip)(void* data, unsigned int count); }; // Generic SoundFont loading method using the stream structure above @@ -116,12 +116,12 @@ TSFDEF const char* tsf_bank_get_presetname(const tsf* f, int bank, int preset_nu // Supported output modes by the render methods enum TSFOutputMode { - // Two channels with single left/right samples one after another - TSF_STEREO_INTERLEAVED, - // Two channels with all samples for the left channel first then right - TSF_STEREO_UNWEAVED, - // A single channel (stereo instruments are mixed into center) - TSF_MONO + // Two channels with single left/right samples one after another + TSF_STEREO_INTERLEAVED, + // Two channels with all samples for the left channel first then right + TSF_STEREO_UNWEAVED, + // A single channel (stereo instruments are mixed into center) + TSF_MONO }; // Thread safety: @@ -206,6 +206,7 @@ TSFDEF void tsf_render_float(tsf* f, float* buffer, int samples, int flag_mixing // pitch_wheel: pitch wheel position 0 to 16383 (default 8192 unpitched) // pitch_range: range of the pitch wheel in semitones (default 2.0, total +/- 2 semitones) // tuning: tuning of all playing voices in semitones (default 0.0, standard (A440) tuning) +// flag_sustain: 0 to end notes that were held sustained and disable holding sustain otherwise enable it // (tsf_set_preset_number and set_bank_preset return 0 if preset does not exist, otherwise 1) // (tsf_channel_set_... return 0 if a new channel needed allocation and that failed, otherwise 1) TSFDEF int tsf_channel_set_presetindex(tsf* f, int channel, int preset_index); @@ -217,6 +218,7 @@ TSFDEF int tsf_channel_set_volume(tsf* f, int channel, float volume); TSFDEF int tsf_channel_set_pitchwheel(tsf* f, int channel, int pitch_wheel); TSFDEF int tsf_channel_set_pitchrange(tsf* f, int channel, float pitch_range); TSFDEF int tsf_channel_set_tuning(tsf* f, int channel, float tuning); +TSFDEF int tsf_channel_set_sustain(tsf* f, int channel, int flag_sustain); // Start or stop playing notes on a channel (needs channel preset to be set) // channel: channel number @@ -307,7 +309,7 @@ TSFDEF float tsf_channel_get_tuning(tsf* f, int channel); #define TSF_TRUE 1 #define TSF_FALSE 0 -#define TSF_BOOL char +#define TSF_BOOL unsigned char #define TSF_PI 3.14159265358979323846264338327950288 #define TSF_NULL 0 @@ -417,7 +419,7 @@ static void tsf_hydra_read_shdr(struct tsf_hydra_shdr* i, struct tsf_stream* str struct tsf_riffchunk { tsf_fourcc id; tsf_u32 size; }; struct tsf_envelope { float delay, attack, hold, decay, sustain, release, keynumToHold, keynumToDecay; }; -struct tsf_voice_envelope { float level, slope; int samplesUntilNextSegment; short segment, midiVelocity; struct tsf_envelope parameters; TSF_BOOL segmentIsExponential, isAmpEnv; }; +struct tsf_voice_envelope { unsigned char segment, segmentIsExponential : 1, isAmpEnv : 1; short midiVelocity; float level, slope; int samplesUntilNextSegment; struct tsf_envelope parameters; }; struct tsf_voice_lowpass { double QInv, a0, a1, b1, b2, z1, z2; TSF_BOOL active; }; struct tsf_voice_lfo { int samplesUntil; float level, delta; }; @@ -448,7 +450,7 @@ struct tsf_preset struct tsf_voice { - int playingPreset, playingKey, playingChannel; + int playingPreset, playingKey, playingChannel, heldSustain; struct tsf_region* region; double pitchInputTimecents, pitchOutputFactor; double sourceSamplePosition; @@ -461,7 +463,7 @@ struct tsf_voice struct tsf_channel { - unsigned short presetIndex, bank, pitchWheel, midiPan, midiVolume, midiExpression, midiRPN, midiData; + unsigned short presetIndex, bank, pitchWheel, midiPan, midiVolume, midiExpression, midiRPN, midiData : 14, sustain : 1; float panOffset, gainDB, pitchRange, tuning; }; @@ -647,7 +649,7 @@ static void tsf_region_operator(struct tsf_region* region, tsf_u16 genOper, unio case GEN_FLOAT_LIMIT12K8K: vfactor = 1.0f; vmin = -12000.0f; vmax = 8000.0f; break; case GEN_FLOAT_LIMIT1200: vfactor = 1.0f; vmin = -1200.0f; vmax = 1200.0f; break; case GEN_FLOAT_LIMITPAN: vfactor = 0.001f; vmin = -0.5f; vmax = 0.5f; break; - case GEN_FLOAT_LIMITATTN: vfactor = 0.1f; vmin = 0.0f; vmax = 144.0f; break; + case GEN_FLOAT_LIMITATTN: vfactor = 0.01f; vmin = 0.0f; vmax = 14.4f; break; case GEN_FLOAT_MAX1000: vfactor = 1.0f; vmin = 0.0f; vmax = 1000.0f; break; case GEN_FLOAT_MAX1440: vfactor = 1.0f; vmin = 0.0f; vmax = 1440.0f; break; default: continue; @@ -894,7 +896,8 @@ static int tsf_decode_ogg(const tsf_u8 *pSmpl, const tsf_u8 *pSmplEnd, float** p if (resNum > resMax) { do { resMax += (resMax ? (resMax < 1048576 ? resMax : 1048576) : resInitial); } while (resNum > resMax); - res = (float*)TSF_REALLOC((oldres = res), resMax * sizeof(float)); + oldres = res; + res = (float*)TSF_REALLOC(res, resMax * sizeof(float)); if (!res) { TSF_FREE(oldres); stb_vorbis_close(v); return 0; } } TSF_MEMCPY(res + resNum - n_samples, outputs[0], n_samples * sizeof(float)); @@ -951,7 +954,8 @@ static int tsf_decode_sf3_samples(const void* rawBuffer, float** pFloatBuffer, u if (resNum > resMax) { do { resMax += (resMax ? (resMax < 1048576 ? resMax : 1048576) : resInitial); } while (resNum > resMax); - res = (float*)TSF_REALLOC((oldres = res), resMax * sizeof(float)); + oldres = res; + res = (float*)TSF_REALLOC(res, resMax * sizeof(float)); if (!res) { TSF_FREE(oldres); return 0; } } @@ -981,12 +985,14 @@ static int tsf_load_samples(void** pRawBuffer, float** pFloatBuffer, unsigned in // Decode custom .sfo 'smpo' format where all samples are in a single ogg stream resNum = resMax = 0; if (!tsf_decode_ogg((tsf_u8*)*pRawBuffer, (tsf_u8*)*pRawBuffer + chunkSmpl->size, pFloatBuffer, &resNum, &resMax, 65536)) return 0; - if (!(*pFloatBuffer = (float*)TSF_REALLOC((oldres = *pFloatBuffer), resNum * sizeof(float)))) *pFloatBuffer = oldres; + oldres = *pFloatBuffer; + if (!(*pFloatBuffer = (float*)TSF_REALLOC(*pFloatBuffer, resNum * sizeof(float)))) *pFloatBuffer = oldres; *pSmplCount = resNum; return (*pFloatBuffer ? 1 : 0); #else // Inline convert the samples from short to float float *res, *out; const short *in; + (void)pRawBuffer; *pSmplCount = chunkSmpl->size / (unsigned int)sizeof(short); *pFloatBuffer = (float*)TSF_MALLOC(*pSmplCount * sizeof(float)); if (!*pFloatBuffer || !stream->read(stream->data, *pFloatBuffer, chunkSmpl->size)) return 0; @@ -1547,7 +1553,7 @@ TSFDEF int tsf_set_max_voices(tsf* f, int max_voices) TSFDEF int tsf_note_on(tsf* f, int preset_index, int key, float vel) { short midiVelocity = (short)(vel * 127); - int voicePlayIndex; + unsigned int voicePlayIndex; struct tsf_region *region, *regionEnd; if (preset_index < 0 || preset_index >= f->presetNum) return 1; @@ -1609,6 +1615,7 @@ TSFDEF int tsf_note_on(tsf* f, int preset_index, int key, float vel) voice->playingPreset = preset_index; voice->playingKey = key; voice->playIndex = voicePlayIndex; + voice->heldSustain = 0; voice->noteGainDB = f->globalGainDB - region->attenuation - tsf_gainToDecibels(1.0f / vel); if (f->channels) @@ -1776,7 +1783,7 @@ static struct tsf_channel* tsf_channel_init(tsf* f, int channel) c->pitchWheel = c->midiPan = 8192; c->midiVolume = c->midiExpression = 16383; c->midiRPN = 0xFFFF; - c->midiData = 0; + c->midiData = c->sustain = 0; c->panOffset = 0.0f; c->gainDB = 0.0f; c->pitchRange = 2.0f; @@ -1850,7 +1857,7 @@ TSFDEF int tsf_channel_set_pan(tsf* f, int channel, float pan) struct tsf_channel *c = tsf_channel_init(f, channel); if (!c) return 0; for (v = f->voices, vEnd = v + f->voiceNum; v != vEnd; v++) - if (v->playingChannel == channel && v->playingPreset != -1) + if (v->playingPreset != -1 && v->playingChannel == channel) { float newpan = v->region->pan + pan - 0.5f; if (newpan <= -0.5f) { v->panFactorLeft = 1.0f; v->panFactorRight = 0.0f; } @@ -1905,35 +1912,62 @@ TSFDEF int tsf_channel_set_tuning(tsf* f, int channel, float tuning) return 1; } +TSFDEF int tsf_channel_set_sustain(tsf* f, int channel, int flag_sustain) +{ + struct tsf_channel *c = tsf_channel_init(f, channel); + if (!c) return 0; + if (!c->sustain == !flag_sustain) return 1; + c->sustain = (unsigned short)(flag_sustain != 0); + //Turning on sustain does no action now, just starts note_off behaving differently + if (flag_sustain) return 1; + //Turning off sustain, actually end voices that got a note_off and were set to heldSustain status + struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum; + for (; v != vEnd; v++) + if (v->playingPreset != -1 && v->playingChannel == channel && v->ampenv.segment < TSF_SEGMENT_RELEASE && v->heldSustain) + tsf_voice_end(f, v); + return 1; +} + TSFDEF int tsf_channel_note_on(tsf* f, int channel, int key, float vel) { if (!f->channels || channel >= f->channels->channelNum) return 1; f->channels->activeChannel = channel; + if (!vel) + { + tsf_channel_note_off(f, channel, key); + return 1; + } return tsf_note_on(f, f->channels->channels[channel].presetIndex, key, vel); } TSFDEF void tsf_channel_note_off(tsf* f, int channel, int key) { + unsigned sustain; struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum, *vMatchFirst = TSF_NULL, *vMatchLast = TSF_NULL; for (; v != vEnd; v++) { //Find the first and last entry in the voices list with matching channel, key and look up the smallest play index - if (v->playingPreset == -1 || v->playingChannel != channel || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE) continue; + if (v->playingPreset == -1 || v->playingChannel != channel || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE || v->heldSustain) continue; else if (!vMatchFirst || v->playIndex < vMatchFirst->playIndex) vMatchFirst = vMatchLast = v; else if (v->playIndex == vMatchFirst->playIndex) vMatchLast = v; } if (!vMatchFirst) return; - for (v = vMatchFirst; v <= vMatchLast; v++) + for (sustain = f->channels->channels[channel].sustain, v = vMatchFirst; v <= vMatchLast; v++) { //Stop all voices with matching channel, key and the smallest play index which was enumerated above if (v != vMatchFirst && v != vMatchLast && (v->playIndex != vMatchFirst->playIndex || v->playingPreset == -1 || v->playingChannel != channel || v->playingKey != key || v->ampenv.segment >= TSF_SEGMENT_RELEASE)) continue; - tsf_voice_end(f, v); + //Don't turn off if sustain is active, just mark as held by sustain so we don't forget it + if (sustain) + v->heldSustain = 1; + else + tsf_voice_end(f, v); } } TSFDEF void tsf_channel_note_off_all(tsf* f, int channel) { + //Ignore sustain channel settings, note_off_all overrides struct tsf_voice *v = f->voices, *vEnd = v + f->voiceNum; for (; v != vEnd; v++) if (v->playingPreset != -1 && v->playingChannel == channel && v->ampenv.segment < TSF_SEGMENT_RELEASE) @@ -1968,6 +2002,7 @@ TSFDEF int tsf_channel_midi_control(tsf* f, int channel, int controller, int con case 100 /*RPN_LSB*/ : c->midiRPN = (unsigned short)(((c->midiRPN == 0xFFFF ? 0 : c->midiRPN) & 0x3F80) | control_value); return 1; case 98 /*NRPN_LSB*/ : c->midiRPN = 0xFFFF; return 1; case 99 /*NRPN_MSB*/ : c->midiRPN = 0xFFFF; return 1; + case 64 /*SUSTAIN*/ : tsf_channel_set_sustain(f, channel, (int)(control_value >= 64)); return 1; case 120 /*ALL_SOUND_OFF*/ : tsf_channel_sounds_off_all(f, channel); return 1; case 123 /*ALL_NOTES_OFF*/ : tsf_channel_note_off_all(f, channel); return 1; case 121 /*ALL_CTRL_OFF*/ : @@ -2041,4 +2076,4 @@ TSFDEF float tsf_channel_get_tuning(tsf* f, int channel) } #endif -#endif //TSF_IMPLEMENTATION \ No newline at end of file +#endif //TSF_IMPLEMENTATION From fa93d8b949e9762a42efb4f92843390b4713d7d9 Mon Sep 17 00:00:00 2001 From: mikolaj Date: Wed, 4 Nov 2026 20:33:19 +0100 Subject: [PATCH 2/3] Add Channel.setSustain Exposes TinySoundFont's tsf_channel_set_sustain: while held, noteOff keeps notes sounding until the pedal is released. Co-Authored-By: Claude Opus 5.5 --- .../mikrosoundfont/internal/ChannelDelegate.android.kt | 5 +++++ .../kotlin/io/github/lemcoder/mikrosoundfont/Channel.kt | 6 ++++++ .../mikrosoundfont/internal/ChannelDelegate.native.kt | 7 +++++++ 3 files changed, 18 insertions(+) diff --git a/soundfont/src/androidMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.android.kt b/soundfont/src/androidMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.android.kt index 922a4d7..895baea 100644 --- a/soundfont/src/androidMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.android.kt +++ b/soundfont/src/androidMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.android.kt @@ -22,6 +22,7 @@ import tinySoundFont.tsf_channel_set_pitchrange import tinySoundFont.tsf_channel_set_pitchwheel import tinySoundFont.tsf_channel_set_presetindex import tinySoundFont.tsf_channel_set_presetnumber +import tinySoundFont.tsf_channel_set_sustain import tinySoundFont.tsf_channel_set_tuning import tinySoundFont.tsf_channel_set_volume import tinySoundFont.tsf_channel_sounds_off_all @@ -74,6 +75,10 @@ internal class ChannelDelegate( tsf_channel_set_tuning(soundFont, number, tuning) } + override fun setSustain(isSustained: Boolean) { + tsf_channel_set_sustain(soundFont, number, if (isSustained) 1 else 0) + } + override fun noteOn(key: Int, velocity: Float) { tsf_channel_note_on(soundFont, number, key, velocity) } diff --git a/soundfont/src/commonMain/kotlin/io/github/lemcoder/mikrosoundfont/Channel.kt b/soundfont/src/commonMain/kotlin/io/github/lemcoder/mikrosoundfont/Channel.kt index 3c1aa4c..fc9d41f 100644 --- a/soundfont/src/commonMain/kotlin/io/github/lemcoder/mikrosoundfont/Channel.kt +++ b/soundfont/src/commonMain/kotlin/io/github/lemcoder/mikrosoundfont/Channel.kt @@ -55,6 +55,12 @@ interface Channel { */ fun setTuning(tuning: Float) + /** + * Hold or release the sustain pedal (MIDI CC 64). While held, [noteOff] keeps notes sounding; + * releasing it ends the notes that were held. + */ + fun setSustain(isSustained: Boolean) + /** * Start playing a note diff --git a/soundfont/src/nativeMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.native.kt b/soundfont/src/nativeMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.native.kt index dd85185..5d769ee 100644 --- a/soundfont/src/nativeMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.native.kt +++ b/soundfont/src/nativeMain/kotlin/io/github/lemcoder/mikrosoundfont/internal/ChannelDelegate.native.kt @@ -25,6 +25,7 @@ import tinySoundFont.tsf_channel_set_pitchwheel import tinySoundFont.tsf_channel_set_presetindex import tinySoundFont.tsf_channel_set_presetnumber import tinySoundFont.tsf_channel_set_tuning +import tinySoundFont.tsf_channel_set_sustain import tinySoundFont.tsf_channel_set_volume import tinySoundFont.tsf_channel_sounds_off_all @@ -98,6 +99,12 @@ internal class ChannelDelegate( } } + override fun setSustain(isSustained: Boolean) { + withSoundFont { + tsf_channel_set_sustain(it.reinterpret(), number, if (isSustained) 1 else 0) + } + } + override fun noteOn(key: Int, velocity: Float) { withSoundFont { tsf_channel_note_on(it.reinterpret(), number, key, velocity) From bc00a56afa0f7b95182f56a42a9f5e3c6250d085 Mon Sep 17 00:00:00 2001 From: mikolaj Date: Wed, 4 Nov 2026 20:52:06 +0100 Subject: [PATCH 3/3] Add shared tests and a Linux CI job commonTest loads an SF2 fixture (TinySoundFont's florestan-subset) and an SF3 made from it by scripts/make-test-sf3.py, then checks presets, rendering, stereo panning, the sustain pedal, close() and rejection of non-SoundFont data. They run natively on the host (linuxX64Test, macosArm64Test; the fixtures path comes from an environment variable) and on a device via connectedAndroidDeviceTest. The Test workflow runs linuxX64Test on pull requests and pushes to master, which exercises the same native code without an Android emulator. gradlew is now executable in git. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/test.yaml | 45 +++++++++ README.md | 6 ++ gradle/libs.versions.toml | 1 + gradlew | 0 scripts/make-test-sf3.py | 68 +++++++++++++ soundfont/build.gradle.kts | 17 ++++ .../mikrosoundfont/TestResources.android.kt | 5 + .../lemcoder/mikrosoundfont/SoundFontTest.kt | 89 ++++++++++++++++++ .../lemcoder/mikrosoundfont/TestResources.kt | 4 + .../commonTest/resources/florestan-subset.sf2 | Bin 0 -> 531786 bytes .../commonTest/resources/florestan-subset.sf3 | Bin 0 -> 276228 bytes .../mikrosoundfont/TestResources.native.kt | 35 +++++++ 12 files changed, 270 insertions(+) create mode 100644 .github/workflows/test.yaml mode change 100644 => 100755 gradlew create mode 100644 scripts/make-test-sf3.py create mode 100644 soundfont/src/androidDeviceTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.android.kt create mode 100644 soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/SoundFontTest.kt create mode 100644 soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.kt create mode 100644 soundfont/src/commonTest/resources/florestan-subset.sf2 create mode 100644 soundfont/src/commonTest/resources/florestan-subset.sf3 create mode 100644 soundfont/src/nativeTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.native.kt diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml new file mode 100644 index 0000000..b8f5608 --- /dev/null +++ b/.github/workflows/test.yaml @@ -0,0 +1,45 @@ +name: Test +on: + pull_request: + push: + branches: [master] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + linux: + name: Linux tests + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Setup Java + uses: actions/setup-java@v4 + with: + distribution: 'zulu' + java-version: '17' + + - name: Setup Gradle + uses: gradle/actions/setup-gradle@v4 + + - name: Cache Kotlin/Native toolchain + uses: actions/cache@v4 + with: + path: ~/.konan + key: konan-${{ runner.os }}-${{ hashFiles('gradle/libs.versions.toml') }} + + # The shared tests (src/commonTest) built for linuxX64 and run natively: same TinySoundFont + # and stb_vorbis code as every other target, without an Android emulator. + - name: Run tests + run: ./gradlew :soundfont:linuxX64Test + + - name: Upload test reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: test-reports + path: soundfont/build/reports/tests/ diff --git a/README.md b/README.md index 24dd787..962b9b7 100644 --- a/README.md +++ b/README.md @@ -51,6 +51,12 @@ A `SoundFont` holds its samples in native memory until `close()` is called, so c Decoding uses [stb_vorbis](https://github.com/nothings/stb), which is not hardened against malformed data, so only load `.sf3` files you trust. +## Testing + +The tests in `soundfont/src/commonTest` load an `.sf2` and an `.sf3` font and render audio through the native library: +* `./gradlew :soundfont:linuxX64Test` or `:soundfont:macosArm64Test` runs them on the host (CI runs the Linux ones on every pull request); +* `./gradlew :soundfont:connectedAndroidDeviceTest` runs them on a connected Android device or emulator. + ## License This project is licensed under the Apache 2.0 License - see the [LICENSE.md](LICENSE.md) file for details diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index d5bc870..daa96c6 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -10,6 +10,7 @@ maven-publish = "0.37.0" konanplugin = "2.0.0-alpha05" [libraries] +androidx-test-runner = { module = "androidx.test:runner", version = "1.6.2" } kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" } [plugins] diff --git a/gradlew b/gradlew old mode 100644 new mode 100755 diff --git a/scripts/make-test-sf3.py b/scripts/make-test-sf3.py new file mode 100644 index 0000000..eb0fef7 --- /dev/null +++ b/scripts/make-test-sf3.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +"""Turns an .sf2 into an .sf3 by compressing every sample to Ogg Vorbis. + +Used to make the SF3 test fixture (needs `pip install soundfile numpy`): + python3 scripts/make-test-sf3.py in.sf2 out.sf3 + +SF3 layout (as read by TinySoundFont and MuseScore): each sample is a standalone Ogg Vorbis +stream in the smpl chunk, its shdr start/end are byte offsets of that stream, its loop points +are sample frames relative to the sample's start, and sampleType has the 0x10 (Vorbis) flag. +""" +import io +import struct +import sys + +import numpy +import soundfile + +SHDR = struct.Struct("<20sIIIIIBbHH") + + +def chunks(data): + pos = 0 + while pos + 8 <= len(data): + cid, size = struct.unpack_from("<4sI", data, pos) + yield cid, data[pos + 8:pos + 8 + size] + pos += 8 + size + (size & 1) + + +def chunk(cid, body): + return struct.pack("<4sI", cid, len(body)) + body + (b"\0" if len(body) & 1 else b"") + + +def list_chunk(kind, body): + return chunk(b"LIST", kind + body) + + +def encode(pcm, rate): + ogg = io.BytesIO() + soundfile.write(ogg, numpy.frombuffer(pcm, "().configureEach { + environment("MIKROSOUNDFONT_TEST_RESOURCES", file("src/commonTest/resources").absolutePath) +} + // Publishing publishing { diff --git a/soundfont/src/androidDeviceTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.android.kt b/soundfont/src/androidDeviceTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.android.kt new file mode 100644 index 0000000..4090ca3 --- /dev/null +++ b/soundfont/src/androidDeviceTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.android.kt @@ -0,0 +1,5 @@ +package io.github.lemcoder.mikrosoundfont + +actual fun readTestResource(name: String): ByteArray = + object {}.javaClass.classLoader!!.getResourceAsStream(name)?.use { it.readBytes() } + ?: error("Missing test resource $name") diff --git a/soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/SoundFontTest.kt b/soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/SoundFontTest.kt new file mode 100644 index 0000000..26643d7 --- /dev/null +++ b/soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/SoundFontTest.kt @@ -0,0 +1,89 @@ +package io.github.lemcoder.mikrosoundfont + +import kotlin.math.abs +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertTrue + +/** + * Runs every test against the SF2 fixture and its SF3 (Ogg Vorbis) conversion. + * + * `florestan-subset.sf2` is TinySoundFont's example font (examples/ in its repository); + * `florestan-subset.sf3` is made from it with `scripts/make-test-sf3.py`. + */ +abstract class SoundFontTest(private val fixture: String) { + private val sampleRate = 44100 + + private fun load(): SoundFont = MikroSoundFont.load(readTestResource(fixture)).apply { + setOutput(SoundFont.OutputMode.STEREO_INTERLEAVED, sampleRate, 0f) + } + + private fun FloatArray.peak(): Float = maxOf { abs(it) } + + @Test + fun readsPresets() = load().use { soundFont -> + assertEquals(17, soundFont.getPresetsCount()) + assertEquals("Piano", soundFont.getPresetName(0)) + assertEquals(soundFont.getPresetsCount() + 1, soundFont.channels.size) + } + + @Test + fun rendersANote() = load().use { soundFont -> + assertEquals(0f, soundFont.renderFloat(1024, 2, false).peak(), "silence before any note") + soundFont.noteOn(presetIndex = 0, key = 60, velocity = 1f) + assertEquals(1, soundFont.activeVoiceCount()) + val audio = soundFont.renderFloat(sampleRate / 10, 2, false) + assertEquals(sampleRate / 10 * 2, audio.size) + assertTrue(audio.peak() > 0.05f, "peak ${audio.peak()}") + } + + @Test + fun stereoOutputHonoursPan() = load().use { soundFont -> + val channel = soundFont.channels[0] + channel.setPresetIndex(0) + channel.setPan(0f) + channel.noteOn(key = 60, velocity = 1f) + val audio = soundFont.renderFloat(sampleRate / 10, 2, false) + val left = audio.filterIndexed { i, _ -> i % 2 == 0 }.maxOf { abs(it) } + val right = audio.filterIndexed { i, _ -> i % 2 == 1 }.maxOf { abs(it) } + assertTrue(left > 0.05f && right < left / 10, "left $left, right $right") + } + + @Test + fun sustainHoldsReleasedNotes() = load().use { soundFont -> + val channel = soundFont.channels[0] + channel.setPresetIndex(0) + channel.setSustain(true) + channel.noteOn(key = 60, velocity = 1f) + channel.noteOff(key = 60) + soundFont.renderFloat(sampleRate * 2, 2, false) + assertEquals(1, soundFont.activeVoiceCount(), "held by the pedal") + + channel.setSustain(false) + soundFont.renderFloat(sampleRate * 2, 2, false) + assertEquals(0, soundFont.activeVoiceCount(), "released with the pedal") + } + + @Test + fun closedSoundFontRejectsCalls() { + val soundFont = load() + val channel = soundFont.channels[0] + soundFont.close() + soundFont.close() // closing twice is harmless + assertFailsWith { soundFont.getPresetsCount() } + assertFailsWith { soundFont.renderFloat(16, 2, false) } + assertFailsWith { channel.noteOn(key = 60, velocity = 1f) } + } +} + +class Sf2Test : SoundFontTest("florestan-subset.sf2") + +class Sf3Test : SoundFontTest("florestan-subset.sf3") + +class LoadTest { + @Test + fun rejectsNonSoundFontData() { + assertFailsWith { MikroSoundFont.load(ByteArray(64) { it.toByte() }) } + } +} diff --git a/soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.kt b/soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.kt new file mode 100644 index 0000000..7c6a88d --- /dev/null +++ b/soundfont/src/commonTest/kotlin/io/github/lemcoder/mikrosoundfont/TestResources.kt @@ -0,0 +1,4 @@ +package io.github.lemcoder.mikrosoundfont + +/** Reads a file from `src/commonTest/resources`. */ +expect fun readTestResource(name: String): ByteArray diff --git a/soundfont/src/commonTest/resources/florestan-subset.sf2 b/soundfont/src/commonTest/resources/florestan-subset.sf2 new file mode 100644 index 0000000000000000000000000000000000000000..56a930aca967777ede5084d7fe117493d57c2237 GIT binary patch literal 531786 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
  • 7)t_yAs2PmR@XzdF$@voT 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

    Z%vqwk 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 z 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⋘4Hxd&|hK9M^R|>;hkNLtw#u9*ui%G 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 literal 0 HcmV?d00001 diff --git a/soundfont/src/commonTest/resources/florestan-subset.sf3 b/soundfont/src/commonTest/resources/florestan-subset.sf3 new file mode 100644 index 0000000000000000000000000000000000000000..e37e3cafc5a285f725677eea315ecfd049b274ba GIT binary patch literal 276228 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