|
|
|
|
@ -1,8 +1,11 @@ |
|
|
|
|
// Ogg Vorbis audio decoder - v1.06 - public domain
|
|
|
|
|
// Ogg Vorbis audio decoder - v1.07 - public domain
|
|
|
|
|
// http://nothings.org/stb_vorbis/
|
|
|
|
|
//
|
|
|
|
|
// Written by Sean Barrett in 2007, last updated in 2014
|
|
|
|
|
// Sponsored by RAD Game Tools.
|
|
|
|
|
// Original version written by Sean Barrett in 2007.
|
|
|
|
|
//
|
|
|
|
|
// Originally sponsored by RAD Game Tools. Seeking sponsored
|
|
|
|
|
// by Phillip Bennefall, Marc Andersen, Aaron Baker, Elias Software,
|
|
|
|
|
// Aras Pranckevicius, and Sean Barrett.
|
|
|
|
|
//
|
|
|
|
|
// LICENSE
|
|
|
|
|
//
|
|
|
|
|
@ -30,11 +33,10 @@ |
|
|
|
|
// Laurent Gomila Marc LeBlanc Ronny Chevalier
|
|
|
|
|
// Bernhard Wodo Evan Balster "alxprd"@github
|
|
|
|
|
// Tom Beaumont Ingo Leitgeb Nicolas Guillemot
|
|
|
|
|
// (If you reported a bug but do not appear in this list, it is because
|
|
|
|
|
// someone else reported the bug before you. There were too many of you to
|
|
|
|
|
// list them all because I was lax about updating for a long time, sorry.)
|
|
|
|
|
// Phillip Bennefall Rohit
|
|
|
|
|
//
|
|
|
|
|
// Partial history:
|
|
|
|
|
// 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
|
|
|
|
|
@ -45,8 +47,6 @@ |
|
|
|
|
// 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
|
|
|
|
|
// 0.99996 - - bracket #include <malloc.h> for macintosh compilation
|
|
|
|
|
// 0.99995 - - avoid alias-optimization issue in float-to-int conversion
|
|
|
|
|
//
|
|
|
|
|
// See end of file for full version history.
|
|
|
|
|
|
|
|
|
|
@ -155,10 +155,10 @@ extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f); |
|
|
|
|
// specification does not bound the size of an individual frame.
|
|
|
|
|
|
|
|
|
|
extern stb_vorbis *stb_vorbis_open_pushdata( |
|
|
|
|
unsigned char *datablock, int datablock_length_in_bytes, |
|
|
|
|
const unsigned char * datablock, int datablock_length_in_bytes, |
|
|
|
|
int *datablock_memory_consumed_in_bytes, |
|
|
|
|
int *error, |
|
|
|
|
stb_vorbis_alloc *alloc_buffer); |
|
|
|
|
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)
|
|
|
|
|
@ -169,7 +169,8 @@ extern stb_vorbis *stb_vorbis_open_pushdata( |
|
|
|
|
// 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, unsigned char *datablock, int datablock_length_in_bytes, |
|
|
|
|
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
|
|
|
|
|
@ -233,18 +234,18 @@ extern int stb_vorbis_decode_memory(const unsigned char *mem, int len, int *chan |
|
|
|
|
// 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, stb_vorbis_alloc *alloc_buffer); |
|
|
|
|
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, stb_vorbis_alloc *alloc_buffer); |
|
|
|
|
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, stb_vorbis_alloc *alloc_buffer); |
|
|
|
|
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
|
|
|
|
|
@ -254,7 +255,7 @@ extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close, |
|
|
|
|
// 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, stb_vorbis_alloc *alloc_buffer, unsigned int len); |
|
|
|
|
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"
|
|
|
|
|
@ -292,15 +293,17 @@ extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***out |
|
|
|
|
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. the
|
|
|
|
|
// data is coerced to the number of channels you request according to the
|
|
|
|
|
// 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. 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.
|
|
|
|
|
// per channel.
|
|
|
|
|
|
|
|
|
|
// Channel coercion rules:
|
|
|
|
|
// Let M be the number of channels requested, and N the number of channels present,
|
|
|
|
|
@ -367,7 +370,7 @@ enum STBVorbisError |
|
|
|
|
VORBIS_invalid_first_page, |
|
|
|
|
VORBIS_bad_packet_type, |
|
|
|
|
VORBIS_cant_find_last_page, |
|
|
|
|
VORBIS_seek_failed, |
|
|
|
|
VORBIS_seek_failed |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -488,14 +491,8 @@ enum STBVorbisError |
|
|
|
|
// trade off storage for speed.
|
|
|
|
|
//#define STB_VORBIS_DIVIDES_IN_CODEBOOK
|
|
|
|
|
|
|
|
|
|
// STB_VORBIS_CODEBOOK_SHORTS
|
|
|
|
|
// The vorbis file format encodes VQ codebook floats as ax+b where a and
|
|
|
|
|
// b are floating point per-codebook constants, and x is a 16-bit int.
|
|
|
|
|
// Normally, stb_vorbis decodes them to floats rather than leaving them
|
|
|
|
|
// as 16-bit ints and computing ax+b while decoding. This is a speed/space
|
|
|
|
|
// tradeoff; you can save space by defining this flag.
|
|
|
|
|
#ifndef STB_VORBIS_CODEBOOK_SHORTS |
|
|
|
|
#define STB_VORBIS_CODEBOOK_FLOATS |
|
|
|
|
#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
|
|
|
|
|
@ -556,11 +553,26 @@ enum STBVorbisError |
|
|
|
|
#if !(defined(__APPLE__) || defined(MACOSX) || defined(macintosh) || defined(Macintosh)) |
|
|
|
|
#include <malloc.h> |
|
|
|
|
#endif |
|
|
|
|
#else |
|
|
|
|
#else // STB_VORBIS_NO_CRT
|
|
|
|
|
#define NULL 0 |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#if !defined(_MSC_VER) && !(defined(__MINGW32__) && defined(__forceinline)) |
|
|
|
|
#define malloc(s) 0 |
|
|
|
|
#define free(s) ((void) 0) |
|
|
|
|
#define realloc(s) 0 |
|
|
|
|
#endif // STB_VORBIS_NO_CRT
|
|
|
|
|
|
|
|
|
|
#include <limits.h> |
|
|
|
|
|
|
|
|
|
#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 |
|
|
|
|
#elif !defined(_MSC_VER) |
|
|
|
|
#if __GNUC__ |
|
|
|
|
#define __forceinline inline |
|
|
|
|
#else |
|
|
|
|
@ -577,6 +589,13 @@ enum STBVorbisError |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if 0 |
|
|
|
|
#include <crtdbg.h> |
|
|
|
|
#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) |
|
|
|
|
|
|
|
|
|
@ -593,11 +612,7 @@ typedef signed int int32; |
|
|
|
|
#define FALSE 0 |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#ifdef STB_VORBIS_CODEBOOK_FLOATS |
|
|
|
|
typedef float codetype; |
|
|
|
|
#else |
|
|
|
|
typedef uint16 codetype; |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
// @NOTE
|
|
|
|
|
//
|
|
|
|
|
@ -831,13 +846,6 @@ struct stb_vorbis |
|
|
|
|
int channel_buffer_end; |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
extern int my_prof(int slot); |
|
|
|
|
//#define stb_prof my_prof
|
|
|
|
|
|
|
|
|
|
#ifndef stb_prof |
|
|
|
|
#define stb_prof(x) ((void) 0) |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#if defined(STB_VORBIS_NO_PUSHDATA_API) |
|
|
|
|
#define IS_PUSH_MODE(f) FALSE |
|
|
|
|
#elif defined(STB_VORBIS_NO_PULLDATA_API) |
|
|
|
|
@ -904,7 +912,7 @@ static void *setup_malloc(vorb *f, int sz) |
|
|
|
|
|
|
|
|
|
static void setup_free(vorb *f, void *p) |
|
|
|
|
{ |
|
|
|
|
if (f->alloc.alloc_buffer) return; // do nothing; setup mem is not a stack
|
|
|
|
|
if (f->alloc.alloc_buffer) return; // do nothing; setup mem is a stack
|
|
|
|
|
free(p); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -1055,10 +1063,12 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values) |
|
|
|
|
while (z > 0 && !available[z]) --z; |
|
|
|
|
if (z == 0) { return FALSE; } |
|
|
|
|
res = available[z]; |
|
|
|
|
assert(z >= 0 && z < 32); |
|
|
|
|
available[z] = 0; |
|
|
|
|
add_entry(c, bit_reverse(res), i, m++, len[i], values); |
|
|
|
|
// propogate availability up the tree
|
|
|
|
|
if (z != len[i]) { |
|
|
|
|
assert(len[i] >= 0 && len[i] < 32); |
|
|
|
|
for (y=len[i]; y > z; --y) { |
|
|
|
|
assert(available[y] == 0); |
|
|
|
|
available[y] = res + (1 << (32-y)); |
|
|
|
|
@ -1576,7 +1586,7 @@ enum |
|
|
|
|
{ |
|
|
|
|
VORBIS_packet_id = 1, |
|
|
|
|
VORBIS_packet_comment = 3, |
|
|
|
|
VORBIS_packet_setup = 5, |
|
|
|
|
VORBIS_packet_setup = 5 |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
static int codebook_decode_scalar_raw(vorb *f, Codebook *c) |
|
|
|
|
@ -1584,7 +1594,9 @@ static int codebook_decode_scalar_raw(vorb *f, Codebook *c) |
|
|
|
|
int i; |
|
|
|
|
prep_huffman(f); |
|
|
|
|
|
|
|
|
|
assert(c->sorted_codewords || c->codewords); |
|
|
|
|
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) { |
|
|
|
|
@ -1692,15 +1704,9 @@ static int codebook_decode_scalar(vorb *f, Codebook *c) |
|
|
|
|
|
|
|
|
|
// CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case
|
|
|
|
|
// where we avoid one addition
|
|
|
|
|
#ifndef STB_VORBIS_CODEBOOK_FLOATS |
|
|
|
|
#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off] * c->delta_value + c->minimum_value) |
|
|
|
|
#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off] * c->delta_value) |
|
|
|
|
#define CODEBOOK_ELEMENT_BASE(c) (c->minimum_value) |
|
|
|
|
#else |
|
|
|
|
#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off]) |
|
|
|
|
#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off]) |
|
|
|
|
#define CODEBOOK_ELEMENT_BASE(c) (0) |
|
|
|
|
#endif |
|
|
|
|
#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) |
|
|
|
|
{ |
|
|
|
|
@ -1892,7 +1898,6 @@ static int codebook_decode_deinterleave_repeat_2(vorb *f, Codebook *c, float **o |
|
|
|
|
|
|
|
|
|
{ |
|
|
|
|
z *= c->dimensions; |
|
|
|
|
stb_prof(11); |
|
|
|
|
if (c->sequence_p) { |
|
|
|
|
// haven't optimized this case because I don't have any examples
|
|
|
|
|
for (i=0; i < effective; ++i) { |
|
|
|
|
@ -1904,7 +1909,7 @@ static int codebook_decode_deinterleave_repeat_2(vorb *f, Codebook *c, float **o |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
i=0; |
|
|
|
|
if (c_inter == 1) { |
|
|
|
|
if (c_inter == 1 && i < effective) { |
|
|
|
|
float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; |
|
|
|
|
if (outputs[c_inter]) |
|
|
|
|
outputs[c_inter][p_inter] += val; |
|
|
|
|
@ -2076,15 +2081,17 @@ static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y |
|
|
|
|
#endif |
|
|
|
|
ady -= abs(base) * adx; |
|
|
|
|
if (x1 > n) x1 = n; |
|
|
|
|
LINE_OP(output[x], inverse_db_table[y]); |
|
|
|
|
for (++x; x < x1; ++x) { |
|
|
|
|
err += ady; |
|
|
|
|
if (err >= adx) { |
|
|
|
|
err -= adx; |
|
|
|
|
y += sy; |
|
|
|
|
} else |
|
|
|
|
y += base; |
|
|
|
|
if (x < x1) { |
|
|
|
|
LINE_OP(output[x], inverse_db_table[y]); |
|
|
|
|
for (++x; x < x1; ++x) { |
|
|
|
|
err += ady; |
|
|
|
|
if (err >= adx) { |
|
|
|
|
err -= adx; |
|
|
|
|
y += sy; |
|
|
|
|
} else |
|
|
|
|
y += base; |
|
|
|
|
LINE_OP(output[x], inverse_db_table[y]); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -2123,7 +2130,8 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
int **classifications = (int **) temp_block_array(f,f->channels, part_read * sizeof(**classifications)); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
stb_prof(2); |
|
|
|
|
CHECK(f); |
|
|
|
|
|
|
|
|
|
for (i=0; i < ch; ++i) |
|
|
|
|
if (!do_not_decode[i]) |
|
|
|
|
memset(residue_buffers[i], 0, sizeof(float) * n); |
|
|
|
|
@ -2135,11 +2143,9 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
if (j == ch) |
|
|
|
|
goto done; |
|
|
|
|
|
|
|
|
|
stb_prof(3); |
|
|
|
|
for (pass=0; pass < 8; ++pass) { |
|
|
|
|
int pcount = 0, class_set = 0; |
|
|
|
|
if (ch == 2) { |
|
|
|
|
stb_prof(13); |
|
|
|
|
while (pcount < part_read) { |
|
|
|
|
int z = r->begin + pcount*r->part_size; |
|
|
|
|
int c_inter = (z & 1), p_inter = z>>1; |
|
|
|
|
@ -2157,7 +2163,6 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
} |
|
|
|
|
stb_prof(5); |
|
|
|
|
for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { |
|
|
|
|
int z = r->begin + pcount*r->part_size; |
|
|
|
|
#ifndef STB_VORBIS_DIVIDES_IN_RESIDUE |
|
|
|
|
@ -2168,23 +2173,20 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
int b = r->residue_books[c][pass]; |
|
|
|
|
if (b >= 0) { |
|
|
|
|
Codebook *book = f->codebooks + b; |
|
|
|
|
stb_prof(20); // accounts for X time
|
|
|
|
|
#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_2(f, book, residue_buffers, &c_inter, &p_inter, n, r->part_size)) |
|
|
|
|
if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) |
|
|
|
|
goto done; |
|
|
|
|
#endif |
|
|
|
|
stb_prof(7); |
|
|
|
|
} else { |
|
|
|
|
z += r->part_size; |
|
|
|
|
c_inter = z & 1; |
|
|
|
|
p_inter = z >> 1; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
stb_prof(8); |
|
|
|
|
#ifndef STB_VORBIS_DIVIDES_IN_RESIDUE |
|
|
|
|
++class_set; |
|
|
|
|
#endif |
|
|
|
|
@ -2217,10 +2219,8 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
int b = r->residue_books[c][pass]; |
|
|
|
|
if (b >= 0) { |
|
|
|
|
Codebook *book = f->codebooks + b; |
|
|
|
|
stb_prof(22); |
|
|
|
|
if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) |
|
|
|
|
goto done; |
|
|
|
|
stb_prof(3); |
|
|
|
|
} else { |
|
|
|
|
z += r->part_size; |
|
|
|
|
c_inter = 0; |
|
|
|
|
@ -2259,10 +2259,8 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
int b = r->residue_books[c][pass]; |
|
|
|
|
if (b >= 0) { |
|
|
|
|
Codebook *book = f->codebooks + b; |
|
|
|
|
stb_prof(22); |
|
|
|
|
if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) |
|
|
|
|
goto done; |
|
|
|
|
stb_prof(3); |
|
|
|
|
} else { |
|
|
|
|
z += r->part_size; |
|
|
|
|
c_inter = z % ch; |
|
|
|
|
@ -2277,7 +2275,7 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
} |
|
|
|
|
goto done; |
|
|
|
|
} |
|
|
|
|
stb_prof(9); |
|
|
|
|
CHECK(f); |
|
|
|
|
|
|
|
|
|
for (pass=0; pass < 8; ++pass) { |
|
|
|
|
int pcount = 0, class_set=0; |
|
|
|
|
@ -2326,7 +2324,7 @@ static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
done: |
|
|
|
|
stb_prof(0); |
|
|
|
|
CHECK(f); |
|
|
|
|
temp_alloc_restore(f,temp_alloc_point); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -3140,13 +3138,16 @@ static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *f |
|
|
|
|
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) |
|
|
|
|
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; |
|
|
|
|
} |
|
|
|
|
@ -3217,6 +3218,7 @@ static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, in |
|
|
|
|
*p_right_start = window_center; |
|
|
|
|
*p_right_end = n; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return TRUE; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -3235,7 +3237,8 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
// FLOORS
|
|
|
|
|
n2 = n >> 1; |
|
|
|
|
|
|
|
|
|
stb_prof(1); |
|
|
|
|
CHECK(f); |
|
|
|
|
|
|
|
|
|
for (i=0; i < f->channels; ++i) { |
|
|
|
|
int s = map->chan[i].mux, floor; |
|
|
|
|
zero_channel[i] = FALSE; |
|
|
|
|
@ -3327,7 +3330,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
// at this point we've decoded the floor into buffer
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
stb_prof(0); |
|
|
|
|
CHECK(f); |
|
|
|
|
// at this point we've decoded all floors
|
|
|
|
|
|
|
|
|
|
if (f->alloc.alloc_buffer) |
|
|
|
|
@ -3340,6 +3343,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
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]; |
|
|
|
|
@ -3364,9 +3368,9 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
|
|
|
|
|
if (f->alloc.alloc_buffer) |
|
|
|
|
assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); |
|
|
|
|
CHECK(f); |
|
|
|
|
|
|
|
|
|
// INVERSE COUPLING
|
|
|
|
|
stb_prof(14); |
|
|
|
|
for (i = map->coupling_steps-1; i >= 0; --i) { |
|
|
|
|
int n2 = n >> 1; |
|
|
|
|
float *m = f->channel_buffers[map->chan[i].magnitude]; |
|
|
|
|
@ -3387,10 +3391,10 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
a[j] = a2; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
CHECK(f); |
|
|
|
|
|
|
|
|
|
// finish decoding the floors
|
|
|
|
|
#ifndef STB_VORBIS_NO_DEFER_FLOOR |
|
|
|
|
stb_prof(15); |
|
|
|
|
for (i=0; i < f->channels; ++i) { |
|
|
|
|
if (really_zero_channel[i]) { |
|
|
|
|
memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); |
|
|
|
|
@ -3410,10 +3414,10 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
// INVERSE MDCT
|
|
|
|
|
stb_prof(16); |
|
|
|
|
CHECK(f); |
|
|
|
|
for (i=0; i < f->channels; ++i) |
|
|
|
|
inverse_mdct(f->channel_buffers[i], n, f, m->blockflag); |
|
|
|
|
stb_prof(0); |
|
|
|
|
CHECK(f); |
|
|
|
|
|
|
|
|
|
// this shouldn't be necessary, unless we exited on an error
|
|
|
|
|
// and want to flush to get to the next packet
|
|
|
|
|
@ -3455,7 +3459,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
if (f->current_loc_valid && (f->page_flag & PAGEFLAG_last_page)) { |
|
|
|
|
uint32 current_end = f->known_loc_for_packet - (n-right_end); |
|
|
|
|
// then let's infer the size of the (probably) short final frame
|
|
|
|
|
if (current_end < f->current_loc + right_end) { |
|
|
|
|
if (current_end < f->current_loc + (right_end-left_start)) { |
|
|
|
|
if (current_end < f->current_loc) { |
|
|
|
|
// negative truncation, that's impossible!
|
|
|
|
|
*len = 0; |
|
|
|
|
@ -3463,6 +3467,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, |
|
|
|
|
*len = current_end - f->current_loc; |
|
|
|
|
} |
|
|
|
|
*len += left_start; |
|
|
|
|
if (*len > right_end) *len = right_end; // this should never happen
|
|
|
|
|
f->current_loc += *len; |
|
|
|
|
return TRUE; |
|
|
|
|
} |
|
|
|
|
@ -3480,6 +3485,8 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int 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; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -3645,14 +3652,15 @@ static int start_decoder(vorb *f) |
|
|
|
|
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); |
|
|
|
|
{ |
|
|
|
|
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
|
|
|
|
|
@ -3701,6 +3709,7 @@ static int start_decoder(vorb *f) |
|
|
|
|
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); |
|
|
|
|
@ -3712,6 +3721,8 @@ static int start_decoder(vorb *f) |
|
|
|
|
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 |
|
|
|
|
@ -3736,6 +3747,8 @@ static int start_decoder(vorb *f) |
|
|
|
|
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; |
|
|
|
|
} |
|
|
|
|
@ -3770,6 +3783,7 @@ static int start_decoder(vorb *f) |
|
|
|
|
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); |
|
|
|
|
@ -3815,6 +3829,7 @@ static int start_decoder(vorb *f) |
|
|
|
|
|
|
|
|
|
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) { |
|
|
|
|
@ -3828,6 +3843,7 @@ static int start_decoder(vorb *f) |
|
|
|
|
} 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) { |
|
|
|
|
@ -3839,6 +3855,7 @@ static int start_decoder(vorb *f) |
|
|
|
|
#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; |
|
|
|
|
@ -3848,21 +3865,22 @@ static int start_decoder(vorb *f) |
|
|
|
|
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) { |
|
|
|
|
int z = sparse ? c->sorted_values[j] : j, div=1; |
|
|
|
|
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; |
|
|
|
|
c->multiplicands[j*c->dimensions + k] = |
|
|
|
|
#ifndef STB_VORBIS_CODEBOOK_FLOATS |
|
|
|
|
mults[off]; |
|
|
|
|
#else |
|
|
|
|
mults[off]*c->delta_value + c->minimum_value; |
|
|
|
|
// in this case (and this case only) we could pre-expand c->sequence_p,
|
|
|
|
|
// and throw away the decode logic for it; have to ALSO do
|
|
|
|
|
// it in the case below, but it can only be done if
|
|
|
|
|
// STB_VORBIS_CODEBOOK_FLOATS
|
|
|
|
|
// !STB_VORBIS_DIVIDES_IN_CODEBOOK
|
|
|
|
|
#endif |
|
|
|
|
div *= c->lookup_values; |
|
|
|
|
float val = mults[off]; |
|
|
|
|
val = mults[off]*c->delta_value + c->minimum_value + last; |
|
|
|
|
c->multiplicands[j*c->dimensions + k] = val; |
|
|
|
|
if (c->sequence_p) |
|
|
|
|
last = val; |
|
|
|
|
if (k+1 < c->dimensions) { |
|
|
|
|
if (div > UINT_MAX / (unsigned int) c->lookup_values) { |
|
|
|
|
setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); |
|
|
|
|
return error(f, VORBIS_invalid_setup); |
|
|
|
|
} |
|
|
|
|
div *= c->lookup_values; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); |
|
|
|
|
@ -3871,28 +3889,25 @@ static int start_decoder(vorb *f) |
|
|
|
|
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); } |
|
|
|
|
#ifndef STB_VORBIS_CODEBOOK_FLOATS |
|
|
|
|
memcpy(c->multiplicands, mults, sizeof(c->multiplicands[0]) * c->lookup_values); |
|
|
|
|
#else |
|
|
|
|
for (j=0; j < (int) c->lookup_values; ++j) |
|
|
|
|
c->multiplicands[j] = mults[j] * c->delta_value + c->minimum_value; |
|
|
|
|
#endif |
|
|
|
|
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; |
|
|
|
|
} |
|
|
|
|
setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); |
|
|
|
|
} |
|
|
|
|
#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK |
|
|
|
|
skip:; |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#ifdef STB_VORBIS_CODEBOOK_FLOATS |
|
|
|
|
if (c->lookup_type == 2 && c->sequence_p) { |
|
|
|
|
for (j=1; j < (int) c->lookup_values; ++j) |
|
|
|
|
c->multiplicands[j] = c->multiplicands[j-1]; |
|
|
|
|
c->sequence_p = 0; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
CHECK(f); |
|
|
|
|
} |
|
|
|
|
CHECK(f); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// time domain transfers (notused)
|
|
|
|
|
@ -3988,9 +4003,11 @@ static int start_decoder(vorb *f) |
|
|
|
|
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); |
|
|
|
|
@ -4171,6 +4188,7 @@ static void vorbis_deinit(stb_vorbis *p) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (p->codebooks) { |
|
|
|
|
CHECK(p); |
|
|
|
|
for (i=0; i < p->codebook_count; ++i) { |
|
|
|
|
Codebook *c = p->codebooks + i; |
|
|
|
|
setup_free(p, c->codeword_lengths); |
|
|
|
|
@ -4189,6 +4207,7 @@ static void vorbis_deinit(stb_vorbis *p) |
|
|
|
|
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]); |
|
|
|
|
@ -4216,7 +4235,7 @@ void stb_vorbis_close(stb_vorbis *p) |
|
|
|
|
setup_free(p,p); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void vorbis_init(stb_vorbis *p, stb_vorbis_alloc *z) |
|
|
|
|
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) { |
|
|
|
|
@ -4374,11 +4393,11 @@ static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len) |
|
|
|
|
|
|
|
|
|
// return value: number of bytes we used
|
|
|
|
|
int stb_vorbis_decode_frame_pushdata( |
|
|
|
|
stb_vorbis *f, // the file we're decoding
|
|
|
|
|
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
|
|
|
|
|
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; |
|
|
|
|
@ -4388,11 +4407,11 @@ int stb_vorbis_decode_frame_pushdata( |
|
|
|
|
|
|
|
|
|
if (f->page_crc_tests >= 0) { |
|
|
|
|
*samples = 0; |
|
|
|
|
return vorbis_search_for_page_pushdata(f, data, data_len); |
|
|
|
|
return vorbis_search_for_page_pushdata(f, (uint8 *) data, data_len); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
f->stream = data; |
|
|
|
|
f->stream_end = 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
|
|
|
|
|
@ -4444,14 +4463,14 @@ int stb_vorbis_decode_frame_pushdata( |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
stb_vorbis *stb_vorbis_open_pushdata( |
|
|
|
|
unsigned char *data, int data_len, // the memory available for decoding
|
|
|
|
|
const unsigned char *data, int data_len, // the memory available for decoding
|
|
|
|
|
int *data_used, // only defined if result is not NULL
|
|
|
|
|
int *error, stb_vorbis_alloc *alloc) |
|
|
|
|
int *error, const stb_vorbis_alloc *alloc) |
|
|
|
|
{ |
|
|
|
|
stb_vorbis *f, p; |
|
|
|
|
vorbis_init(&p, alloc); |
|
|
|
|
p.stream = data; |
|
|
|
|
p.stream_end = data + data_len; |
|
|
|
|
p.stream = (uint8 *) data; |
|
|
|
|
p.stream_end = (uint8 *) data + data_len; |
|
|
|
|
p.push_mode = TRUE; |
|
|
|
|
if (!start_decoder(&p)) { |
|
|
|
|
if (p.eof) |
|
|
|
|
@ -4971,7 +4990,7 @@ int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output) |
|
|
|
|
|
|
|
|
|
#ifndef STB_VORBIS_NO_STDIO |
|
|
|
|
|
|
|
|
|
stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, stb_vorbis_alloc *alloc, unsigned int length) |
|
|
|
|
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); |
|
|
|
|
@ -4992,7 +5011,7 @@ stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *er |
|
|
|
|
return NULL; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, stb_vorbis_alloc *alloc) |
|
|
|
|
stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc) |
|
|
|
|
{ |
|
|
|
|
unsigned int len, start; |
|
|
|
|
start = ftell(file); |
|
|
|
|
@ -5002,7 +5021,7 @@ stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, stb |
|
|
|
|
return stb_vorbis_open_file_section(file, close_on_free, error, alloc, len); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, stb_vorbis_alloc *alloc) |
|
|
|
|
stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc) |
|
|
|
|
{ |
|
|
|
|
FILE *f = fopen(filename, "rb"); |
|
|
|
|
if (f)
|
|
|
|
|
@ -5012,7 +5031,7 @@ stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, stb_vorb |
|
|
|
|
} |
|
|
|
|
#endif // STB_VORBIS_NO_STDIO
|
|
|
|
|
|
|
|
|
|
stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, stb_vorbis_alloc *alloc) |
|
|
|
|
stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc) |
|
|
|
|
{ |
|
|
|
|
stb_vorbis *f, p; |
|
|
|
|
if (data == NULL) return NULL; |
|
|
|
|
@ -5392,6 +5411,8 @@ int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, in |
|
|
|
|
#endif // STB_VORBIS_NO_PULLDATA_API
|
|
|
|
|
|
|
|
|
|
/* Version history
|
|
|
|
|
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 |
|
|
|
|
|
Sean Barrett
ago%!(EXTRA string=10 years)