73 #ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H
74 #define STB_VORBIS_INCLUDE_STB_VORBIS_H
76 #if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
77 #define STB_VORBIS_NO_STDIO 1
80 #ifndef STB_VORBIS_NO_STDIO
120 int alloc_buffer_length_in_bytes;
173 #ifndef STB_VORBIS_NO_PUSHDATA_API
183 const unsigned char * datablock,
int datablock_length_in_bytes,
184 int *datablock_memory_consumed_in_bytes,
198 const unsigned char *datablock,
int datablock_length_in_bytes,
242 #ifndef STB_VORBIS_NO_PULLDATA_API
250 #if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
253 #if !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
266 #ifndef STB_VORBIS_NO_STDIO
317 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
353 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
407 #endif // STB_VORBIS_INCLUDE_STB_VORBIS_H
413 #ifndef STB_VORBIS_HEADER_ONLY
453 #ifndef STB_VORBIS_MAX_CHANNELS
454 #define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone?
469 #ifndef STB_VORBIS_PUSHDATA_CRC_COUNT
470 #define STB_VORBIS_PUSHDATA_CRC_COUNT 4
478 #ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH
479 #define STB_VORBIS_FAST_HUFFMAN_LENGTH 10
492 #ifndef STB_VORBIS_FAST_HUFFMAN_INT
493 #define STB_VORBIS_FAST_HUFFMAN_SHORT
520 #ifdef STB_VORBIS_CODEBOOK_SHORTS
521 #error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats"
545 #ifdef STB_VORBIS_NO_PULLDATA_API
546 #define STB_VORBIS_NO_INTEGER_CONVERSION
547 #define STB_VORBIS_NO_STDIO
550 #if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
551 #define STB_VORBIS_NO_STDIO 1
554 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
555 #ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
560 #ifndef STB_VORBIS_BIG_ENDIAN
561 #define STB_VORBIS_ENDIAN 0
563 #define STB_VORBIS_ENDIAN 1
570 #ifndef STB_VORBIS_NO_STDIO
574 #ifndef STB_VORBIS_NO_CRT
581 #if defined(_MSC_VER) || defined(__MINGW32__)
584 #if defined(__linux__) || defined(__linux) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)
587 #else // STB_VORBIS_NO_CRT
590 #define free(s) ((void) 0)
592 #endif // STB_VORBIS_NO_CRT
605 #define __forceinline
607 #define alloca __builtin_alloca
609 #elif !defined(_MSC_VER)
611 #define __forceinline inline
613 #define __forceinline
617 #if STB_VORBIS_MAX_CHANNELS > 256
618 #error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range"
621 #if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24
622 #error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range"
628 #define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1])
630 #define CHECK(f) ((void) 0)
633 #define MAX_BLOCKSIZE_LOG 13 // from specification
634 #define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG)
664 #define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)
665 #define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1)
669 int dimensions, entries;
670 uint8 *codeword_lengths;
680 #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
695 uint8 amplitude_bits;
696 uint8 amplitude_offset;
697 uint8 number_of_books;
704 uint8 partition_class_list[32];
705 uint8 class_dimensions[16];
706 uint8 class_subclasses[16];
707 uint8 class_masterbooks[16];
708 int16 subclass_books[16][8];
710 uint8 sorted_order[31*8+2];
712 uint8 floor1_multiplier;
727 uint8 classifications;
730 int16 (*residue_books)[8];
745 uint8 submap_floor[15];
746 uint8 submap_residue[15];
768 uint32 page_start, page_end;
769 uint32 last_decoded_sample;
787 #ifndef STB_VORBIS_NO_STDIO
844 #ifndef STB_VORBIS_NO_DEFER_FLOOR
856 float *
A[2],*
B[2],*
C[2];
881 #ifndef STB_VORBIS_NO_PUSHDATA_API
890 #if defined(STB_VORBIS_NO_PUSHDATA_API)
891 #define IS_PUSH_MODE(f) FALSE
892 #elif defined(STB_VORBIS_NO_PULLDATA_API)
893 #define IS_PUSH_MODE(f) TRUE
895 #define IS_PUSH_MODE(f) ((f)->push_mode)
915 #define array_size_required(count,size) (count*(sizeof(void *)+(size)))
917 #define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))
918 #define temp_free(f,p) (void)0
919 #define temp_alloc_save(f) ((f)->temp_offset)
920 #define temp_alloc_restore(f,p) ((f)->temp_offset = (p))
922 #define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)
928 void ** p = (
void **) mem;
929 char *q = (
char *) (p +
count);
930 for (i=0; i <
count; ++i) {
940 f->setup_memory_required += sz;
941 if (
f->alloc.alloc_buffer) {
942 void *p = (
char *)
f->alloc.alloc_buffer +
f->setup_offset;
943 if (
f->setup_offset + sz >
f->temp_offset)
return NULL;
944 f->setup_offset += sz;
947 return sz ? malloc(sz) :
NULL;
952 if (
f->alloc.alloc_buffer)
return;
959 if (
f->alloc.alloc_buffer) {
961 f->temp_offset -= sz;
962 return (
char *)
f->alloc.alloc_buffer +
f->temp_offset;
969 if (
f->alloc.alloc_buffer) {
970 f->temp_offset += (sz+7)&~7;
976 #define CRC32_POLY 0x04c11db7 // from spec
983 for(i=0; i < 256; i++) {
984 for (
s=(
uint32) i << 24, j=0; j < 8; ++j)
992 return (crc << 8) ^
crc_table[
byte ^ (crc >> 24)];
999 n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1);
1000 n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2);
1001 n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4);
1002 n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8);
1003 return (n >> 16) | (n << 16);
1016 static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 };
1018 if (n < 0)
return 0;
1022 if (n < (1 << 4))
return 0 + log2_4[n ];
1023 else if (n < (1 << 9))
return 5 + log2_4[n >> 5];
1024 else return 10 + log2_4[n >> 10];
1025 else if (n < (1 << 24))
1026 if (n < (1 << 19))
return 15 + log2_4[n >> 15];
1027 else return 20 + log2_4[n >> 20];
1028 else if (n < (1 << 29))
return 25 + log2_4[n >> 25];
1029 else return 30 + log2_4[n >> 30];
1033 #define M_PI 3.14159265358979323846264f // from CRC
1047 uint32 mantissa = x & 0x1fffff;
1048 uint32 sign = x & 0x80000000;
1049 uint32 exp = (x & 0x7fe00000) >> 21;
1050 double res = sign ? -(double)mantissa : (
double)mantissa;
1051 return (
float) ldexp((
float)res, exp-788);
1069 values [
count] = symbol;
1078 memset(available, 0,
sizeof(available));
1080 for (k=0; k < n; ++k)
if (len[k] <
NO_CODE)
break;
1083 add_entry(c, 0, k, m++, len[k], values);
1085 for (i=1; i <= len[k]; ++i)
1086 available[i] = 1U << (32-i);
1091 for (i=k+1; i < n; ++i) {
1101 while (z > 0 && !available[z]) --z;
1102 if (z == 0) {
return FALSE; }
1104 assert(z >= 0 && z < 32);
1109 assert(len[i] >= 0 && len[i] < 32);
1110 for (y=len[i]; y > z; --y) {
1111 assert(available[y] == 0);
1112 available[y] = res + (1 << (32-y));
1129 if (len > 32767) len = 32767;
1131 for (i=0; i < len; ++i) {
1144 #define STBV_CDECL __cdecl
1153 return x < y ? -1 : x > y;
1175 for (i=0; i < c->
entries; ++i)
1193 for (i=0; i < len; ++i) {
1194 int huff_len = c->
sparse ? lengths[values[i]] : lengths[i];
1200 int m = x + (n >> 1);
1222 static uint8 vorbis[6] = {
'v',
'o',
'r',
'b',
'i',
's' };
1223 return memcmp(data, vorbis, 6) == 0;
1230 int r = (int) floor(exp((
float)
log((
float) entries) / dim));
1231 if ((
int) floor(pow((
float) r+1, dim)) <= entries)
1233 if (pow((
float) r+1, dim) <= entries)
1235 if ((
int) floor(pow((
float) r, dim)) > entries)
1243 int n4 = n >> 2, n8 = n >> 3;
1246 for (k=k2=0; k < n4; ++k,k2+=2) {
1247 A[k2 ] = (float) cos(4*k*
M_PI/n);
1248 A[k2+1] = (float) -sin(4*k*
M_PI/n);
1249 B[k2 ] = (float) cos((k2+1)*
M_PI/n/2) * 0.5
f;
1250 B[k2+1] = (float) sin((k2+1)*
M_PI/n/2) * 0.5
f;
1252 for (k=k2=0; k < n8; ++k,k2+=2) {
1253 C[k2 ] = (float) cos(2*(k2+1)*
M_PI/n);
1254 C[k2+1] = (float) -sin(2*(k2+1)*
M_PI/n);
1261 for (i=0; i < n2; ++i)
1267 int ld =
ilog(n) - 1;
1269 for (i=0; i < n8; ++i)
1275 int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3;
1295 for (i=0; i < n; ++i) {
1296 if (x[i] > low && x[i] < x[n]) { *plow = i; low = x[i]; }
1297 if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; }
1311 return a->
x < b->
x ? -1 : a->
x > b->
x;
1318 #if defined(STB_VORBIS_NO_STDIO)
1319 #define USE_MEMORY(z) TRUE
1321 #define USE_MEMORY(z) ((z)->stream)
1331 #ifndef STB_VORBIS_NO_STDIO
1333 int c = fgetc(z->
f);
1334 if (c == EOF) { z->
eof =
TRUE;
return 0; }
1354 memcpy(data, z->
stream, n);
1359 #ifndef STB_VORBIS_NO_STDIO
1360 if (fread(data, n, 1, z->
f) == 1)
1376 #ifndef STB_VORBIS_NO_STDIO
1378 long x = ftell(z->
f);
1379 fseek(z->
f, x+n, SEEK_SET);
1386 #ifndef STB_VORBIS_NO_PUSHDATA_API
1387 if (
f->push_mode)
return 0;
1391 if (
f->stream_start + loc >=
f->stream_end ||
f->stream_start + loc < f->
stream_start) {
1392 f->stream =
f->stream_end;
1396 f->stream =
f->stream_start + loc;
1400 #ifndef STB_VORBIS_NO_STDIO
1401 if (loc +
f->f_start < loc || loc >= 0x80000000) {
1407 if (!fseek(
f->f, loc, SEEK_SET))
1410 fseek(
f->f,
f->f_start, SEEK_END);
1427 #define PAGEFLAG_continued_packet 1
1428 #define PAGEFLAG_first_page 2
1429 #define PAGEFLAG_last_page 4
1454 f->segment_count =
get8(
f);
1455 if (!
getn(
f,
f->segments,
f->segment_count))
1458 f->end_seg_with_known_loc = -2;
1459 if (loc0 != ~0U || loc1 != ~0U) {
1462 for (i=
f->segment_count-1; i >= 0; --i)
1463 if (
f->segments[i] < 255)
1467 f->end_seg_with_known_loc = i;
1468 f->known_loc_for_packet = loc0;
1471 if (
f->first_decode) {
1474 for (i=0; i <
f->segment_count; ++i)
1475 len +=
f->segments[i];
1476 len += 27 +
f->segment_count;
1477 f->p_first.page_end =
f->p_first.page_start + len;
1478 f->p_first.last_decoded_sample = loc0;
1492 while (
f->next_seg == -1) {
1499 f->packet_bytes = 0;
1500 f->bytes_in_seg = 0;
1507 if (
f->next_seg == -1) {
1509 if (
f->eof)
return FALSE;
1519 f->bytes_in_seg = 0;
1529 if (
f->last_seg)
return 0;
1530 if (
f->next_seg == -1) {
1531 f->last_seg_which =
f->segment_count-1;
1535 len =
f->segments[
f->next_seg++];
1538 f->last_seg_which =
f->next_seg-1;
1540 if (
f->next_seg >=
f->segment_count)
1542 assert(
f->bytes_in_seg == 0);
1543 f->bytes_in_seg = len;
1548 #define INVALID_BITS (-1)
1552 if (!
f->bytes_in_seg) {
1553 if (
f->last_seg)
return EOP;
1556 assert(
f->bytes_in_seg > 0);
1590 if (
f->valid_bits < 0)
return 0;
1591 if (
f->valid_bits < n) {
1598 if (
f->valid_bits == 0)
f->acc = 0;
1599 while (
f->valid_bits < n) {
1605 f->acc += z <<
f->valid_bits;
1610 assert(
f->valid_bits >= n);
1611 z =
f->acc & ((1 << n)-1);
1623 if (
f->valid_bits <= 24) {
1624 if (
f->valid_bits == 0)
f->acc = 0;
1627 if (
f->last_seg && !
f->bytes_in_seg)
return;
1629 if (z ==
EOP)
return;
1630 f->acc += (unsigned) z <<
f->valid_bits;
1632 }
while (
f->valid_bits <= 24);
1660 int m = x + (n >> 1);
1672 if (
f->valid_bits >= len) {
1674 f->valid_bits -= len;
1684 for (i=0; i < c->
entries; ++i) {
1702 #ifndef STB_VORBIS_NO_INLINE_DECODE
1704 #define DECODE_RAW(var, f,c) \
1705 if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) \
1707 var = f->acc & FAST_HUFFMAN_TABLE_MASK; \
1708 var = c->fast_huffman[var]; \
1710 int n = c->codeword_lengths[var]; \
1712 f->valid_bits -= n; \
1713 if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \
1715 var = codebook_decode_scalar_raw(f,c); \
1731 if (
f->valid_bits < 0) {
f->valid_bits = 0;
return -1; }
1737 #define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c);
1741 #define DECODE(var,f,c) \
1742 DECODE_RAW(var,f,c) \
1743 if (c->sparse) var = c->sorted_values[var];
1745 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
1746 #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c)
1748 #define DECODE_VQ(var,f,c) DECODE(var,f,c)
1758 #define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off])
1759 #define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off])
1760 #define CODEBOOK_ELEMENT_BASE(c) (0)
1771 if (c->
sparse) assert(z < c->sorted_entries);
1773 if (!
f->bytes_in_seg)
1785 if (z < 0)
return FALSE;
1788 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
1792 for (i=0; i < len; ++i) {
1806 for (i=0; i < len; ++i) {
1813 for (i=0; i < len; ++i) {
1825 if (z < 0)
return FALSE;
1828 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
1831 for (i=0; i < len; ++i) {
1834 output[i*step] += val;
1843 for (i=0; i < len; ++i) {
1845 output[i*step] += val;
1854 int c_inter = *c_inter_p;
1855 int p_inter = *p_inter_p;
1861 while (total_decode > 0) {
1864 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
1865 assert(!c->
sparse || z < c->sorted_entries);
1868 if (!
f->bytes_in_seg)
1869 if (
f->last_seg)
return FALSE;
1877 if (c_inter + p_inter*ch + effective > len * ch) {
1878 effective = len*ch - (p_inter*ch - c_inter);
1881 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
1884 for (i=0; i < effective; ++i) {
1888 outputs[c_inter][p_inter] += val;
1889 if (++c_inter == ch) { c_inter = 0; ++p_inter; }
1898 for (i=0; i < effective; ++i) {
1901 outputs[c_inter][p_inter] += val;
1902 if (++c_inter == ch) { c_inter = 0; ++p_inter; }
1906 for (i=0; i < effective; ++i) {
1909 outputs[c_inter][p_inter] += val;
1910 if (++c_inter == ch) { c_inter = 0; ++p_inter; }
1915 total_decode -= effective;
1917 *c_inter_p = c_inter;
1918 *p_inter_p = p_inter;
1927 int err = abs(dy) * (x - x0);
1928 int off = err / adx;
1929 return dy < 0 ? y0 - off : y0 + off;
1935 1.0649863e-07
f, 1.1341951e-07
f, 1.2079015e-07
f, 1.2863978e-07
f,
1936 1.3699951e-07
f, 1.4590251e-07
f, 1.5538408e-07
f, 1.6548181e-07
f,
1937 1.7623575e-07
f, 1.8768855e-07
f, 1.9988561e-07
f, 2.1287530e-07
f,
1938 2.2670913e-07
f, 2.4144197e-07
f, 2.5713223e-07
f, 2.7384213e-07
f,
1939 2.9163793e-07
f, 3.1059021e-07
f, 3.3077411e-07
f, 3.5226968e-07
f,
1940 3.7516214e-07
f, 3.9954229e-07
f, 4.2550680e-07
f, 4.5315863e-07
f,
1941 4.8260743e-07
f, 5.1396998e-07
f, 5.4737065e-07
f, 5.8294187e-07
f,
1942 6.2082472e-07
f, 6.6116941e-07
f, 7.0413592e-07
f, 7.4989464e-07
f,
1943 7.9862701e-07
f, 8.5052630e-07
f, 9.0579828e-07
f, 9.6466216e-07
f,
1944 1.0273513e-06
f, 1.0941144e-06
f, 1.1652161e-06
f, 1.2409384e-06
f,
1945 1.3215816e-06
f, 1.4074654e-06
f, 1.4989305e-06
f, 1.5963394e-06
f,
1946 1.7000785e-06
f, 1.8105592e-06
f, 1.9282195e-06
f, 2.0535261e-06
f,
1947 2.1869758e-06
f, 2.3290978e-06
f, 2.4804557e-06
f, 2.6416497e-06
f,
1948 2.8133190e-06
f, 2.9961443e-06
f, 3.1908506e-06
f, 3.3982101e-06
f,
1949 3.6190449e-06
f, 3.8542308e-06
f, 4.1047004e-06
f, 4.3714470e-06
f,
1950 4.6555282e-06
f, 4.9580707e-06
f, 5.2802740e-06
f, 5.6234160e-06
f,
1951 5.9888572e-06
f, 6.3780469e-06
f, 6.7925283e-06
f, 7.2339451e-06
f,
1952 7.7040476e-06
f, 8.2047000e-06
f, 8.7378876e-06
f, 9.3057248e-06
f,
1953 9.9104632e-06
f, 1.0554501e-05
f, 1.1240392e-05
f, 1.1970856e-05
f,
1954 1.2748789e-05
f, 1.3577278e-05
f, 1.4459606e-05
f, 1.5399272e-05
f,
1955 1.6400004e-05
f, 1.7465768e-05
f, 1.8600792e-05
f, 1.9809576e-05
f,
1956 2.1096914e-05
f, 2.2467911e-05
f, 2.3928002e-05
f, 2.5482978e-05
f,
1957 2.7139006e-05
f, 2.8902651e-05
f, 3.0780908e-05
f, 3.2781225e-05
f,
1958 3.4911534e-05
f, 3.7180282e-05
f, 3.9596466e-05
f, 4.2169667e-05
f,
1959 4.4910090e-05
f, 4.7828601e-05
f, 5.0936773e-05
f, 5.4246931e-05
f,
1960 5.7772202e-05
f, 6.1526565e-05
f, 6.5524908e-05
f, 6.9783085e-05
f,
1961 7.4317983e-05
f, 7.9147585e-05
f, 8.4291040e-05
f, 8.9768747e-05
f,
1962 9.5602426e-05
f, 0.00010181521f, 0.00010843174f, 0.00011547824f,
1963 0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f,
1964 0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f,
1965 0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f,
1966 0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f,
1967 0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f,
1968 0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f,
1969 0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f,
1970 0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f,
1971 0.00092223983f, 0.00098217216f, 0.0010459992f, 0.0011139742f,
1972 0.0011863665f, 0.0012634633f, 0.0013455702f, 0.0014330129f,
1973 0.0015261382f, 0.0016253153f, 0.0017309374f, 0.0018434235f,
1974 0.0019632195f, 0.0020908006f, 0.0022266726f, 0.0023713743f,
1975 0.0025254795f, 0.0026895994f, 0.0028643847f, 0.0030505286f,
1976 0.0032487691f, 0.0034598925f, 0.0036847358f, 0.0039241906f,
1977 0.0041792066f, 0.0044507950f, 0.0047400328f, 0.0050480668f,
1978 0.0053761186f, 0.0057254891f, 0.0060975636f, 0.0064938176f,
1979 0.0069158225f, 0.0073652516f, 0.0078438871f, 0.0083536271f,
1980 0.0088964928f, 0.009474637f, 0.010090352f, 0.010746080f,
1981 0.011444421f, 0.012188144f, 0.012980198f, 0.013823725f,
1982 0.014722068f, 0.015678791f, 0.016697687f, 0.017782797f,
1983 0.018938423f, 0.020169149f, 0.021479854f, 0.022875735f,
1984 0.024362330f, 0.025945531f, 0.027631618f, 0.029427276f,
1985 0.031339626f, 0.033376252f, 0.035545228f, 0.037855157f,
1986 0.040315199f, 0.042935108f, 0.045725273f, 0.048696758f,
1987 0.051861348f, 0.055231591f, 0.058820850f, 0.062643361f,
1988 0.066714279f, 0.071049749f, 0.075666962f, 0.080584227f,
1989 0.085821044f, 0.091398179f, 0.097337747f, 0.10366330f,
1990 0.11039993f, 0.11757434f, 0.12521498f, 0.13335215f,
1991 0.14201813f, 0.15124727f, 0.16107617f, 0.17154380f,
1992 0.18269168f, 0.19456402f, 0.20720788f, 0.22067342f,
1993 0.23501402f, 0.25028656f, 0.26655159f, 0.28387361f,
1994 0.30232132f, 0.32196786f, 0.34289114f, 0.36517414f,
1995 0.38890521f, 0.41417847f, 0.44109412f, 0.46975890f,
1996 0.50028648f, 0.53279791f, 0.56742212f, 0.60429640f,
1997 0.64356699f, 0.68538959f, 0.72993007f, 0.77736504f,
1998 0.82788260f, 0.88168307f, 0.9389798f, 1.0f
2009 #ifndef STB_VORBIS_NO_DEFER_FLOOR
2010 #define LINE_OP(a,b) a *= b
2012 #define LINE_OP(a,b) a = b
2015 #ifdef STB_VORBIS_DIVIDE_TABLE
2016 #define DIVTAB_NUMER 32
2017 #define DIVTAB_DENOM 64
2018 int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM];
2031 #ifdef STB_VORBIS_DIVIDE_TABLE
2032 if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) {
2034 base = -integer_divide_table[ady][adx];
2037 base = integer_divide_table[ady][adx];
2054 ady -= abs(base) * adx;
2058 for (++x; x < x1; ++x) {
2075 for (k=0; k < step; ++k)
2079 for (k=0; k < n; ) {
2094 Residue *r =
f->residue_config + rn;
2095 int rtype =
f->residue_types[rn];
2097 int classwords =
f->codebooks[c].dimensions;
2098 unsigned int actual_size = rtype == 2 ? n*2 : n;
2099 unsigned int limit_r_begin = (r->
begin < actual_size ? r->
begin : actual_size);
2100 unsigned int limit_r_end = (r->
end < actual_size ? r->
end : actual_size);
2101 int n_read = limit_r_end - limit_r_begin;
2104 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2107 int **classifications = (
int **)
temp_block_array(
f,
f->channels, part_read *
sizeof(**classifications));
2112 for (i=0; i < ch; ++i)
2113 if (!do_not_decode[i])
2114 memset(residue_buffers[i], 0,
sizeof(
float) * n);
2116 if (rtype == 2 && ch != 1) {
2117 for (j=0; j < ch; ++j)
2118 if (!do_not_decode[j])
2123 for (pass=0; pass < 8; ++pass) {
2124 int pcount = 0, class_set = 0;
2126 while (pcount < part_read) {
2128 int c_inter = (z & 1), p_inter = z>>1;
2133 if (q ==
EOP)
goto done;
2134 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2135 part_classdata[0][class_set] = r->
classdata[q];
2137 for (i=classwords-1; i >= 0; --i) {
2143 for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
2145 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2146 int c = part_classdata[0][class_set][i];
2148 int c = classifications[0][pcount];
2153 #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
2167 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2171 }
else if (ch > 2) {
2172 while (pcount < part_read) {
2174 int c_inter = z % ch, p_inter = z/ch;
2179 if (q ==
EOP)
goto done;
2180 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2181 part_classdata[0][class_set] = r->
classdata[q];
2183 for (i=classwords-1; i >= 0; --i) {
2189 for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
2191 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2192 int c = part_classdata[0][class_set][i];
2194 int c = classifications[0][pcount];
2207 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2217 for (pass=0; pass < 8; ++pass) {
2218 int pcount = 0, class_set=0;
2219 while (pcount < part_read) {
2221 for (j=0; j < ch; ++j) {
2222 if (!do_not_decode[j]) {
2226 if (temp ==
EOP)
goto done;
2227 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2228 part_classdata[j][class_set] = r->
classdata[temp];
2230 for (i=classwords-1; i >= 0; --i) {
2238 for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
2239 for (j=0; j < ch; ++j) {
2240 if (!do_not_decode[j]) {
2241 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2242 int c = part_classdata[j][class_set][i];
2244 int c = classifications[j][pcount];
2248 float *target = residue_buffers[j];
2258 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2265 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
2276 void inverse_mdct_slow(
float *buffer,
int n)
2280 float *x = (
float *) malloc(
sizeof(*x) * n2);
2281 memcpy(x, buffer,
sizeof(*x) * n2);
2282 for (i=0; i < n; ++i) {
2284 for (j=0; j < n2; ++j)
2292 acc += x[j] * (
float) cos(
M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1));
2299 void inverse_mdct_slow(
float *buffer,
int n,
vorb *
f,
int blocktype)
2303 int n2 = n >> 1, nmask = (n << 2) -1;
2304 float *x = (
float *) malloc(
sizeof(*x) * n2);
2305 memcpy(x, buffer,
sizeof(*x) * n2);
2306 for (i=0; i < 4*n; ++i)
2307 mcos[i] = (
float) cos(
M_PI / 2 * i / n);
2309 for (i=0; i < n; ++i) {
2311 for (j=0; j < n2; ++j)
2312 acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask];
2320 void dct_iv_slow(
float *buffer,
int n)
2325 int n2 = n >> 1, nmask = (n << 3) - 1;
2326 memcpy(x, buffer,
sizeof(*x) * n);
2327 for (i=0; i < 8*n; ++i)
2328 mcos[i] = (
float) cos(
M_PI / 4 * i / n);
2329 for (i=0; i < n; ++i) {
2331 for (j=0; j < n; ++j)
2332 acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask];
2337 void inverse_mdct_slow(
float *buffer,
int n,
vorb *
f,
int blocktype)
2339 int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4;
2342 memcpy(temp, buffer, n2 *
sizeof(
float));
2343 dct_iv_slow(temp, n2);
2345 for (i=0; i < n4 ; ++i) buffer[i] = temp[i+n4];
2346 for ( ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1];
2347 for ( ; i < n ; ++i) buffer[i] = -temp[i - n3_4];
2351 #ifndef LIBVORBIS_MDCT
2352 #define LIBVORBIS_MDCT 0
2369 extern void mdct_init(mdct_lookup *lookup,
int n);
2370 extern void mdct_clear(mdct_lookup *l);
2371 extern void mdct_backward(mdct_lookup *init,
float *in,
float *out);
2378 if (M1.n == n) M = &M1;
2379 else if (M2.n == n) M = &M2;
2380 else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; }
2382 if (M2.n) __asm
int 3;
2387 mdct_backward(M, buffer, buffer);
2397 float *ee0 = e + i_off;
2398 float *ee2 = ee0 + k_off;
2401 assert((n & 3) == 0);
2402 for (i=(n>>2); i > 0; --i) {
2403 float k00_20, k01_21;
2404 k00_20 = ee0[ 0] - ee2[ 0];
2405 k01_21 = ee0[-1] - ee2[-1];
2408 ee2[ 0] = k00_20 *
A[0] - k01_21 *
A[1];
2409 ee2[-1] = k01_21 *
A[0] + k00_20 *
A[1];
2412 k00_20 = ee0[-2] - ee2[-2];
2413 k01_21 = ee0[-3] - ee2[-3];
2416 ee2[-2] = k00_20 *
A[0] - k01_21 *
A[1];
2417 ee2[-3] = k01_21 *
A[0] + k00_20 *
A[1];
2420 k00_20 = ee0[-4] - ee2[-4];
2421 k01_21 = ee0[-5] - ee2[-5];
2424 ee2[-4] = k00_20 *
A[0] - k01_21 *
A[1];
2425 ee2[-5] = k01_21 *
A[0] + k00_20 *
A[1];
2428 k00_20 = ee0[-6] - ee2[-6];
2429 k01_21 = ee0[-7] - ee2[-7];
2432 ee2[-6] = k00_20 *
A[0] - k01_21 *
A[1];
2433 ee2[-7] = k01_21 *
A[0] + k00_20 *
A[1];
2443 float k00_20, k01_21;
2446 float *e2 = e0 + k_off;
2448 for (i=lim >> 2; i > 0; --i) {
2449 k00_20 = e0[-0] - e2[-0];
2450 k01_21 = e0[-1] - e2[-1];
2453 e2[-0] = (k00_20)*
A[0] - (k01_21) *
A[1];
2454 e2[-1] = (k01_21)*
A[0] + (k00_20) *
A[1];
2458 k00_20 = e0[-2] - e2[-2];
2459 k01_21 = e0[-3] - e2[-3];
2462 e2[-2] = (k00_20)*
A[0] - (k01_21) *
A[1];
2463 e2[-3] = (k01_21)*
A[0] + (k00_20) *
A[1];
2467 k00_20 = e0[-4] - e2[-4];
2468 k01_21 = e0[-5] - e2[-5];
2471 e2[-4] = (k00_20)*
A[0] - (k01_21) *
A[1];
2472 e2[-5] = (k01_21)*
A[0] + (k00_20) *
A[1];
2476 k00_20 = e0[-6] - e2[-6];
2477 k01_21 = e0[-7] - e2[-7];
2480 e2[-6] = (k00_20)*
A[0] - (k01_21) *
A[1];
2481 e2[-7] = (k01_21)*
A[0] + (k00_20) *
A[1];
2495 float A2 =
A[0+a_off];
2496 float A3 =
A[0+a_off+1];
2497 float A4 =
A[0+a_off*2+0];
2498 float A5 =
A[0+a_off*2+1];
2499 float A6 =
A[0+a_off*3+0];
2500 float A7 =
A[0+a_off*3+1];
2504 float *ee0 = e +i_off;
2505 float *ee2 = ee0+k_off;
2507 for (i=n; i > 0; --i) {
2508 k00 = ee0[ 0] - ee2[ 0];
2509 k11 = ee0[-1] - ee2[-1];
2510 ee0[ 0] = ee0[ 0] + ee2[ 0];
2511 ee0[-1] = ee0[-1] + ee2[-1];
2512 ee2[ 0] = (k00) * A0 - (k11) * A1;
2513 ee2[-1] = (k11) * A0 + (k00) * A1;
2515 k00 = ee0[-2] - ee2[-2];
2516 k11 = ee0[-3] - ee2[-3];
2517 ee0[-2] = ee0[-2] + ee2[-2];
2518 ee0[-3] = ee0[-3] + ee2[-3];
2519 ee2[-2] = (k00) * A2 - (k11) * A3;
2520 ee2[-3] = (k11) * A2 + (k00) * A3;
2522 k00 = ee0[-4] - ee2[-4];
2523 k11 = ee0[-5] - ee2[-5];
2524 ee0[-4] = ee0[-4] + ee2[-4];
2525 ee0[-5] = ee0[-5] + ee2[-5];
2526 ee2[-4] = (k00) * A4 - (k11) * A5;
2527 ee2[-5] = (k11) * A4 + (k00) * A5;
2529 k00 = ee0[-6] - ee2[-6];
2530 k11 = ee0[-7] - ee2[-7];
2531 ee0[-6] = ee0[-6] + ee2[-6];
2532 ee0[-7] = ee0[-7] + ee2[-7];
2533 ee2[-6] = (k00) * A6 - (k11) * A7;
2534 ee2[-7] = (k11) * A6 + (k00) * A7;
2543 float k00,k11,k22,k33;
2546 k00 = z[ 0] - z[-4];
2549 k22 = z[-2] - z[-6];
2556 k33 = z[-3] - z[-7];
2563 k11 = z[-1] - z[-5];
2575 int a_off = base_n >> 3;
2576 float A2 =
A[0+a_off];
2577 float *z = e + i_off;
2578 float *base = z - 16 * n;
2583 k00 = z[-0] - z[-8];
2584 k11 = z[-1] - z[-9];
2585 z[-0] = z[-0] + z[-8];
2586 z[-1] = z[-1] + z[-9];
2590 k00 = z[ -2] - z[-10];
2591 k11 = z[ -3] - z[-11];
2592 z[ -2] = z[ -2] + z[-10];
2593 z[ -3] = z[ -3] + z[-11];
2594 z[-10] = (k00+k11) * A2;
2595 z[-11] = (k11-k00) * A2;
2597 k00 = z[-12] - z[ -4];
2598 k11 = z[ -5] - z[-13];
2599 z[ -4] = z[ -4] + z[-12];
2600 z[ -5] = z[ -5] + z[-13];
2604 k00 = z[-14] - z[ -6];
2605 k11 = z[ -7] - z[-15];
2606 z[ -6] = z[ -6] + z[-14];
2607 z[ -7] = z[ -7] + z[-15];
2608 z[-14] = (k00+k11) * A2;
2609 z[-15] = (k00-k11) * A2;
2619 int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
2623 float *buf2 = (
float *)
temp_alloc(
f, n2 *
sizeof(*buf2));
2626 float *
A =
f->A[blocktype];
2648 float *
d,*e, *AA, *e_stop;
2652 e_stop = &buffer[n2];
2653 while (e != e_stop) {
2654 d[1] = (e[0] * AA[0] - e[2]*AA[1]);
2655 d[0] = (e[0] * AA[1] + e[2]*AA[0]);
2663 d[1] = (-e[2] * AA[0] - -e[0]*AA[1]);
2664 d[0] = (-e[2] * AA[1] + -e[0]*AA[0]);
2682 float *AA = &
A[n2-8];
2683 float *d0,*d1, *e0, *e1;
2692 float v40_20, v41_21;
2694 v41_21 = e0[1] - e1[1];
2695 v40_20 = e0[0] - e1[0];
2696 d0[1] = e0[1] + e1[1];
2697 d0[0] = e0[0] + e1[0];
2698 d1[1] = v41_21*AA[4] - v40_20*AA[5];
2699 d1[0] = v40_20*AA[4] + v41_21*AA[5];
2701 v41_21 = e0[3] - e1[3];
2702 v40_20 = e0[2] - e1[2];
2703 d0[3] = e0[3] + e1[3];
2704 d0[2] = e0[2] + e1[2];
2705 d1[3] = v41_21*AA[0] - v40_20*AA[1];
2706 d1[2] = v40_20*AA[0] + v41_21*AA[1];
2738 for (; l < (ld-3)>>1; ++l) {
2739 int k0 = n >> (l+2), k0_2 = k0>>1;
2740 int lim = 1 << (l+1);
2742 for (i=0; i < lim; ++i)
2746 for (; l < ld-6; ++l) {
2747 int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1;
2748 int rlim = n >> (l+6), r;
2749 int lim = 1 << (l+1);
2753 for (r=rlim; r > 0; --r) {
2772 uint16 *bitrev =
f->bit_reverse[blocktype];
2778 float *d0 = &v[n4-4];
2779 float *d1 = &v[n2-4];
2809 float *
C =
f->C[blocktype];
2816 float a02,a11,b0,b1,b2,b3;
2821 b0 =
C[1]*a02 +
C[0]*a11;
2822 b1 =
C[1]*a11 -
C[0]*a02;
2835 b0 =
C[3]*a02 +
C[2]*a11;
2836 b1 =
C[3]*a11 -
C[2]*a02;
2863 float *d0,*d1,*d2,*d3;
2865 float *
B =
f->B[blocktype] + n2 - 8;
2866 float *e = buf2 + n2 - 8;
2874 p3 = e[6]*
B[7] - e[7]*
B[6];
2875 p2 = -e[6]*
B[6] - e[7]*
B[7];
2882 p1 = e[4]*
B[5] - e[5]*
B[4];
2883 p0 = -e[4]*
B[4] - e[5]*
B[5];
2890 p3 = e[2]*
B[3] - e[3]*
B[2];
2891 p2 = -e[2]*
B[2] - e[3]*
B[3];
2898 p1 = e[0]*
B[1] - e[1]*
B[0];
2899 p0 = -e[0]*
B[0] - e[1]*
B[1];
2921 void inverse_mdct_naive(
float *buffer,
int n)
2924 float A[1 << 12],
B[1 << 12],
C[1 << 11];
2925 int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
2926 int n3_4 = n - n4, ld;
2929 float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13];
2932 for (k=k2=0; k < n4; ++k,k2+=2) {
2933 A[k2 ] = (float) cos(4*k*
M_PI/n);
2934 A[k2+1] = (float) -sin(4*k*
M_PI/n);
2935 B[k2 ] = (float) cos((k2+1)*
M_PI/n/2);
2936 B[k2+1] = (float) sin((k2+1)*
M_PI/n/2);
2938 for (k=k2=0; k < n8; ++k,k2+=2) {
2939 C[k2 ] = (float) cos(2*(k2+1)*
M_PI/n);
2940 C[k2+1] = (float) -sin(2*(k2+1)*
M_PI/n);
2951 for (k=0; k < n2; ++k) u[k] = buffer[k];
2952 for ( ; k < n ; ++k) u[k] = -buffer[n - k - 1];
2955 for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) {
2956 v[n-k4-1] = (u[k4] - u[n-k4-1]) *
A[k2] - (u[k4+2] - u[n-k4-3])*
A[k2+1];
2957 v[n-k4-3] = (u[k4] - u[n-k4-1]) *
A[k2+1] + (u[k4+2] - u[n-k4-3])*
A[k2];
2960 for (k=k4=0; k < n8; k+=1, k4+=4) {
2961 w[n2+3+k4] = v[n2+3+k4] + v[k4+3];
2962 w[n2+1+k4] = v[n2+1+k4] + v[k4+1];
2963 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];
2964 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];
2968 for (l=0; l < ld-3; ++l) {
2969 int k0 = n >> (l+2), k1 = 1 << (l+3);
2970 int rlim = n >> (l+4), r4, r;
2971 int s2lim = 1 << (l+2), s2;
2972 for (r=r4=0; r < rlim; r4+=4,++r) {
2973 for (s2=0; s2 < s2lim; s2+=2) {
2974 u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4];
2975 u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4];
2976 u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) *
A[r*k1]
2977 - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) *
A[r*k1+1];
2978 u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) *
A[r*k1]
2979 + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) *
A[r*k1+1];
2984 memcpy(w, u,
sizeof(u));
2989 for (i=0; i < n8; ++i) {
3001 int i8 = i << 3, j8 = j << 3;
3002 v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1];
3003 v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3];
3004 v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5];
3005 v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7];
3009 for (k=0; k < n2; ++k) {
3013 for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) {
3015 u[n-2-k2] = w[k4+1];
3016 u[n3_4 - 1 - k2] = w[k4+2];
3017 u[n3_4 - 2 - k2] = w[k4+3];
3020 for (k=k2=0; k < n8; ++k, k2 += 2) {
3021 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;
3022 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;
3023 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;
3024 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;
3027 for (k=k2=0; k < n4; ++k,k2 += 2) {
3028 X[k] = v[k2+n2]*
B[k2 ] + v[k2+1+n2]*
B[k2+1];
3029 X[n2-1-k] = v[k2+n2]*
B[k2+1] - v[k2+1+n2]*
B[k2 ];
3041 for (i=0; i < n4 ; ++i) buffer[i] = s * X[i+n4];
3042 for ( ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1];
3043 for ( ; i < n ; ++i) buffer[i] = -s * X[i - n3_4];
3050 if (len ==
f->blocksize_0)
return f->window[0];
3051 if (len ==
f->blocksize_1)
return f->window[1];
3055 #ifndef STB_VORBIS_NO_DEFER_FLOOR
3065 if (
f->floor_types[floor] == 0) {
3068 Floor1 *g = &
f->floor_config[floor].floor1;
3071 for (q=1; q < g->
values; ++q) {
3073 #ifndef STB_VORBIS_NO_DEFER_FLOOR
3080 int hx = g->
Xlist[j];
3089 for (j=lx; j < n2; ++j)
3114 int i, n, prev, next, window_center;
3115 f->channel_buffer_start =
f->channel_buffer_end = 0;
3118 if (
f->eof)
return FALSE;
3129 if (
f->alloc.alloc_buffer)
3130 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3134 if (i >=
f->mode_count)
return FALSE;
3136 m =
f->mode_config + i;
3148 window_center = n >> 1;
3150 *p_left_start = (n -
f->blocksize_0) >> 2;
3151 *p_left_end = (n +
f->blocksize_0) >> 2;
3154 *p_left_end = window_center;
3157 *p_right_start = (n*3 -
f->blocksize_0) >> 2;
3158 *p_right_end = (n*3 +
f->blocksize_0) >> 2;
3160 *p_right_start = window_center;
3171 int zero_channel[256];
3172 int really_zero_channel[256];
3184 for (i=0; i <
f->channels; ++i) {
3186 zero_channel[i] =
FALSE;
3188 if (
f->floor_types[floor] == 0) {
3191 Floor1 *g = &
f->floor_config[floor].floor1;
3194 uint8 step2_flag[256];
3195 static int range_list[4] = { 256, 128, 86, 64 };
3205 int csub = (1 << cbits)-1;
3211 for (k=0; k < cdim; ++k) {
3213 cval = cval >> cbits;
3224 step2_flag[0] = step2_flag[1] = 1;
3225 for (j=2; j < g->
values; ++j) {
3226 int low, high, pred, highroom, lowroom, room, val;
3232 highroom = range - pred;
3234 if (highroom < lowroom)
3235 room = highroom * 2;
3239 step2_flag[low] = step2_flag[high] = 1;
3242 if (highroom > lowroom)
3243 finalY[j] = val - lowroom + pred;
3245 finalY[j] = pred - val + highroom - 1;
3248 finalY[j] = pred - ((val+1)>>1);
3250 finalY[j] = pred + (val>>1);
3257 #ifdef STB_VORBIS_NO_DEFER_FLOOR
3261 for (j=0; j < g->
values; ++j) {
3268 zero_channel[i] =
TRUE;
3278 if (
f->alloc.alloc_buffer)
3279 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3282 memcpy(really_zero_channel, zero_channel,
sizeof(really_zero_channel[0]) *
f->channels);
3290 for (i=0; i < map->
submaps; ++i) {
3293 uint8 do_not_decode[256];
3295 for (j=0; j <
f->channels; ++j) {
3297 if (zero_channel[j]) {
3298 do_not_decode[ch] =
TRUE;
3299 residue_buffers[ch] =
NULL;
3301 do_not_decode[ch] =
FALSE;
3302 residue_buffers[ch] =
f->channel_buffers[j];
3311 if (
f->alloc.alloc_buffer)
3312 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3319 float *a =
f->channel_buffers[map->
chan[i].
angle ];
3320 for (j=0; j < n2; ++j) {
3324 m2 = m[j], a2 = m[j] - a[j];
3326 a2 = m[j], m2 = m[j] + a[j];
3329 m2 = m[j], a2 = m[j] + a[j];
3331 a2 = m[j], m2 = m[j] - a[j];
3339 #ifndef STB_VORBIS_NO_DEFER_FLOOR
3340 for (i=0; i <
f->channels; ++i) {
3341 if (really_zero_channel[i]) {
3342 memset(
f->channel_buffers[i], 0,
sizeof(*
f->channel_buffers[i]) * n2);
3348 for (i=0; i <
f->channels; ++i) {
3349 if (really_zero_channel[i]) {
3350 memset(
f->channel_buffers[i], 0,
sizeof(*
f->channel_buffers[i]) * n2);
3352 for (j=0; j < n2; ++j)
3353 f->channel_buffers[i][j] *=
f->floor_buffers[i][j];
3360 for (i=0; i <
f->channels; ++i)
3368 if (
f->first_decode) {
3373 f->current_loc = -n2;
3376 f->discard_samples_deferred = n - right_end;
3377 f->current_loc_valid =
TRUE;
3379 }
else if (
f->discard_samples_deferred) {
3380 if (
f->discard_samples_deferred >= right_start - left_start) {
3381 f->discard_samples_deferred -= (right_start - left_start);
3382 left_start = right_start;
3383 *p_left = left_start;
3385 left_start +=
f->discard_samples_deferred;
3386 *p_left = left_start;
3387 f->discard_samples_deferred = 0;
3389 }
else if (
f->previous_length == 0 &&
f->current_loc_valid) {
3399 if (
f->last_seg_which ==
f->end_seg_with_known_loc) {
3402 uint32 current_end =
f->known_loc_for_packet;
3404 if (current_end < f->
current_loc + (right_end-left_start)) {
3409 *len = current_end -
f->current_loc;
3412 if (*len > right_end) *len = right_end;
3413 f->current_loc += *len;
3421 f->current_loc =
f->known_loc_for_packet - (n2-left_start);
3422 f->current_loc_valid =
TRUE;
3424 if (
f->current_loc_valid)
3425 f->current_loc += (right_start - left_start);
3427 if (
f->alloc.alloc_buffer)
3428 assert(
f->alloc.alloc_buffer_length_in_bytes ==
f->temp_offset);
3437 int mode, left_end, right_end;
3454 if (
f->previous_length) {
3455 int i,j, n =
f->previous_length;
3457 if (w ==
NULL)
return 0;
3458 for (i=0; i <
f->channels; ++i) {
3459 for (j=0; j < n; ++j)
3460 f->channel_buffers[i][left+j] =
3461 f->channel_buffers[i][left+j]*w[ j] +
3462 f->previous_window[i][ j]*w[n-1-j];
3466 prev =
f->previous_length;
3469 f->previous_length = len - right;
3477 for (i=0; i <
f->channels; ++i)
3478 for (j=0; right+j < len; ++j)
3479 f->previous_window[i][j] =
f->channel_buffers[i][right+j];
3488 if (len < right) right = len;
3490 f->samples_output += right-left;
3492 return right - left;
3497 int len, right, left, res;
3504 #ifndef STB_VORBIS_NO_PUSHDATA_API
3515 int s =
f->next_seg, first =
TRUE;
3519 for (;
s <
f->segment_count; ++
s) {
3520 p +=
f->segments[
s];
3521 if (
f->segments[
s] < 255)
3525 if (
s ==
f->segment_count)
3540 if (
f->previous_length)
3552 for (
s=0;
s < n; ++
s) {
3564 #endif // !STB_VORBIS_NO_PUSHDATA_API
3569 int len,i,j,k, max_submaps = 0;
3570 int longest_floorlist=0;
3573 f->first_decode =
TRUE;
3582 if (
f->segments[0] != 30) {
3584 if (
f->segments[0] == 64 &&
3616 f->blocksize_0 = 1 << log0;
3617 f->blocksize_1 = 1 << log1;
3641 for(i=0; i < len; ++i) {
3644 f->vendor[len] = (char)
'\0';
3647 f->comment_list =
NULL;
3648 if (
f->comment_list_length > 0)
3650 f->comment_list = (
char**)
setup_malloc(
f,
sizeof(
char*) * (
f->comment_list_length));
3654 for(i=0; i <
f->comment_list_length; ++i) {
3656 f->comment_list[i] = (
char*)
setup_malloc(
f,
sizeof(
char) * (len+1));
3659 for(j=0; j < len; ++j) {
3662 f->comment_list[i][len] = (char)
'\0';
3670 skip(
f,
f->bytes_in_seg);
3671 f->bytes_in_seg = 0;
3676 f->bytes_in_seg = 0;
3682 #ifndef STB_VORBIS_NO_PUSHDATA_API
3704 memset(
f->codebooks, 0,
sizeof(*
f->codebooks) *
f->codebook_count);
3705 for (i=0; i <
f->codebook_count; ++i) {
3707 int ordered, sorted_count;
3733 int current_entry = 0;
3735 while (current_entry < c->entries) {
3736 int limit = c->
entries - current_entry;
3740 memset(lengths + current_entry, current_length, n);
3745 for (j=0; j < c->
entries; ++j) {
3750 if (lengths[j] == 32)
3760 if (c->
entries > (
int)
f->setup_temp_memory_required)
3761 f->setup_temp_memory_required = c->
entries;
3773 sorted_count = total;
3776 #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
3777 for (j=0; j < c->
entries; ++j)
3801 if (size >
f->setup_temp_memory_required)
3802 f->setup_temp_memory_required = size;
3857 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
3859 int len, sparse = c->
sparse;
3869 for (j=0; j < len; ++j) {
3874 float val = mults[off];
3904 #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
3917 for (i=0; i < x; ++i) {
3926 for (i=0; i <
f->floor_count; ++i) {
3929 if (
f->floor_types[i] == 0) {
3930 Floor0 *g = &
f->floor_config[i].floor0;
3942 Floor1 *g = &
f->floor_config[i].floor1;
3950 for (j=0; j <= max_class; ++j) {
3975 for (j=0; j < g->
values; ++j) {
3980 for (j=0; j < g->
values-1; ++j)
3981 if (p[j].x == p[j+1].x)
3983 for (j=0; j < g->
values; ++j)
3986 for (j=2; j < g->
values; ++j) {
3993 if (g->
values > longest_floorlist)
3994 longest_floorlist = g->
values;
4002 memset(
f->residue_config, 0,
f->residue_count *
sizeof(
f->residue_config[0]));
4003 for (i=0; i <
f->residue_count; ++i) {
4004 uint8 residue_cascade[64];
4020 residue_cascade[j] = high_bits*8 + low_bits;
4025 for (k=0; k < 8; ++k) {
4026 if (residue_cascade[j] & (1 << k)) {
4039 for (j=0; j <
f->codebooks[r->
classbook].entries; ++j) {
4040 int classwords =
f->codebooks[r->
classbook].dimensions;
4044 for (k=classwords-1; k >= 0; --k) {
4054 memset(
f->mapping, 0,
f->mapping_count *
sizeof(*
f->mapping));
4055 for (i=0; i <
f->mapping_count; ++i) {
4083 for (j=0; j <
f->channels; ++j) {
4089 for (j=0; j <
f->channels; ++j)
4092 for (j=0; j < m->
submaps; ++j) {
4103 for (i=0; i <
f->mode_count; ++i) {
4104 Mode *m =
f->mode_config+i;
4116 f->previous_length = 0;
4118 for (i=0; i <
f->channels; ++i) {
4119 f->channel_buffers[i] = (
float *)
setup_malloc(
f,
sizeof(
float) *
f->blocksize_1);
4120 f->previous_window[i] = (
float *)
setup_malloc(
f,
sizeof(
float) *
f->blocksize_1/2);
4123 memset(
f->channel_buffers[i], 0,
sizeof(
float) *
f->blocksize_1);
4124 #ifdef STB_VORBIS_NO_DEFER_FLOOR
4125 f->floor_buffers[i] = (
float *)
setup_malloc(
f,
sizeof(
float) *
f->blocksize_1/2);
4132 f->blocksize[0] =
f->blocksize_0;
4133 f->blocksize[1] =
f->blocksize_1;
4135 #ifdef STB_VORBIS_DIVIDE_TABLE
4136 if (integer_divide_table[1][1]==0)
4137 for (i=0; i < DIVTAB_NUMER; ++i)
4138 for (j=1; j < DIVTAB_DENOM; ++j)
4139 integer_divide_table[i][j] = i / j;
4146 uint32 imdct_mem = (
f->blocksize_1 *
sizeof(float) >> 1);
4148 int i,max_part_read=0;
4149 for (i=0; i <
f->residue_count; ++i) {
4150 Residue *r =
f->residue_config + i;
4151 unsigned int actual_size =
f->blocksize_1 / 2;
4152 unsigned int limit_r_begin = r->
begin < actual_size ? r->
begin : actual_size;
4153 unsigned int limit_r_end = r->
end < actual_size ? r->
end : actual_size;
4154 int n_read = limit_r_end - limit_r_begin;
4156 if (part_read > max_part_read)
4157 max_part_read = part_read;
4159 #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
4160 classify_mem =
f->channels * (
sizeof(
void*) + max_part_read *
sizeof(
uint8 *));
4162 classify_mem =
f->channels * (
sizeof(
void*) + max_part_read *
sizeof(
int *));
4167 f->temp_memory_required = classify_mem;
4168 if (imdct_mem >
f->temp_memory_required)
4169 f->temp_memory_required = imdct_mem;
4173 if (
f->alloc.alloc_buffer) {
4174 assert(
f->temp_offset ==
f->alloc.alloc_buffer_length_in_bytes);
4176 if (
f->setup_offset +
sizeof(*
f) +
f->temp_memory_required > (
unsigned)
f->temp_offset)
4186 if (
f->next_seg == -1) {
4189 f->first_audio_page_offset = 0;
4241 #ifdef STB_VORBIS_NO_DEFER_FLOOR
4246 for (i=0; i < 2; ++i) {
4253 #ifndef STB_VORBIS_NO_STDIO
4260 if (p ==
NULL)
return;
4267 memset(p, 0,
sizeof(*p));
4278 #ifndef STB_VORBIS_NO_STDIO
4286 if (
f->current_loc_valid)
4287 return f->current_loc;
4295 d.channels =
f->channels;
4296 d.sample_rate =
f->sample_rate;
4297 d.setup_memory_required =
f->setup_memory_required;
4298 d.setup_temp_memory_required =
f->setup_temp_memory_required;
4299 d.temp_memory_required =
f->temp_memory_required;
4300 d.max_frame_size =
f->blocksize_1 >> 1;
4307 d.vendor =
f->vendor;
4308 d.comment_list_length =
f->comment_list_length;
4309 d.comment_list =
f->comment_list;
4326 #ifndef STB_VORBIS_NO_PUSHDATA_API
4330 f->previous_length = 0;
4331 f->page_crc_tests = 0;
4332 f->discard_samples_deferred = 0;
4333 f->current_loc_valid =
FALSE;
4335 f->samples_output = 0;
4336 f->channel_buffer_start = 0;
4337 f->channel_buffer_end = 0;
4343 for (i=0; i <
f->page_crc_tests; ++i)
4344 f->scan[i].bytes_done = 0;
4349 if (data_len < 4)
return 0;
4352 for (i=0; i < data_len; ++i) {
4353 if (data[i] == 0x4f) {
4358 if (i+26 >= data_len || i+27+data[i+26] >= data_len) {
4365 len = 27 + data[i+26];
4366 for (j=0; j < data[i+26]; ++j)
4367 len += data[i+27+j];
4370 for (j=0; j < 22; ++j)
4373 for ( ; j < 26; ++j)
4376 n =
f->page_crc_tests++;
4377 f->scan[n].bytes_left = len-j;
4378 f->scan[n].crc_so_far = crc;
4379 f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24);
4382 if (data[i+27+data[i+26]-1] == 255)
4383 f->scan[n].sample_loc = ~0;
4385 f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24);
4386 f->scan[n].bytes_done = i+j;
4395 for (i=0; i <
f->page_crc_tests;) {
4398 int n =
f->scan[i].bytes_done;
4399 int m =
f->scan[i].bytes_left;
4400 if (m > data_len - n) m = data_len - n;
4402 crc =
f->scan[i].crc_so_far;
4403 for (j=0; j < m; ++j)
4405 f->scan[i].bytes_left -= m;
4406 f->scan[i].crc_so_far = crc;
4407 if (
f->scan[i].bytes_left == 0) {
4409 if (
f->scan[i].crc_so_far ==
f->scan[i].goal_crc) {
4412 f->page_crc_tests = -1;
4413 f->previous_length = 0;
4415 f->current_loc =
f->scan[i].sample_loc;
4417 f->current_loc_valid =
f->current_loc != ~0U;
4421 f->scan[i] =
f->scan[--
f->page_crc_tests];
4433 const uint8 *data,
int data_len,
4444 if (
f->page_crc_tests >= 0) {
4449 f->stream = (
uint8 *) data;
4450 f->stream_end = (
uint8 *) data + data_len;
4468 return (
int) (
f->stream - data);
4471 if (
f->previous_length == 0) {
4478 return (
int) (
f->stream - data);
4492 for (i=0; i <
f->channels; ++i)
4493 f->outputs[i] =
f->channel_buffers[i] + left;
4497 *output =
f->outputs;
4498 return (
int) (
f->stream - data);
4502 const unsigned char *data,
int data_len,
4521 *data_used = (int) (
f->stream - data);
4529 #endif // STB_VORBIS_NO_PUSHDATA_API
4533 #ifndef STB_VORBIS_NO_PUSHDATA_API
4534 if (
f->push_mode)
return 0;
4536 if (
USE_MEMORY(
f))
return (
unsigned int) (
f->stream -
f->stream_start);
4537 #ifndef STB_VORBIS_NO_STDIO
4538 return (
unsigned int) (ftell(
f->f) -
f->f_start);
4542 #ifndef STB_VORBIS_NO_PULLDATA_API
4551 if (
f->eof)
return 0;
4557 if (retry_loc - 25 >
f->stream_len)
4560 for (i=1; i < 4; ++i)
4563 if (
f->eof)
return 0;
4566 uint32 i, crc, goal, len;
4567 for (i=0; i < 4; ++i)
4571 if (
f->eof)
return 0;
4572 if (
header[4] != 0)
goto invalid;
4574 for (i=22; i < 26; ++i)
4577 for (i=0; i < 27; ++i)
4580 for (i=0; i <
header[26]; ++i) {
4585 if (len &&
f->eof)
return 0;
4586 for (i=0; i < len; ++i)
4618 #define SAMPLE_unknown 0xffffffff
4645 for (i=0; i <
header[26]; ++i)
4663 unsigned int previous_safe, end;
4666 if (limit_offset >= 65536 && limit_offset-65536 >=
f->first_audio_page_offset)
4667 previous_safe = limit_offset - 65536;
4669 previous_safe =
f->first_audio_page_offset;
4689 int i, start_seg_with_known_loc, end_pos, page_start;
4690 uint32 delta, stream_length, padding, last_sample_limit;
4691 double offset = 0.0, bytes_per_sample = 0.0;
4702 padding = ((
f->blocksize_1 -
f->blocksize_0) >> 2);
4703 if (sample_number < padding)
4704 last_sample_limit = 0;
4706 last_sample_limit = sample_number - padding;
4721 if (
f->current_loc > sample_number)
4732 if (delta <= 65536) {
4746 if (error < 0 && error > -8000)
error = -8000;
4747 offset +=
error * 2;
4777 if (probe >= 2 || delta <= 65536)
4793 end_pos =
f->end_seg_with_known_loc;
4794 assert(end_pos >= 0);
4797 for (i = end_pos; i > 0; --i)
4798 if (
f->segments[i-1] != 255)
4801 start_seg_with_known_loc = i;
4812 end_pos =
f->segment_count - 1;
4816 f->current_loc_valid =
FALSE;
4819 f->packet_bytes = 0;
4820 f->bytes_in_seg = 0;
4821 f->previous_length = 0;
4822 f->next_seg = start_seg_with_known_loc;
4824 for (i = 0; i < start_seg_with_known_loc; i++)
4830 if (
f->current_loc > sample_number)
4843 int bits_read, bytes_read;
4849 bits_read = 1 +
ilog(
f->mode_count-1);
4850 if (
f->mode_config[*mode].blockflag)
4852 bytes_read = (bits_read + 7) / 8;
4854 f->bytes_in_seg += bytes_read;
4855 f->packet_bytes -= bytes_read;
4856 skip(
f, -bytes_read);
4857 if (
f->next_seg == -1)
4858 f->next_seg =
f->segment_count - 1;
4868 uint32 max_frame_samples;
4876 assert(
f->current_loc_valid);
4877 assert(
f->current_loc <= sample_number);
4880 max_frame_samples = (
f->blocksize_1*3 -
f->blocksize_0) >> 2;
4881 while (
f->current_loc < sample_number) {
4882 int left_start, left_end, right_start, right_end, mode, frame_samples;
4886 frame_samples = right_start - left_start;
4887 if (
f->current_loc + frame_samples > sample_number) {
4889 }
else if (
f->current_loc + frame_samples + max_frame_samples > sample_number) {
4894 f->current_loc += frame_samples;
4895 f->previous_length = 0;
4910 if (sample_number !=
f->current_loc) {
4912 uint32 frame_start =
f->current_loc;
4914 assert(sample_number > frame_start);
4915 assert(
f->channel_buffer_start + (
int) (sample_number-frame_start) <=
f->channel_buffer_end);
4916 f->channel_buffer_start += (sample_number - frame_start);
4926 f->previous_length = 0;
4927 f->first_decode =
TRUE;
4934 unsigned int restore_offset, previous_safe;
4935 unsigned int end, last_page_loc;
4938 if (!
f->total_samples) {
4948 if (
f->stream_len >= 65536 &&
f->stream_len-65536 >=
f->first_audio_page_offset)
4949 previous_safe =
f->stream_len - 65536;
4951 previous_safe =
f->first_audio_page_offset;
4960 f->total_samples = 0xffffffff;
4977 previous_safe = last_page_loc+1;
4988 if (lo == 0xffffffff && hi == 0xffffffff) {
4995 f->total_samples = lo;
4997 f->p_last.page_start = last_page_loc;
4998 f->p_last.page_end = end;
4999 f->p_last.last_decoded_sample = lo;
5016 int len, right,left,i;
5020 f->channel_buffer_start =
f->channel_buffer_end = 0;
5025 for (i=0; i <
f->channels; ++i)
5026 f->outputs[i] =
f->channel_buffers[i] + left;
5028 f->channel_buffer_start = left;
5029 f->channel_buffer_end = left+len;
5032 if (output) *output =
f->outputs;
5036 #ifndef STB_VORBIS_NO_STDIO
5061 unsigned int len,
start;
5062 start = (
unsigned int) ftell(file);
5063 fseek(file, 0, SEEK_END);
5064 len = (
unsigned int) (ftell(file) -
start);
5065 fseek(file,
start, SEEK_SET);
5072 #if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)
5073 if (0 != fopen_s(&
f, filename,
"rb"))
5076 f = fopen(filename,
"rb");
5083 #endif // STB_VORBIS_NO_STDIO
5109 #ifndef STB_VORBIS_NO_INTEGER_CONVERSION
5110 #define PLAYBACK_MONO 1
5111 #define PLAYBACK_LEFT 2
5112 #define PLAYBACK_RIGHT 4
5114 #define L (PLAYBACK_LEFT | PLAYBACK_MONO)
5115 #define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO)
5116 #define R (PLAYBACK_RIGHT | PLAYBACK_MONO)
5130 #ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
5136 #define FASTDEF(x) float_conv x
5138 #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))
5139 #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))
5140 #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))
5141 #define check_endianness()
5143 #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))
5144 #define check_endianness()
5152 for (i=0; i < len; ++i) {
5155 if ((
unsigned int) (v + 32768) > 65535)
5156 v = v < 0 ? -32768 : 32767;
5161 static void compute_samples(
int mask,
short *output,
int num_c,
float **data,
int d_offset,
int len)
5163 #define BUFFER_SIZE 32
5168 memset(buffer, 0,
sizeof(buffer));
5169 if (o + n > len) n = len - o;
5170 for (j=0; j < num_c; ++j) {
5172 for (i=0; i < n; ++i)
5173 buffer[i] += data[j][d_offset+o+i];
5176 for (i=0; i < n; ++i) {
5179 if ((
unsigned int) (v + 32768) > 65535)
5180 v = v < 0 ? -32768 : 32767;
5188 #define BUFFER_SIZE 32
5193 for (o = 0; o < len; o += BUFFER_SIZE >> 1) {
5196 memset(buffer, 0,
sizeof(buffer));
5197 if (o + n > len) n = len - o;
5198 for (j=0; j < num_c; ++j) {
5201 for (i=0; i < n; ++i) {
5202 buffer[i*2+0] += data[j][d_offset+o+i];
5203 buffer[i*2+1] += data[j][d_offset+o+i];
5206 for (i=0; i < n; ++i) {
5207 buffer[i*2+0] += data[j][d_offset+o+i];
5210 for (i=0; i < n; ++i) {
5211 buffer[i*2+1] += data[j][d_offset+o+i];
5215 for (i=0; i < (n<<1); ++i) {
5218 if ((
unsigned int) (v + 32768) > 65535)
5219 v = v < 0 ? -32768 : 32767;
5225 static void convert_samples_short(
int buf_c,
short **buffer,
int b_offset,
int data_c,
float **data,
int d_offset,
int samples)
5228 if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
5230 for (i=0; i < buf_c; ++i)
5231 compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples);
5233 int limit = buf_c < data_c ? buf_c : data_c;
5234 for (i=0; i < limit; ++i)
5235 copy_samples(buffer[i]+b_offset, data[i]+d_offset, samples);
5236 for ( ; i < buf_c; ++i)
5237 memset(buffer[i]+b_offset, 0,
sizeof(
short) * samples);
5243 float **output =
NULL;
5245 if (len > num_samples) len = num_samples;
5255 if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
5257 for (i=0; i < buf_c; ++i)
5260 int limit = buf_c < data_c ? buf_c : data_c;
5262 for (j=0; j < len; ++j) {
5263 for (i=0; i < limit; ++i) {
5265 float f = data[i][d_offset+j];
5267 if ((
unsigned int) (v + 32768) > 65535)
5268 v = v < 0 ? -32768 : 32767;
5271 for ( ; i < buf_c; ++i)
5284 if (len*num_c > num_shorts) len = num_shorts / num_c;
5293 int len = num_shorts / channels;
5295 int z =
f->channels;
5296 if (z > channels) z = channels;
5298 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5299 if (n+k >= len) k = len - n;
5302 buffer += k*channels;
5304 f->channel_buffer_start += k;
5305 if (n == len)
break;
5315 int z =
f->channels;
5316 if (z > channels) z = channels;
5318 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5319 if (n+k >= len) k = len - n;
5323 f->channel_buffer_start += k;
5324 if (n == len)
break;
5330 #ifndef STB_VORBIS_NO_STDIO
5333 int data_len, offset, total, limit,
error;
5336 if (v ==
NULL)
return -1;
5341 offset = data_len = 0;
5343 data = (
short *) malloc(total *
sizeof(*data));
5353 if (offset + limit > total) {
5356 data2 = (
short *) realloc(data, total *
sizeof(*data));
5357 if (data2 ==
NULL) {
5373 int data_len, offset, total, limit,
error;
5376 if (v ==
NULL)
return -1;
5381 offset = data_len = 0;
5383 data = (
short *) malloc(total *
sizeof(*data));
5393 if (offset + limit > total) {
5396 data2 = (
short *) realloc(data, total *
sizeof(*data));
5397 if (data2 ==
NULL) {
5409 #endif // STB_VORBIS_NO_INTEGER_CONVERSION
5414 int len = num_floats / channels;
5416 int z =
f->channels;
5417 if (z > channels) z = channels;
5420 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5421 if (n+k >= len) k = len - n;
5422 for (j=0; j < k; ++j) {
5423 for (i=0; i < z; ++i)
5424 *buffer++ =
f->channel_buffers[i][
f->channel_buffer_start+j];
5425 for ( ; i < channels; ++i)
5429 f->channel_buffer_start += k;
5442 int z =
f->channels;
5443 if (z > channels) z = channels;
5444 while (n < num_samples) {
5446 int k =
f->channel_buffer_end -
f->channel_buffer_start;
5447 if (n+k >= num_samples) k = num_samples - n;
5449 for (i=0; i < z; ++i)
5450 memcpy(buffer[i]+n,
f->channel_buffers[i]+
f->channel_buffer_start,
sizeof(
float)*k);
5451 for ( ; i < channels; ++i)
5452 memset(buffer[i]+n, 0,
sizeof(
float) * k);
5455 f->channel_buffer_start += k;
5456 if (n == num_samples)
5463 #endif // STB_VORBIS_NO_PULLDATA_API
5526 #endif // STB_VORBIS_HEADER_ONLY