#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

#ifndef STB_VORBIS_NO_STDIO

#include <stdio.h>

#ifdef __cplusplus

extern "C" {

typedef struct

{

char *alloc_buffer;

int alloc_buffer_length_in_bytes;

} stb_vorbis_alloc;

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;

extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f);

extern stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f);

extern int stb_vorbis_get_error(stb_vorbis *f);

extern void stb_vorbis_close(stb_vorbis *f);

extern int stb_vorbis_get_sample_offset(stb_vorbis *f);

extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f);

#ifndef STB_VORBIS_NO_PUSHDATA_API

extern stb_vorbis *stb_vorbis_open_pushdata(

const stb_vorbis_alloc *alloc_buffer);

extern int stb_vorbis_decode_frame_pushdata(

);

extern void stb_vorbis_flush_pushdata(stb_vorbis *f);

#ifndef STB_VORBIS_NO_PULLDATA_API

#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);

#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);

extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len,

int *error, const stb_vorbis_alloc *alloc_buffer);

#ifndef STB_VORBIS_NO_STDIO

extern stb_vorbis * stb_vorbis_open_filename(const char *filename,

int *error, const stb_vorbis_alloc *alloc_buffer);

extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close,

int *error, const stb_vorbis_alloc *alloc_buffer);

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);

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);

extern int stb_vorbis_seek_start(stb_vorbis *f);

extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f);

extern float stb_vorbis_stream_length_in_seconds(stb_vorbis *f);

extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output);

#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);

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);

#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);

enum STBVorbisError

};

#ifdef __cplusplus

}

#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H

#ifndef STB_VORBIS_HEADER_ONLY

#ifndef STB_VORBIS_MAX_CHANNELS

#define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone?

#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT

#define STB_VORBIS_PUSHDATA_CRC_COUNT 4

#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH

#define STB_VORBIS_FAST_HUFFMAN_LENGTH 10

#ifndef STB_VORBIS_FAST_HUFFMAN_INT

#define STB_VORBIS_FAST_HUFFMAN_SHORT

#ifdef STB_VORBIS_CODEBOOK_SHORTS

#error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats"

#ifdef STB_VORBIS_NO_PULLDATA_API

#define STB_VORBIS_NO_INTEGER_CONVERSION

#define STB_VORBIS_NO_STDIO

#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)

#define STB_VORBIS_NO_STDIO 1

#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

#ifndef STB_VORBIS_NO_STDIO

#include <stdio.h>

#ifndef STB_VORBIS_NO_CRT

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <math.h>

// find definition of alloca if it's not in stdlib.h:

#if defined(_MSC_VER) || defined(__MINGW32__)

#include <malloc.h>

#endif

#if defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)

#include <alloca.h>

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

#ifndef alloca

#define alloca __builtin_alloca

#endif

#elif !defined(_MSC_VER)

#if __GNUC__

#define __forceinline inline

#else

#define __forceinline

#endif

#if STB_VORBIS_MAX_CHANNELS > 256

#error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range"

#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24

#error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range"

#if 0

#include <crtdbg.h>

#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1])

#define CHECK(f) ((void) 0)

#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

typedef float codetype;

#ifdef _MSC_VER

#define STBV_NOTUSED(v) (void)(v)

#define STBV_NOTUSED(v) (void)sizeof(v)

#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

};

#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

#define IS_PUSH_MODE(f) ((f)->push_mode)

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;

}

#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)

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;

}