69 #ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H
70 #define STB_VORBIS_INCLUDE_STB_VORBIS_H
72 #if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
73 #define STB_VORBIS_NO_STDIO 1
76 #ifndef STB_VORBIS_NO_STDIO
116 int alloc_buffer_length_in_bytes;
169 #ifndef STB_VORBIS_NO_PUSHDATA_API
179 const unsigned char * datablock,
int datablock_length_in_bytes,
180 int *datablock_memory_consumed_in_bytes,
194 const unsigned char *datablock,
int datablock_length_in_bytes,
238 #ifndef STB_VORBIS_NO_PULLDATA_API
246 #if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
249 #if !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
262 #ifndef STB_VORBIS_NO_STDIO
313 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
349 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
403 #endif // STB_VORBIS_INCLUDE_STB_VORBIS_H
409 #ifndef STB_VORBIS_HEADER_ONLY
449 #ifndef STB_VORBIS_MAX_CHANNELS
450 #define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone?
465 #ifndef STB_VORBIS_PUSHDATA_CRC_COUNT
466 #define STB_VORBIS_PUSHDATA_CRC_COUNT 4
474 #ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH
475 #define STB_VORBIS_FAST_HUFFMAN_LENGTH 10
488 #ifndef STB_VORBIS_FAST_HUFFMAN_INT
489 #define STB_VORBIS_FAST_HUFFMAN_SHORT
516 #ifdef STB_VORBIS_CODEBOOK_SHORTS
517 #error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats"
541 #ifdef STB_VORBIS_NO_PULLDATA_API
542 #define STB_VORBIS_NO_INTEGER_CONVERSION
543 #define STB_VORBIS_NO_STDIO
546 #if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
547 #define STB_VORBIS_NO_STDIO 1
550 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
551 #ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
556 #ifndef STB_VORBIS_BIG_ENDIAN
557 #define STB_VORBIS_ENDIAN 0
559 #define STB_VORBIS_ENDIAN 1
566 #ifndef STB_VORBIS_NO_STDIO
570 #ifndef STB_VORBIS_NO_CRT
577 #if defined(_MSC_VER) || defined(__MINGW32__)
580 #if defined(__linux__) || defined(__linux) || defined(__EMSCRIPTEN__)
583 #else // STB_VORBIS_NO_CRT
586 #define free(s) ((void) 0)
588 #endif // STB_VORBIS_NO_CRT
601 #define __forceinline
603 #define alloca __builtin_alloca
605 #elif !defined(_MSC_VER)
607 #define __forceinline inline
609 #define __forceinline
613 #if STB_VORBIS_MAX_CHANNELS > 256
614 #error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range"
617 #if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24
618 #error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range"
624 #define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1])
626 #define CHECK(f) ((void) 0)
629 #define MAX_BLOCKSIZE_LOG 13 // from specification
630 #define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG)
660 #define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)
661 #define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1)
665 int dimensions, entries;
666 uint8 *codeword_lengths;
676 #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
691 uint8 amplitude_bits;
692 uint8 amplitude_offset;
693 uint8 number_of_books;
700 uint8 partition_class_list[32];
701 uint8 class_dimensions[16];
702 uint8 class_subclasses[16];
703 uint8 class_masterbooks[16];
704 int16 subclass_books[16][8];
706 uint8 sorted_order[31*8+2];
708 uint8 floor1_multiplier;
723 uint8 classifications;
726 int16 (*residue_books)[8];
741 uint8 submap_floor[15];
742 uint8 submap_residue[15];
764 uint32 page_start, page_end;
765 uint32 last_decoded_sample;
783 #ifndef STB_VORBIS_NO_STDIO
840 #ifndef STB_VORBIS_NO_DEFER_FLOOR
852 float *
A[2],*
B[2],*
C[2];
877 #ifndef STB_VORBIS_NO_PUSHDATA_API
886 #if defined(STB_VORBIS_NO_PUSHDATA_API)
887 #define IS_PUSH_MODE(f) FALSE
888 #elif defined(STB_VORBIS_NO_PULLDATA_API)
889 #define IS_PUSH_MODE(f) TRUE
891 #define IS_PUSH_MODE(f) ((f)->push_mode)
911 #define array_size_required(count,size) (count*(sizeof(void *)+(size)))
913 #define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))
914 #define temp_free(f,p) (void)0
915 #define temp_alloc_save(f) ((f)->temp_offset)
916 #define temp_alloc_restore(f,p) ((f)->temp_offset = (p))
918 #define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)
924 void ** p = (
void **) mem;
925 char *q = (
char *) (p +
count);
926 for (i=0; i <
count; ++i) {
936 f->setup_memory_required += sz;
937 if (
f->alloc.alloc_buffer) {
938 void *p = (
char *)
f->alloc.alloc_buffer +
f->setup_offset;
939 if (
f->setup_offset + sz >
f->temp_offset)
return NULL;
940 f->setup_offset += sz;
943 return sz ? malloc(sz) :
NULL;
948 if (
f->alloc.alloc_buffer)
return;
955 if (
f->alloc.alloc_buffer) {
957 f->temp_offset -= sz;
958 return (
char *)
f->alloc.alloc_buffer +
f->temp_offset;
965 if (
f->alloc.alloc_buffer) {
966 f->temp_offset += (sz+3)&~3;
972 #define CRC32_POLY 0x04c11db7 // from spec
979 for(i=0; i < 256; i++) {
980 for (
s=(
uint32) i << 24, j=0; j < 8; ++j)
988 return (crc << 8) ^
crc_table[
byte ^ (crc >> 24)];
995 n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1);
996 n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2);
997 n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4);
998 n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8);
999 return (n >> 16) | (n << 16);
1012 static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 };
1014 if (n < 0)
return 0;
1018 if (n < (1 << 4))
return 0 + log2_4[n ];
1019 else if (n < (1 << 9))
return 5 + log2_4[n >> 5];
1020 else return 10 + log2_4[n >> 10];
1021 else if (n < (1 << 24))
1022 if (n < (1 << 19))
return 15 + log2_4[n >> 15];
1023 else return 20 + log2_4[n >> 20];
1024 else if (n < (1 << 29))
return 25 + log2_4[n >> 25];
1025 else return 30 + log2_4[n >> 30];
1029 #define M_PI 3.14159265358979323846264f // from CRC
1043 uint32 mantissa = x & 0x1fffff;
1044 uint32 sign = x & 0x80000000;
1045 uint32 exp = (x & 0x7fe00000) >> 21;
1046 double res = sign ? -(double)mantissa : (
double)mantissa;
1047 return (
float) ldexp((
float)res, exp-788);
1065 values [
count] = symbol;
1074 memset(available, 0,
sizeof(available));
1076 for (k=0; k < n; ++k)
if (len[k] <
NO_CODE)
break;
1079 add_entry(c, 0, k, m++, len[k], values);
1081 for (i=1; i <= len[k]; ++i)
1082 available[i] = 1U << (32-i);
1087 for (i=k+1; i < n; ++i) {
1097 while (z > 0 && !available[z]) --z;
1098 if (z == 0) {
return FALSE; }
1100 assert(z >= 0 && z < 32);
1105 assert(len[i] >= 0 && len[i] < 32);
1106 for (y=len[i]; y > z; --y) {
1107 assert(available[y] == 0);
1108 available[y] = res + (1 << (32-y));
1125 if (len > 32767) len = 32767;
1127 for (i=0; i < len; ++i) {
1140 #define STBV_CDECL __cdecl
1149 return x < y ? -1 : x > y;
1171 for (i=0; i < c->
entries; ++i)
1189 for (i=0; i < len; ++i) {
1190 int huff_len = c->
sparse ? lengths[values[i]] : lengths[i];
1196 int m = x + (n >> 1);
1218 static uint8 vorbis[6] = {
'v',
'o',
'r',
'b',
'i',
's' };
1219 return memcmp(data, vorbis, 6) == 0;
1226 int r = (int) floor(exp((
float)
log((
float) entries) / dim));
1227 if ((
int) floor(pow((
float) r+1, dim)) <= entries)
1229 if (pow((
float) r+1, dim) <= entries)
1231 if ((
int) floor(pow((
float) r, dim)) > entries)
1239 int n4 = n >> 2, n8 = n >> 3;
1242 for (k=k2=0; k < n4; ++k,k2+=2) {
1243 A[k2 ] = (float) cos(4*k*
M_PI/n);
1244 A[k2+1] = (float) -sin(4*k*
M_PI/n);
1245 B[k2 ] = (float) cos((k2+1)*
M_PI/n/2) * 0.5
f;
1246 B[k2+1] = (float) sin((k2+1)*
M_PI/n/2) * 0.5
f;
1248 for (k=k2=0; k < n8; ++k,k2+=2) {
1249 C[k2 ] = (float) cos(2*(k2+1)*
M_PI/n);
1250 C[k2+1] = (float) -sin(2*(k2+1)*
M_PI/n);
1257 for (i=0; i < n2; ++i)
1263 int ld =
ilog(n) - 1;
1265 for (i=0; i < n8; ++i)
1271 int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3;
1291 for (i=0; i < n; ++i) {
1292 if (x[i] > low && x[i] < x[n]) { *plow = i; low = x[i]; }
1293 if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; }
1307 return a->
x < b->
x ? -1 : a->
x > b->
x;
1314 #if defined(STB_VORBIS_NO_STDIO)
1315 #define USE_MEMORY(z) TRUE
1317 #define USE_MEMORY(z) ((z)->stream)
1327 #ifndef STB_VORBIS_NO_STDIO
1329 int c = fgetc(z->
f);
1330 if (c == EOF) { z->
eof =
TRUE;
return 0; }
1350 memcpy(data, z->
stream, n);
1355 #ifndef STB_VORBIS_NO_STDIO
1356 if (fread(data, n, 1, z->
f) == 1)
1372 #ifndef STB_VORBIS_NO_STDIO
1374 long x = ftell(z->
f);
1375 fseek(z->
f, x+n, SEEK_SET);
1382 #ifndef STB_VORBIS_NO_PUSHDATA_API
1383 if (
f->push_mode)
return 0;
1387 if (
f->stream_start + loc >=
f->stream_end ||
f->stream_start + loc < f->
stream_start) {
1388 f->stream =
f->stream_end;
1392 f->stream =
f->stream_start + loc;
1396 #ifndef STB_VORBIS_NO_STDIO
1397 if (loc +
f->f_start < loc || loc >= 0x80000000) {
1403 if (!fseek(
f->f, loc, SEEK_SET))
1406 fseek(
f->f,
f->f_start, SEEK_END);
1423 #define PAGEFLAG_continued_packet 1
1424 #define PAGEFLAG_first_page 2
1425 #define PAGEFLAG_last_page 4
1450 f->segment_count =
get8(
f);
1451 if (!
getn(
f,
f->segments,
f->segment_count))
1454 f->end_seg_with_known_loc = -2;
1455 if (loc0 != ~0U || loc1 != ~0U) {
1458 for (i=
f->segment_count-1; i >= 0; --i)
1459 if (
f->segments[i] < 255)
1463 f->end_seg_with_known_loc = i;
1464 f->known_loc_for_packet = loc0;
1467 if (
f->first_decode) {
1470 for (i=0; i <
f->segment_count; ++i)
1471 len +=
f->segments[i];
1472 len += 27 +
f->segment_count;
1473 f->p_first.page_end =
f->p_first.page_start + len;
1474 f->p_first.last_decoded_sample = loc0;
1488 while (
f->next_seg == -1) {
1495 f->packet_bytes = 0;
1496 f->bytes_in_seg = 0;
1503 if (
f->next_seg == -1) {
1505 if (
f->eof)
return FALSE;
1515 f->bytes_in_seg = 0;
1525 if (
f->last_seg)
return 0;
1526 if (
f->next_seg == -1) {
1527 f->last_seg_which =
f->segment_count-1;
1531 len =
f->segments[
f->next_seg++];
1534 f->last_seg_which =
f->next_seg-1;
1536 if (
f->next_seg >=
f->segment_count)
1538 assert(
f->bytes_in_seg == 0);
1539 f->bytes_in_seg = len;
1544 #define INVALID_BITS (-1)
1548 if (!
f->bytes_in_seg) {
1549 if (
f->last_seg)
return EOP;
1552 assert(
f->bytes_in_seg > 0);
1586 if (
f->valid_bits < 0)
return 0;
1587 if (
f->valid_bits < n) {
1594 if (
f->valid_bits == 0)
f->acc = 0;
1595 while (
f->valid_bits < n) {
1601 f->acc += z <<
f->valid_bits;
1605 if (
f->valid_bits < 0)
return 0;
1606 z =
f->acc & ((1 << n)-1);
1618 if (
f->valid_bits <= 24) {
1619 if (
f->valid_bits == 0)
f->acc = 0;
1622 if (
f->last_seg && !
f->bytes_in_seg)
return;
1624 if (z ==
EOP)
return;
1625 f->acc += (unsigned) z <<
f->valid_bits;
1627 }
while (
f->valid_bits <= 24);
1655 int m = x + (n >> 1);
1667 if (
f->valid_bits >= len) {
1669 f->valid_bits -= len;
1679 for (i=0; i < c->
entries; ++i) {
1697 #ifndef STB_VORBIS_NO_INLINE_DECODE
1699 #define DECODE_RAW(var, f,c) \
1700 if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) \
1702 var = f->acc & FAST_HUFFMAN_TABLE_MASK; \
1703 var = c->fast_huffman[var]; \
1705 int n = c->codeword_lengths[var]; \
1707 f->valid_bits -= n; \
1708 if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \
1710 var = codebook_decode_scalar_raw(f,c); \
1726 if (
f->valid_bits < 0) {
f->valid_bits = 0;
return -1; }
1732 #define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c);
1736 #define DECODE(var,f,c) \
1737 DECODE_RAW(var,f,c) \
1738 if (c->sparse) var = c->sorted_values[var];
1740 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
1741 #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c)
1743 #define DECODE_VQ(var,f,c) DECODE(var,f,c)
1753 #define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off])
1754 #define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off])
1755 #define CODEBOOK_ELEMENT_BASE(c) (0)
1766 if (c->
sparse) assert(z < c->sorted_entries);
1768 if (!
f->bytes_in_seg)
1780 if (z < 0)
return FALSE;
1783 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
1787 for (i=0; i < len; ++i) {
1801 for (i=0; i < len; ++i) {
1808 for (i=0; i < len; ++i) {
1820 if (z < 0)
return FALSE;
1823 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
1826 for (i=0; i < len; ++i) {
1829 output[i*step] += val;
1838 for (i=0; i < len; ++i) {
1840 output[i*step] += val;
1849 int c_inter = *c_inter_p;
1850 int p_inter = *p_inter_p;
1856 while (total_decode > 0) {
1859 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
1860 assert(!c->
sparse || z < c->sorted_entries);
1863 if (!
f->bytes_in_seg)
1864 if (
f->last_seg)
return FALSE;
1872 if (c_inter + p_inter*ch + effective > len * ch) {
1873 effective = len*ch - (p_inter*ch - c_inter);
1876 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
1879 for (i=0; i < effective; ++i) {
1883 outputs[c_inter][p_inter] += val;
1884 if (++c_inter == ch) { c_inter = 0; ++p_inter; }
1893 for (i=0; i < effective; ++i) {
1896 outputs[c_inter][p_inter] += val;
1897 if (++c_inter == ch) { c_inter = 0; ++p_inter; }
1901 for (i=0; i < effective; ++i) {
1904 outputs[c_inter][p_inter] += val;
1905 if (++c_inter == ch) { c_inter = 0; ++p_inter; }
1910 total_decode -= effective;
1912 *c_inter_p = c_inter;
1913 *p_inter_p = p_inter;
1922 int err = abs(dy) * (x - x0);
1923 int off = err / adx;
1924 return dy < 0 ? y0 - off : y0 + off;
1930 1.0649863e-07
f, 1.1341951e-07
f, 1.2079015e-07
f, 1.2863978e-07
f,
1931 1.3699951e-07
f, 1.4590251e-07
f, 1.5538408e-07
f, 1.6548181e-07
f,
1932 1.7623575e-07
f, 1.8768855e-07
f, 1.9988561e-07
f, 2.1287530e-07
f,
1933 2.2670913e-07
f, 2.4144197e-07
f, 2.5713223e-07
f, 2.7384213e-07
f,
1934 2.9163793e-07
f, 3.1059021e-07
f, 3.3077411e-07
f, 3.5226968e-07
f,
1935 3.7516214e-07
f, 3.9954229e-07
f, 4.2550680e-07
f, 4.5315863e-07
f,
1936 4.8260743e-07
f, 5.1396998e-07
f, 5.4737065e-07
f, 5.8294187e-07
f,
1937 6.2082472e-07
f, 6.6116941e-07
f, 7.0413592e-07
f, 7.4989464e-07
f,
1938 7.9862701e-07
f, 8.5052630e-07
f, 9.0579828e-07
f, 9.6466216e-07
f,
1939 1.0273513e-06
f, 1.0941144e-06
f, 1.1652161e-06
f, 1.2409384e-06
f,
1940 1.3215816e-06
f, 1.4074654e-06
f, 1.4989305e-06
f, 1.5963394e-06
f,
1941 1.7000785e-06
f, 1.8105592e-06
f, 1.9282195e-06
f, 2.0535261e-06
f,
1942 2.1869758e-06
f, 2.3290978e-06
f, 2.4804557e-06
f, 2.6416497e-06
f,
1943 2.8133190e-06
f, 2.9961443e-06
f, 3.1908506e-06
f, 3.3982101e-06
f,
1944 3.6190449e-06
f, 3.8542308e-06
f, 4.1047004e-06
f, 4.3714470e-06
f,
1945 4.6555282e-06
f, 4.9580707e-06
f, 5.2802740e-06
f, 5.6234160e-06
f,
1946 5.9888572e-06
f, 6.3780469e-06
f, 6.7925283e-06
f, 7.2339451e-06
f,
1947 7.7040476e-06
f, 8.2047000e-06
f, 8.7378876e-06
f, 9.3057248e-06
f,
1948 9.9104632e-06
f, 1.0554501e-05
f, 1.1240392e-05
f, 1.1970856e-05
f,
1949 1.2748789e-05
f, 1.3577278e-05
f, 1.4459606e-05
f, 1.5399272e-05
f,
1950 1.6400004e-05
f, 1.7465768e-05
f, 1.8600792e-05
f, 1.9809576e-05
f,
1951 2.1096914e-05
f, 2.2467911e-05
f, 2.3928002e-05
f, 2.5482978e-05
f,
1952 2.7139006e-05
f, 2.8902651e-05
f, 3.0780908e-05
f, 3.2781225e-05
f,
1953 3.4911534e-05
f, 3.7180282e-05
f, 3.9596466e-05
f, 4.2169667e-05
f,
1954 4.4910090e-05
f, 4.7828601e-05
f, 5.0936773e-05
f, 5.4246931e-05
f,
1955 5.7772202e-05
f, 6.1526565e-05
f, 6.5524908e-05
f, 6.9783085e-05
f,
1956 7.4317983e-05
f, 7.9147585e-05
f, 8.4291040e-05
f, 8.9768747e-05
f,
1957 9.5602426e-05
f, 0.00010181521f, 0.00010843174f, 0.00011547824f,
1958 0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f,
1959 0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f,
1960 0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f,
1961 0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f,
1962 0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f,
1963 0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f,
1964 0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f,
1965 0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f,
1966 0.00092223983f, 0.00098217216f, 0.0010459992f, 0.0011139742f,
1967 0.0011863665f, 0.0012634633f, 0.0013455702f, 0.0014330129f,
1968 0.0015261382f, 0.0016253153f, 0.0017309374f, 0.0018434235f,
1969 0.0019632195f, 0.0020908006f, 0.0022266726f, 0.0023713743f,
1970 0.0025254795f, 0.0026895994f, 0.0028643847f, 0.0030505286f,
1971 0.0032487691f, 0.0034598925f, 0.0036847358f, 0.0039241906f,
1972 0.0041792066f, 0.0044507950f, 0.0047400328f, 0.0050480668f,
1973 0.0053761186f, 0.0057254891f, 0.0060975636f, 0.0064938176f,
1974 0.0069158225f, 0.0073652516f, 0.0078438871f, 0.0083536271f,
1975 0.0088964928f, 0.009474637f, 0.010090352f, 0.010746080f,
1976 0.011444421f, 0.012188144f, 0.012980198f, 0.013823725f,
1977 0.014722068f, 0.015678791f, 0.016697687f, 0.017782797f,
1978 0.018938423f, 0.020169149f, 0.021479854f, 0.022875735f,
1979 0.024362330f, 0.025945531f, 0.027631618f, 0.029427276f,
1980 0.031339626f, 0.033376252f, 0.035545228f, 0.037855157f,
1981 0.040315199f, 0.042935108f, 0.045725273f, 0.048696758f,
1982 0.051861348f, 0.055231591f, 0.058820850f, 0.062643361f,
1983 0.066714279f, 0.071049749f, 0.075666962f, 0.080584227f,
1984 0.085821044f, 0.091398179f, 0.097337747f, 0.10366330f,
1985 0.11039993f, 0.11757434f, 0.12521498f, 0.13335215f,
1986 0.14201813f, 0.15124727f, 0.16107617f, 0.17154380f,
1987 0.18269168f, 0.19456402f, 0.20720788f, 0.22067342f,
1988 0.23501402f, 0.25028656f, 0.26655159f, 0.28387361f,
1989 0.30232132f, 0.32196786f, 0.34289114f, 0.36517414f,
1990 0.38890521f, 0.41417847f, 0.44109412f, 0.46975890f,
1991 0.50028648f, 0.53279791f, 0.56742212f, 0.60429640f,
1992 0.64356699f, 0.68538959f, 0.72993007f, 0.77736504f,
1993 0.82788260f, 0.88168307f, 0.9389798f, 1.0f
2004 #ifndef STB_VORBIS_NO_DEFER_FLOOR
2005 #define LINE_OP(a,b) a *= b
2007 #define LINE_OP(a,b) a = b
2010 #ifdef STB_VORBIS_DIVIDE_TABLE
2011 #define DIVTAB_NUMER 32
2012 #define DIVTAB_DENOM 64
2013 int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM];
2026 #ifdef STB_VORBIS_DIVIDE_TABLE
2027 if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) {
2029 base = -integer_divide_table[ady][adx];
2032 base = integer_divide_table[ady][adx];
2049 ady -= abs(base) * adx;
2053 for (++x; x < x1; ++x) {
2070 for (k=0; k < step; ++k)
2074 for (k=0; k < n; ) {
2089 Residue *r =
f->residue_config + rn;
2090 int rtype =
f->residue_types[rn];
2092 int classwords =
f->codebooks[c].dimensions;
2093 unsigned int actual_size = rtype == 2 ? n*2 : n;
2094 unsigned int limit_r_begin = (r->
begin < actual_size ? r->
begin : actual_size);
2095 unsigned int limit_r_end = (r->
end < actual_size ? r->
end : actual_size);
2096 int n_read = limit_r_end - limit_r_begin;
2099 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2102 int **classifications = (
int **)
temp_block_array(
f,
f->channels, part_read *
sizeof(**classifications));
2107 for (i=0; i < ch; ++i)
2108 if (!do_not_decode[i])
2109 memset(residue_buffers[i], 0,
sizeof(
float) * n);
2111 if (rtype == 2 && ch != 1) {
2112 for (j=0; j < ch; ++j)
2113 if (!do_not_decode[j])
2118 for (pass=0; pass < 8; ++pass) {
2119 int pcount = 0, class_set = 0;
2121 while (pcount < part_read) {
2123 int c_inter = (z & 1), p_inter = z>>1;
2128 if (q ==
EOP)
goto done;
2129 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2130 part_classdata[0][class_set] = r->
classdata[q];
2132 for (i=classwords-1; i >= 0; --i) {
2138 for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
2140 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2141 int c = part_classdata[0][class_set][i];
2143 int c = classifications[0][pcount];
2148 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
2162 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2166 }
else if (ch > 2) {
2167 while (pcount < part_read) {
2169 int c_inter = z % ch, p_inter = z/ch;
2174 if (q ==
EOP)
goto done;
2175 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2176 part_classdata[0][class_set] = r->
classdata[q];
2178 for (i=classwords-1; i >= 0; --i) {
2184 for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
2186 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2187 int c = part_classdata[0][class_set][i];
2189 int c = classifications[0][pcount];
2202 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2212 for (pass=0; pass < 8; ++pass) {
2213 int pcount = 0, class_set=0;
2214 while (pcount < part_read) {
2216 for (j=0; j < ch; ++j) {
2217 if (!do_not_decode[j]) {
2221 if (temp ==
EOP)
goto done;
2222 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2223 part_classdata[j][class_set] = r->
classdata[temp];
2225 for (i=classwords-1; i >= 0; --i) {
2233 for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
2234 for (j=0; j < ch; ++j) {
2235 if (!do_not_decode[j]) {
2236 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2237 int c = part_classdata[j][class_set][i];
2239 int c = classifications[j][pcount];
2243 float *target = residue_buffers[j];
2253 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2260 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2271 void inverse_mdct_slow(
float *buffer,
int n)
2275 float *x = (
float *) malloc(
sizeof(*x) * n2);
2276 memcpy(x, buffer,
sizeof(*x) * n2);
2277 for (i=0; i < n; ++i) {
2279 for (j=0; j < n2; ++j)
2287 acc += x[j] * (
float) cos(
M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1));
2294 void inverse_mdct_slow(
float *buffer,
int n,
vorb *
f,
int blocktype)
2298 int n2 = n >> 1, nmask = (n << 2) -1;
2299 float *x = (
float *) malloc(
sizeof(*x) * n2);
2300 memcpy(x, buffer,
sizeof(*x) * n2);
2301 for (i=0; i < 4*n; ++i)
2302 mcos[i] = (
float) cos(
M_PI / 2 * i / n);
2304 for (i=0; i < n; ++i) {
2306 for (j=0; j < n2; ++j)
2307 acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask];
2315 void dct_iv_slow(
float *buffer,
int n)
2320 int n2 = n >> 1, nmask = (n << 3) - 1;
2321 memcpy(x, buffer,
sizeof(*x) * n);
2322 for (i=0; i < 8*n; ++i)
2323 mcos[i] = (
float) cos(
M_PI / 4 * i / n);
2324 for (i=0; i < n; ++i) {
2326 for (j=0; j < n; ++j)
2327 acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask];
2332 void inverse_mdct_slow(
float *buffer,
int n,
vorb *
f,
int blocktype)
2334 int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4;
2337 memcpy(temp, buffer, n2 *
sizeof(
float));
2338 dct_iv_slow(temp, n2);
2340 for (i=0; i < n4 ; ++i) buffer[i] = temp[i+n4];
2341 for ( ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1];
2342 for ( ; i < n ; ++i) buffer[i] = -temp[i - n3_4];
2346 #ifndef LIBVORBIS_MDCT
2347 #define LIBVORBIS_MDCT 0
2364 extern void mdct_init(mdct_lookup *lookup,
int n);
2365 extern void mdct_clear(mdct_lookup *l);
2366 extern void mdct_backward(mdct_lookup *init,
float *in,
float *out);
2373 if (M1.n == n) M = &M1;
2374 else if (M2.n == n) M = &M2;
2375 else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; }
2377 if (M2.n) __asm
int 3;
2382 mdct_backward(M, buffer, buffer);
2392 float *ee0 = e + i_off;
2393 float *ee2 = ee0 + k_off;
2396 assert((n & 3) == 0);
2397 for (i=(n>>2); i > 0; --i) {
2398 float k00_20, k01_21;
2399 k00_20 = ee0[ 0] - ee2[ 0];
2400 k01_21 = ee0[-1] - ee2[-1];
2403 ee2[ 0] = k00_20 *
A[0] - k01_21 *
A[1];
2404 ee2[-1] = k01_21 *
A[0] + k00_20 *
A[1];
2407 k00_20 = ee0[-2] - ee2[-2];
2408 k01_21 = ee0[-3] - ee2[-3];
2411 ee2[-2] = k00_20 *
A[0] - k01_21 *
A[1];
2412 ee2[-3] = k01_21 *
A[0] + k00_20 *
A[1];
2415 k00_20 = ee0[-4] - ee2[-4];
2416 k01_21 = ee0[-5] - ee2[-5];
2419 ee2[-4] = k00_20 *
A[0] - k01_21 *
A[1];
2420 ee2[-5] = k01_21 *
A[0] + k00_20 *
A[1];
2423 k00_20 = ee0[-6] - ee2[-6];
2424 k01_21 = ee0[-7] - ee2[-7];
2427 ee2[-6] = k00_20 *
A[0] - k01_21 *
A[1];
2428 ee2[-7] = k01_21 *
A[0] + k00_20 *
A[1];
2438 float k00_20, k01_21;
2441 float *e2 = e0 + k_off;
2443 for (i=lim >> 2; i > 0; --i) {
2444 k00_20 = e0[-0] - e2[-0];
2445 k01_21 = e0[-1] - e2[-1];
2448 e2[-0] = (k00_20)*
A[0] - (k01_21) *
A[1];
2449 e2[-1] = (k01_21)*
A[0] + (k00_20) *
A[1];
2453 k00_20 = e0[-2] - e2[-2];
2454 k01_21 = e0[-3] - e2[-3];
2457 e2[-2] = (k00_20)*
A[0] - (k01_21) *
A[1];
2458 e2[-3] = (k01_21)*
A[0] + (k00_20) *
A[1];
2462 k00_20 = e0[-4] - e2[-4];
2463 k01_21 = e0[-5] - e2[-5];
2466 e2[-4] = (k00_20)*
A[0] - (k01_21) *
A[1];
2467 e2[-5] = (k01_21)*
A[0] + (k00_20) *
A[1];
2471 k00_20 = e0[-6] - e2[-6];
2472 k01_21 = e0[-7] - e2[-7];
2475 e2[-6] = (k00_20)*
A[0] - (k01_21) *
A[1];
2476 e2[-7] = (k01_21)*
A[0] + (k00_20) *
A[1];
2490 float A2 =
A[0+a_off];
2491 float A3 =
A[0+a_off+1];
2492 float A4 =
A[0+a_off*2+0];
2493 float A5 =
A[0+a_off*2+1];
2494 float A6 =
A[0+a_off*3+0];
2495 float A7 =
A[0+a_off*3+1];
2499 float *ee0 = e +i_off;
2500 float *ee2 = ee0+k_off;
2502 for (i=n; i > 0; --i) {
2503 k00 = ee0[ 0] - ee2[ 0];
2504 k11 = ee0[-1] - ee2[-1];
2505 ee0[ 0] = ee0[ 0] + ee2[ 0];
2506 ee0[-1] = ee0[-1] + ee2[-1];
2507 ee2[ 0] = (k00) * A0 - (k11) * A1;
2508 ee2[-1] = (k11) * A0 + (k00) * A1;
2510 k00 = ee0[-2] - ee2[-2];
2511 k11 = ee0[-3] - ee2[-3];
2512 ee0[-2] = ee0[-2] + ee2[-2];
2513 ee0[-3] = ee0[-3] + ee2[-3];
2514 ee2[-2] = (k00) * A2 - (k11) * A3;
2515 ee2[-3] = (k11) * A2 + (k00) * A3;
2517 k00 = ee0[-4] - ee2[-4];
2518 k11 = ee0[-5] - ee2[-5];
2519 ee0[-4] = ee0[-4] + ee2[-4];
2520 ee0[-5] = ee0[-5] + ee2[-5];
2521 ee2[-4] = (k00) * A4 - (k11) * A5;
2522 ee2[-5] = (k11) * A4 + (k00) * A5;
2524 k00 = ee0[-6] - ee2[-6];
2525 k11 = ee0[-7] - ee2[-7];
2526 ee0[-6] = ee0[-6] + ee2[-6];
2527 ee0[-7] = ee0[-7] + ee2[-7];
2528 ee2[-6] = (k00) * A6 - (k11) * A7;
2529 ee2[-7] = (k11) * A6 + (k00) * A7;
2538 float k00,k11,k22,k33;
2541 k00 = z[ 0] - z[-4];
2544 k22 = z[-2] - z[-6];
2551 k33 = z[-3] - z[-7];
2558 k11 = z[-1] - z[-5];
2570 int a_off = base_n >> 3;
2571 float A2 =
A[0+a_off];
2572 float *z = e + i_off;
2573 float *base = z - 16 * n;
2578 k00 = z[-0] - z[-8];
2579 k11 = z[-1] - z[-9];
2580 z[-0] = z[-0] + z[-8];
2581 z[-1] = z[-1] + z[-9];
2585 k00 = z[ -2] - z[-10];
2586 k11 = z[ -3] - z[-11];
2587 z[ -2] = z[ -2] + z[-10];
2588 z[ -3] = z[ -3] + z[-11];
2589 z[-10] = (k00+k11) * A2;
2590 z[-11] = (k11-k00) * A2;
2592 k00 = z[-12] - z[ -4];
2593 k11 = z[ -5] - z[-13];
2594 z[ -4] = z[ -4] + z[-12];
2595 z[ -5] = z[ -5] + z[-13];
2599 k00 = z[-14] - z[ -6];
2600 k11 = z[ -7] - z[-15];
2601 z[ -6] = z[ -6] + z[-14];
2602 z[ -7] = z[ -7] + z[-15];
2603 z[-14] = (k00+k11) * A2;
2604 z[-15] = (k00-k11) * A2;
2614 int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
2618 float *buf2 = (
float *)
temp_alloc(
f, n2 *
sizeof(*buf2));
2621 float *
A =
f->A[blocktype];
2643 float *
d,*e, *AA, *e_stop;
2647 e_stop = &buffer[n2];
2648 while (e != e_stop) {
2649 d[1] = (e[0] * AA[0] - e[2]*AA[1]);
2650 d[0] = (e[0] * AA[1] + e[2]*AA[0]);
2658 d[1] = (-e[2] * AA[0] - -e[0]*AA[1]);
2659 d[0] = (-e[2] * AA[1] + -e[0]*AA[0]);
2677 float *AA = &
A[n2-8];
2678 float *d0,*d1, *e0, *e1;
2687 float v40_20, v41_21;
2689 v41_21 = e0[1] - e1[1];
2690 v40_20 = e0[0] - e1[0];
2691 d0[1] = e0[1] + e1[1];
2692 d0[0] = e0[0] + e1[0];
2693 d1[1] = v41_21*AA[4] - v40_20*AA[5];
2694 d1[0] = v40_20*AA[4] + v41_21*AA[5];
2696 v41_21 = e0[3] - e1[3];
2697 v40_20 = e0[2] - e1[2];
2698 d0[3] = e0[3] + e1[3];
2699 d0[2] = e0[2] + e1[2];
2700 d1[3] = v41_21*AA[0] - v40_20*AA[1];
2701 d1[2] = v40_20*AA[0] + v41_21*AA[1];
2733 for (; l < (ld-3)>>1; ++l) {
2734 int k0 = n >> (l+2), k0_2 = k0>>1;
2735 int lim = 1 << (l+1);
2737 for (i=0; i < lim; ++i)
2741 for (; l < ld-6; ++l) {
2742 int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1;
2743 int rlim = n >> (l+6), r;
2744 int lim = 1 << (l+1);
2748 for (r=rlim; r > 0; --r) {
2767 uint16 *bitrev =
f->bit_reverse[blocktype];
2773 float *d0 = &v[n4-4];
2774 float *d1 = &v[n2-4];
2804 float *
C =
f->C[blocktype];
2811 float a02,a11,b0,b1,b2,b3;
2816 b0 =
C[1]*a02 +
C[0]*a11;
2817 b1 =
C[1]*a11 -
C[0]*a02;
2830 b0 =
C[3]*a02 +
C[2]*a11;
2831 b1 =
C[3]*a11 -
C[2]*a02;
2858 float *d0,*d1,*d2,*d3;
2860 float *
B =
f->B[blocktype] + n2 - 8;
2861 float *e = buf2 + n2 - 8;
2869 p3 = e[6]*
B[7] - e[7]*
B[6];
2870 p2 = -e[6]*
B[6] - e[7]*
B[7];
2877 p1 = e[4]*
B[5] - e[5]*
B[4];
2878 p0 = -e[4]*
B[4] - e[5]*
B[5];
2885 p3 = e[2]*
B[3] - e[3]*
B[2];
2886 p2 = -e[2]*
B[2] - e[3]*
B[3];
2893 p1 = e[0]*
B[1] - e[1]*
B[0];
2894 p0 = -e[0]*
B[0] - e[1]*
B[1];
2916 void inverse_mdct_naive(
float *buffer,
int n)
2919 float A[1 << 12],
B[1 << 12],
C[1 << 11];
2920 int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
2921 int n3_4 = n - n4, ld;
2924 float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13];
2927 for (k=k2=0; k < n4; ++k,k2+=2) {
2928 A[k2 ] = (float) cos(4*k*
M_PI/n);
2929 A[k2+1] = (float) -sin(4*k*
M_PI/n);
2930 B[k2 ] = (float) cos((k2+1)*
M_PI/n/2);
2931 B[k2+1] = (float) sin((k2+1)*
M_PI/n/2);
2933 for (k=k2=0; k < n8; ++k,k2+=2) {
2934 C[k2 ] = (float) cos(2*(k2+1)*
M_PI/n);
2935 C[k2+1] = (float) -sin(2*(k2+1)*
M_PI/n);
2946 for (k=0; k < n2; ++k) u[k] = buffer[k];
2947 for ( ; k < n ; ++k) u[k] = -buffer[n - k - 1];
2950 for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) {
2951 v[n-k4-1] = (u[k4] - u[n-k4-1]) *
A[k2] - (u[k4+2] - u[n-k4-3])*
A[k2+1];
2952 v[n-k4-3] = (u[k4] - u[n-k4-1]) *
A[k2+1] + (u[k4+2] - u[n-k4-3])*
A[k2];
2955 for (k=k4=0; k < n8; k+=1, k4+=4) {
2956 w[n2+3+k4] = v[n2+3+k4] + v[k4+3];
2957 w[n2+1+k4] = v[n2+1+k4] + v[k4+1];
2958 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];
2959 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];
2963 for (l=0; l < ld-3; ++l) {
2964 int k0 = n >> (l+2), k1 = 1 << (l+3);
2965 int rlim = n >> (l+4), r4, r;
2966 int s2lim = 1 << (l+2), s2;
2967 for (r=r4=0; r < rlim; r4+=4,++r) {
2968 for (s2=0; s2 < s2lim; s2+=2) {
2969 u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4];
2970 u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4];
2971 u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) *
A[r*k1]
2972 - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) *
A[r*k1+1];
2973 u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) *
A[r*k1]
2974 + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) *
A[r*k1+1];
2979 memcpy(w, u,
sizeof(u));
2984 for (i=0; i < n8; ++i) {
2996 int i8 = i << 3, j8 = j << 3;
2997 v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1];
2998 v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3];
2999 v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5];
3000 v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7];
3004 for (k=0; k < n2; ++k) {
3008 for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) {
3010 u[n-2-k2] = w[k4+1];
3011 u[n3_4 - 1 - k2] = w[k4+2];
3012 u[n3_4 - 2 - k2] = w[k4+3];
3015 for (k=k2=0; k < n8; ++k, k2 += 2) {
3016 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;
3017 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;
3018 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;
3019 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;
3022 for (k=k2=0; k < n4; ++k,k2 += 2) {
3023 X[k] = v[k2+n2]*
B[k2 ] + v[k2+1+n2]*
B[k2+1];
3024 X[n2-1-k] = v[k2+n2]*
B[k2+1] - v[k2+1+n2]*
B[k2 ];
3036 for (i=0; i < n4 ; ++i) buffer[i] = s * X[i+n4];
3037 for ( ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1];
3038 for ( ; i < n ; ++i) buffer[i] = -s * X[i - n3_4];
3045 if (len ==
f->blocksize_0)
return f->window[0];
3046 if (len ==
f->blocksize_1)
return f->window[1];
3050 #ifndef STB_VORBIS_NO_DEFER_FLOOR
3060 if (
f->floor_types[floor] == 0) {
3063 Floor1 *g = &
f->floor_config[floor].floor1;
3066 for (q=1; q < g->
values; ++q) {
3068 #ifndef STB_VORBIS_NO_DEFER_FLOOR
3075 int hx = g->
Xlist[j];
3084 for (j=lx; j < n2; ++j)
3109 int i, n, prev, next, window_center;
3110 f->channel_buffer_start =
f->channel_buffer_end = 0;
3113 if (
f->eof)
return FALSE;
3124 if (
f->alloc.alloc_buffer)
3125 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3129 if (i >=
f->mode_count)
return FALSE;
3131 m =
f->mode_config + i;
3143 window_center = n >> 1;
3145 *p_left_start = (n -
f->blocksize_0) >> 2;
3146 *p_left_end = (n +
f->blocksize_0) >> 2;
3149 *p_left_end = window_center;
3152 *p_right_start = (n*3 -
f->blocksize_0) >> 2;
3153 *p_right_end = (n*3 +
f->blocksize_0) >> 2;
3155 *p_right_start = window_center;
3166 int zero_channel[256];
3167 int really_zero_channel[256];
3179 for (i=0; i <
f->channels; ++i) {
3181 zero_channel[i] =
FALSE;
3183 if (
f->floor_types[floor] == 0) {
3186 Floor1 *g = &
f->floor_config[floor].floor1;
3189 uint8 step2_flag[256];
3190 static int range_list[4] = { 256, 128, 86, 64 };
3200 int csub = (1 << cbits)-1;
3206 for (k=0; k < cdim; ++k) {
3208 cval = cval >> cbits;
3219 step2_flag[0] = step2_flag[1] = 1;
3220 for (j=2; j < g->
values; ++j) {
3221 int low, high, pred, highroom, lowroom, room, val;
3227 highroom = range - pred;
3229 if (highroom < lowroom)
3230 room = highroom * 2;
3234 step2_flag[low] = step2_flag[high] = 1;
3237 if (highroom > lowroom)
3238 finalY[j] = val - lowroom + pred;
3240 finalY[j] = pred - val + highroom - 1;
3243 finalY[j] = pred - ((val+1)>>1);
3245 finalY[j] = pred + (val>>1);
3252 #ifdef STB_VORBIS_NO_DEFER_FLOOR
3256 for (j=0; j < g->
values; ++j) {
3263 zero_channel[i] =
TRUE;
3273 if (
f->alloc.alloc_buffer)
3274 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3277 memcpy(really_zero_channel, zero_channel,
sizeof(really_zero_channel[0]) *
f->channels);
3285 for (i=0; i < map->
submaps; ++i) {
3288 uint8 do_not_decode[256];
3290 for (j=0; j <
f->channels; ++j) {
3292 if (zero_channel[j]) {
3293 do_not_decode[ch] =
TRUE;
3294 residue_buffers[ch] =
NULL;
3296 do_not_decode[ch] =
FALSE;
3297 residue_buffers[ch] =
f->channel_buffers[j];
3306 if (
f->alloc.alloc_buffer)
3307 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3314 float *a =
f->channel_buffers[map->
chan[i].
angle ];
3315 for (j=0; j < n2; ++j) {
3319 m2 = m[j], a2 = m[j] - a[j];
3321 a2 = m[j], m2 = m[j] + a[j];
3324 m2 = m[j], a2 = m[j] + a[j];
3326 a2 = m[j], m2 = m[j] - a[j];
3334 #ifndef STB_VORBIS_NO_DEFER_FLOOR
3335 for (i=0; i <
f->channels; ++i) {
3336 if (really_zero_channel[i]) {
3337 memset(
f->channel_buffers[i], 0,
sizeof(*
f->channel_buffers[i]) * n2);
3343 for (i=0; i <
f->channels; ++i) {
3344 if (really_zero_channel[i]) {
3345 memset(
f->channel_buffers[i], 0,
sizeof(*
f->channel_buffers[i]) * n2);
3347 for (j=0; j < n2; ++j)
3348 f->channel_buffers[i][j] *=
f->floor_buffers[i][j];
3355 for (i=0; i <
f->channels; ++i)
3363 if (
f->first_decode) {
3368 f->current_loc = -n2;
3371 f->discard_samples_deferred = n - right_end;
3372 f->current_loc_valid =
TRUE;
3374 }
else if (
f->discard_samples_deferred) {
3375 if (
f->discard_samples_deferred >= right_start - left_start) {
3376 f->discard_samples_deferred -= (right_start - left_start);
3377 left_start = right_start;
3378 *p_left = left_start;
3380 left_start +=
f->discard_samples_deferred;
3381 *p_left = left_start;
3382 f->discard_samples_deferred = 0;
3384 }
else if (
f->previous_length == 0 &&
f->current_loc_valid) {
3394 if (
f->last_seg_which ==
f->end_seg_with_known_loc) {
3397 uint32 current_end =
f->known_loc_for_packet;
3399 if (current_end < f->
current_loc + (right_end-left_start)) {
3404 *len = current_end -
f->current_loc;
3407 if (*len > right_end) *len = right_end;
3408 f->current_loc += *len;
3416 f->current_loc =
f->known_loc_for_packet - (n2-left_start);
3417 f->current_loc_valid =
TRUE;
3419 if (
f->current_loc_valid)
3420 f->current_loc += (right_start - left_start);
3422 if (
f->alloc.alloc_buffer)
3423 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3432 int mode, left_end, right_end;
3449 if (
f->previous_length) {
3450 int i,j, n =
f->previous_length;
3452 if (w ==
NULL)
return 0;
3453 for (i=0; i <
f->channels; ++i) {
3454 for (j=0; j < n; ++j)
3455 f->channel_buffers[i][left+j] =
3456 f->channel_buffers[i][left+j]*w[ j] +
3457 f->previous_window[i][ j]*w[n-1-j];
3461 prev =
f->previous_length;
3464 f->previous_length = len - right;
3472 for (i=0; i <
f->channels; ++i)
3473 for (j=0; right+j < len; ++j)
3474 f->previous_window[i][j] =
f->channel_buffers[i][right+j];
3483 if (len < right) right = len;
3485 f->samples_output += right-left;
3487 return right - left;
3492 int len, right, left, res;
3499 #ifndef STB_VORBIS_NO_PUSHDATA_API
3510 int s =
f->next_seg, first =
TRUE;
3514 for (;
s <
f->segment_count; ++
s) {
3515 p +=
f->segments[
s];
3516 if (
f->segments[
s] < 255)
3520 if (
s ==
f->segment_count)
3535 if (
f->previous_length)
3547 for (
s=0;
s < n; ++
s) {
3559 #endif // !STB_VORBIS_NO_PUSHDATA_API
3564 int len,i,j,k, max_submaps = 0;
3565 int longest_floorlist=0;
3568 f->first_decode =
TRUE;
3577 if (
f->segments[0] != 30) {
3579 if (
f->segments[0] == 64 &&
3611 f->blocksize_0 = 1 << log0;
3612 f->blocksize_1 = 1 << log1;
3635 for(i=0; i < len; ++i) {
3638 f->vendor[len] = (char)
'\0';
3641 f->comment_list = (
char**)
setup_malloc(
f,
sizeof(
char*) * (
f->comment_list_length));
3643 for(i=0; i <
f->comment_list_length; ++i) {
3645 f->comment_list[i] = (
char*)
setup_malloc(
f,
sizeof(
char) * (len+1));
3647 for(j=0; j < len; ++j) {
3650 f->comment_list[i][len] = (char)
'\0';
3658 skip(
f,
f->bytes_in_seg);
3659 f->bytes_in_seg = 0;
3664 f->bytes_in_seg = 0;
3670 #ifndef STB_VORBIS_NO_PUSHDATA_API
3692 memset(
f->codebooks, 0,
sizeof(*
f->codebooks) *
f->codebook_count);
3693 for (i=0; i <
f->codebook_count; ++i) {
3695 int ordered, sorted_count;
3721 int current_entry = 0;
3723 while (current_entry < c->entries) {
3724 int limit = c->
entries - current_entry;
3728 memset(lengths + current_entry, current_length, n);
3733 for (j=0; j < c->
entries; ++j) {
3738 if (lengths[j] == 32)
3748 if (c->
entries > (
int)
f->setup_temp_memory_required)
3749 f->setup_temp_memory_required = c->
entries;
3761 sorted_count = total;
3764 #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
3765 for (j=0; j < c->
entries; ++j)
3789 if (size >
f->setup_temp_memory_required)
3790 f->setup_temp_memory_required = size;
3845 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
3847 int len, sparse = c->
sparse;
3857 for (j=0; j < len; ++j) {
3862 float val = mults[off];
3892 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
3905 for (i=0; i < x; ++i) {
3914 for (i=0; i <
f->floor_count; ++i) {
3917 if (
f->floor_types[i] == 0) {
3918 Floor0 *g = &
f->floor_config[i].floor0;
3930 Floor1 *g = &
f->floor_config[i].floor1;
3938 for (j=0; j <= max_class; ++j) {
3963 for (j=0; j < g->
values; ++j) {
3968 for (j=0; j < g->
values-1; ++j)
3969 if (p[j].x == p[j+1].x)
3971 for (j=0; j < g->
values; ++j)
3974 for (j=2; j < g->
values; ++j) {
3981 if (g->
values > longest_floorlist)
3982 longest_floorlist = g->
values;
3990 memset(
f->residue_config, 0,
f->residue_count *
sizeof(
f->residue_config[0]));
3991 for (i=0; i <
f->residue_count; ++i) {
3992 uint8 residue_cascade[64];
4008 residue_cascade[j] = high_bits*8 + low_bits;
4013 for (k=0; k < 8; ++k) {
4014 if (residue_cascade[j] & (1 << k)) {
4027 for (j=0; j <
f->codebooks[r->
classbook].entries; ++j) {
4028 int classwords =
f->codebooks[r->
classbook].dimensions;
4032 for (k=classwords-1; k >= 0; --k) {
4042 memset(
f->mapping, 0,
f->mapping_count *
sizeof(*
f->mapping));
4043 for (i=0; i <
f->mapping_count; ++i) {
4071 for (j=0; j <
f->channels; ++j) {
4077 for (j=0; j <
f->channels; ++j)
4080 for (j=0; j < m->
submaps; ++j) {
4091 for (i=0; i <
f->mode_count; ++i) {
4092 Mode *m =
f->mode_config+i;
4104 f->previous_length = 0;
4106 for (i=0; i <
f->channels; ++i) {
4107 f->channel_buffers[i] = (
float *)
setup_malloc(
f,
sizeof(
float) *
f->blocksize_1);
4108 f->previous_window[i] = (
float *)
setup_malloc(
f,
sizeof(
float) *
f->blocksize_1/2);
4111 memset(
f->channel_buffers[i], 0,
sizeof(
float) *
f->blocksize_1);
4112 #ifdef STB_VORBIS_NO_DEFER_FLOOR
4113 f->floor_buffers[i] = (
float *)
setup_malloc(
f,
sizeof(
float) *
f->blocksize_1/2);
4120 f->blocksize[0] =
f->blocksize_0;
4121 f->blocksize[1] =
f->blocksize_1;
4123 #ifdef STB_VORBIS_DIVIDE_TABLE
4124 if (integer_divide_table[1][1]==0)
4125 for (i=0; i < DIVTAB_NUMER; ++i)
4126 for (j=1; j < DIVTAB_DENOM; ++j)
4127 integer_divide_table[i][j] = i / j;
4134 uint32 imdct_mem = (
f->blocksize_1 *
sizeof(float) >> 1);
4136 int i,max_part_read=0;
4137 for (i=0; i <
f->residue_count; ++i) {
4138 Residue *r =
f->residue_config + i;
4139 unsigned int actual_size =
f->blocksize_1 / 2;
4140 unsigned int limit_r_begin = r->
begin < actual_size ? r->
begin : actual_size;
4141 unsigned int limit_r_end = r->
end < actual_size ? r->
end : actual_size;
4142 int n_read = limit_r_end - limit_r_begin;
4144 if (part_read > max_part_read)
4145 max_part_read = part_read;
4147 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
4148 classify_mem =
f->channels * (
sizeof(
void*) + max_part_read *
sizeof(
uint8 *));
4150 classify_mem =
f->channels * (
sizeof(
void*) + max_part_read *
sizeof(
int *));
4155 f->temp_memory_required = classify_mem;
4156 if (imdct_mem >
f->temp_memory_required)
4157 f->temp_memory_required = imdct_mem;
4161 if (
f->alloc.alloc_buffer) {
4162 assert(
f->temp_offset ==
f->alloc.alloc_buffer_length_in_bytes);
4164 if (
f->setup_offset +
sizeof(*
f) +
f->temp_memory_required > (
unsigned)
f->temp_offset)
4174 if (
f->next_seg == -1) {
4177 f->first_audio_page_offset = 0;
4229 #ifdef STB_VORBIS_NO_DEFER_FLOOR
4234 for (i=0; i < 2; ++i) {
4241 #ifndef STB_VORBIS_NO_STDIO
4248 if (p ==
NULL)
return;
4255 memset(p, 0,
sizeof(*p));
4266 #ifndef STB_VORBIS_NO_STDIO
4274 if (
f->current_loc_valid)
4275 return f->current_loc;
4283 d.channels =
f->channels;
4284 d.sample_rate =
f->sample_rate;
4285 d.setup_memory_required =
f->setup_memory_required;
4286 d.setup_temp_memory_required =
f->setup_temp_memory_required;
4287 d.temp_memory_required =
f->temp_memory_required;
4288 d.max_frame_size =
f->blocksize_1 >> 1;
4295 d.vendor =
f->vendor;
4296 d.comment_list_length =
f->comment_list_length;
4297 d.comment_list =
f->comment_list;
4314 #ifndef STB_VORBIS_NO_PUSHDATA_API
4318 f->previous_length = 0;
4319 f->page_crc_tests = 0;
4320 f->discard_samples_deferred = 0;
4321 f->current_loc_valid =
FALSE;
4323 f->samples_output = 0;
4324 f->channel_buffer_start = 0;
4325 f->channel_buffer_end = 0;
4331 for (i=0; i <
f->page_crc_tests; ++i)
4332 f->scan[i].bytes_done = 0;
4337 if (data_len < 4)
return 0;
4340 for (i=0; i < data_len; ++i) {
4341 if (data[i] == 0x4f) {
4346 if (i+26 >= data_len || i+27+data[i+26] >= data_len) {
4353 len = 27 + data[i+26];
4354 for (j=0; j < data[i+26]; ++j)
4355 len += data[i+27+j];
4358 for (j=0; j < 22; ++j)
4361 for ( ; j < 26; ++j)
4364 n =
f->page_crc_tests++;
4365 f->scan[n].bytes_left = len-j;
4366 f->scan[n].crc_so_far = crc;
4367 f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24);
4370 if (data[i+27+data[i+26]-1] == 255)
4371 f->scan[n].sample_loc = ~0;
4373 f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24);
4374 f->scan[n].bytes_done = i+j;
4383 for (i=0; i <
f->page_crc_tests;) {
4386 int n =
f->scan[i].bytes_done;
4387 int m =
f->scan[i].bytes_left;
4388 if (m > data_len - n) m = data_len - n;
4390 crc =
f->scan[i].crc_so_far;
4391 for (j=0; j < m; ++j)
4393 f->scan[i].bytes_left -= m;
4394 f->scan[i].crc_so_far = crc;
4395 if (
f->scan[i].bytes_left == 0) {
4397 if (
f->scan[i].crc_so_far ==
f->scan[i].goal_crc) {
4400 f->page_crc_tests = -1;
4401 f->previous_length = 0;
4403 f->current_loc =
f->scan[i].sample_loc;
4405 f->current_loc_valid =
f->current_loc != ~0U;
4409 f->scan[i] =
f->scan[--
f->page_crc_tests];
4421 const uint8 *data,
int data_len,
4432 if (
f->page_crc_tests >= 0) {
4437 f->stream = (
uint8 *) data;
4438 f->stream_end = (
uint8 *) data + data_len;
4456 return (
int) (
f->stream - data);
4459 if (
f->previous_length == 0) {
4466 return (
int) (
f->stream - data);
4480 for (i=0; i <
f->channels; ++i)
4481 f->outputs[i] =
f->channel_buffers[i] + left;
4485 *output =
f->outputs;
4486 return (
int) (
f->stream - data);
4490 const unsigned char *data,
int data_len,
4509 *data_used = (int) (
f->stream - data);
4517 #endif // STB_VORBIS_NO_PUSHDATA_API
4521 #ifndef STB_VORBIS_NO_PUSHDATA_API
4522 if (
f->push_mode)
return 0;
4524 if (
USE_MEMORY(
f))
return (
unsigned int) (
f->stream -
f->stream_start);
4525 #ifndef STB_VORBIS_NO_STDIO
4526 return (
unsigned int) (ftell(
f->f) -
f->f_start);
4530 #ifndef STB_VORBIS_NO_PULLDATA_API
4539 if (
f->eof)
return 0;
4545 if (retry_loc - 25 >
f->stream_len)
4548 for (i=1; i < 4; ++i)
4551 if (
f->eof)
return 0;
4554 uint32 i, crc, goal, len;
4555 for (i=0; i < 4; ++i)
4559 if (
f->eof)
return 0;
4560 if (
header[4] != 0)
goto invalid;
4562 for (i=22; i < 26; ++i)
4565 for (i=0; i < 27; ++i)
4568 for (i=0; i <
header[26]; ++i) {
4573 if (len &&
f->eof)
return 0;
4574 for (i=0; i < len; ++i)
4606 #define SAMPLE_unknown 0xffffffff
4633 for (i=0; i <
header[26]; ++i)
4651 unsigned int previous_safe, end;
4654 if (limit_offset >= 65536 && limit_offset-65536 >=
f->first_audio_page_offset)
4655 previous_safe = limit_offset - 65536;
4657 previous_safe =
f->first_audio_page_offset;
4677 int i, start_seg_with_known_loc, end_pos, page_start;
4678 uint32 delta, stream_length, padding, last_sample_limit;
4679 double offset = 0.0, bytes_per_sample = 0.0;
4690 padding = ((
f->blocksize_1 -
f->blocksize_0) >> 2);
4691 if (sample_number < padding)
4692 last_sample_limit = 0;
4694 last_sample_limit = sample_number - padding;
4709 if (
f->current_loc > sample_number)
4720 if (delta <= 65536) {
4734 if (error < 0 && error > -8000)
error = -8000;
4735 offset +=
error * 2;
4765 if (probe >= 2 || delta <= 65536)
4781 end_pos =
f->end_seg_with_known_loc;
4782 assert(end_pos >= 0);
4785 for (i = end_pos; i > 0; --i)
4786 if (
f->segments[i-1] != 255)
4789 start_seg_with_known_loc = i;
4800 end_pos =
f->segment_count - 1;
4804 f->current_loc_valid =
FALSE;
4807 f->packet_bytes = 0;
4808 f->bytes_in_seg = 0;
4809 f->previous_length = 0;
4810 f->next_seg = start_seg_with_known_loc;
4812 for (i = 0; i < start_seg_with_known_loc; i++)
4818 if (
f->current_loc > sample_number)
4831 int bits_read, bytes_read;
4837 bits_read = 1 +
ilog(
f->mode_count-1);
4838 if (
f->mode_config[*mode].blockflag)
4840 bytes_read = (bits_read + 7) / 8;
4842 f->bytes_in_seg += bytes_read;
4843 f->packet_bytes -= bytes_read;
4844 skip(
f, -bytes_read);
4845 if (
f->next_seg == -1)
4846 f->next_seg =
f->segment_count - 1;
4856 uint32 max_frame_samples;
4864 assert(
f->current_loc_valid);
4865 assert(
f->current_loc <= sample_number);
4868 max_frame_samples = (
f->blocksize_1*3 -
f->blocksize_0) >> 2;
4869 while (
f->current_loc < sample_number) {
4870 int left_start, left_end, right_start, right_end, mode, frame_samples;
4874 frame_samples = right_start - left_start;
4875 if (
f->current_loc + frame_samples > sample_number) {
4877 }
else if (
f->current_loc + frame_samples + max_frame_samples > sample_number) {
4882 f->current_loc += frame_samples;
4883 f->previous_length = 0;
4898 if (sample_number !=
f->current_loc) {
4900 uint32 frame_start =
f->current_loc;
4902 assert(sample_number > frame_start);
4903 assert(
f->channel_buffer_start + (
int) (sample_number-frame_start) <=
f->channel_buffer_end);
4904 f->channel_buffer_start += (sample_number - frame_start);
4914 f->previous_length = 0;
4915 f->first_decode =
TRUE;
4922 unsigned int restore_offset, previous_safe;
4923 unsigned int end, last_page_loc;
4926 if (!
f->total_samples) {
4936 if (
f->stream_len >= 65536 &&
f->stream_len-65536 >=
f->first_audio_page_offset)
4937 previous_safe =
f->stream_len - 65536;
4939 previous_safe =
f->first_audio_page_offset;
4948 f->total_samples = 0xffffffff;
4965 previous_safe = last_page_loc+1;
4976 if (lo == 0xffffffff && hi == 0xffffffff) {
4983 f->total_samples = lo;
4985 f->p_last.page_start = last_page_loc;
4986 f->p_last.page_end = end;
4987 f->p_last.last_decoded_sample = lo;
5004 int len, right,left,i;
5008 f->channel_buffer_start =
f->channel_buffer_end = 0;
5013 for (i=0; i <
f->channels; ++i)
5014 f->outputs[i] =
f->channel_buffers[i] + left;
5016 f->channel_buffer_start = left;
5017 f->channel_buffer_end = left+len;
5020 if (output) *output =
f->outputs;
5024 #ifndef STB_VORBIS_NO_STDIO
5049 unsigned int len,
start;
5050 start = (
unsigned int) ftell(file);
5051 fseek(file, 0, SEEK_END);
5052 len = (
unsigned int) (ftell(file) -
start);
5053 fseek(file,
start, SEEK_SET);
5060 #if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)
5061 if (0 != fopen_s(&
f, filename,
"rb"))
5064 f = fopen(filename,
"rb");
5071 #endif // STB_VORBIS_NO_STDIO
5097 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
5098 #define PLAYBACK_MONO 1
5099 #define PLAYBACK_LEFT 2
5100 #define PLAYBACK_RIGHT 4
5102 #define L (PLAYBACK_LEFT | PLAYBACK_MONO)
5103 #define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO)
5104 #define R (PLAYBACK_RIGHT | PLAYBACK_MONO)
5118 #ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
5124 #define FASTDEF(x) float_conv x
5126 #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))
5127 #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))
5128 #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))
5129 #define check_endianness()
5131 #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))
5132 #define check_endianness()
5140 for (i=0; i < len; ++i) {
5143 if ((
unsigned int) (v + 32768) > 65535)
5144 v = v < 0 ? -32768 : 32767;
5149 static void compute_samples(
int mask,
short *output,
int num_c,
float **data,
int d_offset,
int len)
5151 #define BUFFER_SIZE 32
5156 memset(buffer, 0,
sizeof(buffer));
5157 if (o + n > len) n = len - o;
5158 for (j=0; j < num_c; ++j) {
5160 for (i=0; i < n; ++i)
5161 buffer[i] += data[j][d_offset+o+i];
5164 for (i=0; i < n; ++i) {
5167 if ((
unsigned int) (v + 32768) > 65535)
5168 v = v < 0 ? -32768 : 32767;
5176 #define BUFFER_SIZE 32
5181 for (o = 0; o < len; o += BUFFER_SIZE >> 1) {
5184 memset(buffer, 0,
sizeof(buffer));
5185 if (o + n > len) n = len - o;
5186 for (j=0; j < num_c; ++j) {
5189 for (i=0; i < n; ++i) {
5190 buffer[i*2+0] += data[j][d_offset+o+i];
5191 buffer[i*2+1] += data[j][d_offset+o+i];
5194 for (i=0; i < n; ++i) {
5195 buffer[i*2+0] += data[j][d_offset+o+i];
5198 for (i=0; i < n; ++i) {
5199 buffer[i*2+1] += data[j][d_offset+o+i];
5203 for (i=0; i < (n<<1); ++i) {
5206 if ((
unsigned int) (v + 32768) > 65535)
5207 v = v < 0 ? -32768 : 32767;
5213 static void convert_samples_short(
int buf_c,
short **buffer,
int b_offset,
int data_c,
float **data,
int d_offset,
int samples)
5216 if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
5218 for (i=0; i < buf_c; ++i)
5219 compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples);
5221 int limit = buf_c < data_c ? buf_c : data_c;
5222 for (i=0; i < limit; ++i)
5223 copy_samples(buffer[i]+b_offset, data[i]+d_offset, samples);
5224 for ( ; i < buf_c; ++i)
5225 memset(buffer[i]+b_offset, 0,
sizeof(
short) * samples);
5231 float **output =
NULL;
5233 if (len > num_samples) len = num_samples;
5243 if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
5245 for (i=0; i < buf_c; ++i)
5248 int limit = buf_c < data_c ? buf_c : data_c;
5250 for (j=0; j < len; ++j) {
5251 for (i=0; i < limit; ++i) {
5253 float f = data[i][d_offset+j];
5255 if ((
unsigned int) (v + 32768) > 65535)
5256 v = v < 0 ? -32768 : 32767;
5259 for ( ; i < buf_c; ++i)
5272 if (len*num_c > num_shorts) len = num_shorts / num_c;
5281 int len = num_shorts / channels;
5283 int z =
f->channels;
5284 if (z > channels) z = channels;
5286 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5287 if (n+k >= len) k = len - n;
5290 buffer += k*channels;
5292 f->channel_buffer_start += k;
5293 if (n == len)
break;
5303 int z =
f->channels;
5304 if (z > channels) z = channels;
5306 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5307 if (n+k >= len) k = len - n;
5311 f->channel_buffer_start += k;
5312 if (n == len)
break;
5318 #ifndef STB_VORBIS_NO_STDIO
5321 int data_len, offset, total, limit,
error;
5324 if (v ==
NULL)
return -1;
5329 offset = data_len = 0;
5331 data = (
short *) malloc(total *
sizeof(*data));
5341 if (offset + limit > total) {
5344 data2 = (
short *) realloc(data, total *
sizeof(*data));
5345 if (data2 ==
NULL) {
5361 int data_len, offset, total, limit,
error;
5364 if (v ==
NULL)
return -1;
5369 offset = data_len = 0;
5371 data = (
short *) malloc(total *
sizeof(*data));
5381 if (offset + limit > total) {
5384 data2 = (
short *) realloc(data, total *
sizeof(*data));
5385 if (data2 ==
NULL) {
5397 #endif // STB_VORBIS_NO_INTEGER_CONVERSION
5402 int len = num_floats / channels;
5404 int z =
f->channels;
5405 if (z > channels) z = channels;
5408 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5409 if (n+k >= len) k = len - n;
5410 for (j=0; j < k; ++j) {
5411 for (i=0; i < z; ++i)
5412 *buffer++ =
f->channel_buffers[i][
f->channel_buffer_start+j];
5413 for ( ; i < channels; ++i)
5417 f->channel_buffer_start += k;
5430 int z =
f->channels;
5431 if (z > channels) z = channels;
5432 while (n < num_samples) {
5434 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5435 if (n+k >= num_samples) k = num_samples - n;
5437 for (i=0; i < z; ++i)
5438 memcpy(buffer[i]+n,
f->channel_buffers[i]+
f->channel_buffer_start,
sizeof(
float)*k);
5439 for ( ; i < channels; ++i)
5440 memset(buffer[i]+n, 0,
sizeof(
float) * k);
5443 f->channel_buffer_start += k;
5444 if (n == num_samples)
5451 #endif // STB_VORBIS_NO_PULLDATA_API
5514 #endif // STB_VORBIS_HEADER_ONLY