145#define DRWAV_STRINGIFY(x) #x
146#define DRWAV_XSTRINGIFY(x) DRWAV_STRINGIFY(x)
148#define DRWAV_VERSION_MAJOR 0
149#define DRWAV_VERSION_MINOR 14
150#define DRWAV_VERSION_REVISION 5
151#define DRWAV_VERSION_STRING DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
162#if defined(_MSC_VER) && !defined(__clang__)
166 #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
167 #pragma GCC diagnostic push
168 #pragma GCC diagnostic ignored "-Wlong-long"
169 #if defined(__clang__)
170 #pragma GCC diagnostic ignored "-Wc++11-long-long"
175 #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
176 #pragma GCC diagnostic pop
179#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(__powerpc64__)
191#if !defined(DRWAV_API)
192 #if defined(DRWAV_DLL)
194 #define DRWAV_DLL_IMPORT __declspec(dllimport)
195 #define DRWAV_DLL_EXPORT __declspec(dllexport)
196 #define DRWAV_DLL_PRIVATE static
198 #if defined(__GNUC__) && __GNUC__ >= 4
199 #define DRWAV_DLL_IMPORT __attribute__((visibility("default")))
200 #define DRWAV_DLL_EXPORT __attribute__((visibility("default")))
201 #define DRWAV_DLL_PRIVATE __attribute__((visibility("hidden")))
203 #define DRWAV_DLL_IMPORT
204 #define DRWAV_DLL_EXPORT
205 #define DRWAV_DLL_PRIVATE static
209 #if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
210 #define DRWAV_API DRWAV_DLL_EXPORT
212 #define DRWAV_API DRWAV_DLL_IMPORT
214 #define DRWAV_PRIVATE DRWAV_DLL_PRIVATE
216 #define DRWAV_API extern
217 #define DRWAV_PRIVATE static
224#define DRWAV_SUCCESS 0
225#define DRWAV_ERROR -1
226#define DRWAV_INVALID_ARGS -2
227#define DRWAV_INVALID_OPERATION -3
228#define DRWAV_OUT_OF_MEMORY -4
229#define DRWAV_OUT_OF_RANGE -5
230#define DRWAV_ACCESS_DENIED -6
231#define DRWAV_DOES_NOT_EXIST -7
232#define DRWAV_ALREADY_EXISTS -8
233#define DRWAV_TOO_MANY_OPEN_FILES -9
234#define DRWAV_INVALID_FILE -10
235#define DRWAV_TOO_BIG -11
236#define DRWAV_PATH_TOO_LONG -12
237#define DRWAV_NAME_TOO_LONG -13
238#define DRWAV_NOT_DIRECTORY -14
239#define DRWAV_IS_DIRECTORY -15
240#define DRWAV_DIRECTORY_NOT_EMPTY -16
241#define DRWAV_END_OF_FILE -17
242#define DRWAV_NO_SPACE -18
243#define DRWAV_BUSY -19
244#define DRWAV_IO_ERROR -20
245#define DRWAV_INTERRUPT -21
246#define DRWAV_UNAVAILABLE -22
247#define DRWAV_ALREADY_IN_USE -23
248#define DRWAV_BAD_ADDRESS -24
249#define DRWAV_BAD_SEEK -25
250#define DRWAV_BAD_PIPE -26
251#define DRWAV_DEADLOCK -27
252#define DRWAV_TOO_MANY_LINKS -28
253#define DRWAV_NOT_IMPLEMENTED -29
254#define DRWAV_NO_MESSAGE -30
255#define DRWAV_BAD_MESSAGE -31
256#define DRWAV_NO_DATA_AVAILABLE -32
257#define DRWAV_INVALID_DATA -33
258#define DRWAV_TIMEOUT -34
259#define DRWAV_NO_NETWORK -35
260#define DRWAV_NOT_UNIQUE -36
261#define DRWAV_NOT_SOCKET -37
262#define DRWAV_NO_ADDRESS -38
263#define DRWAV_BAD_PROTOCOL -39
264#define DRWAV_PROTOCOL_UNAVAILABLE -40
265#define DRWAV_PROTOCOL_NOT_SUPPORTED -41
266#define DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED -42
267#define DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED -43
268#define DRWAV_SOCKET_NOT_SUPPORTED -44
269#define DRWAV_CONNECTION_RESET -45
270#define DRWAV_ALREADY_CONNECTED -46
271#define DRWAV_NOT_CONNECTED -47
272#define DRWAV_CONNECTION_REFUSED -48
273#define DRWAV_NO_HOST -49
274#define DRWAV_IN_PROGRESS -50
275#define DRWAV_CANCELLED -51
276#define DRWAV_MEMORY_ALREADY_MAPPED -52
277#define DRWAV_AT_END -53
281#define DR_WAVE_FORMAT_PCM 0x1
282#define DR_WAVE_FORMAT_ADPCM 0x2
283#define DR_WAVE_FORMAT_IEEE_FLOAT 0x3
284#define DR_WAVE_FORMAT_ALAW 0x6
285#define DR_WAVE_FORMAT_MULAW 0x7
286#define DR_WAVE_FORMAT_DVI_ADPCM 0x11
287#define DR_WAVE_FORMAT_EXTENSIBLE 0xFFFE
290#define DRWAV_SEQUENTIAL 0x00000001
291#define DRWAV_WITH_METADATA 0x00000002
300 void* (* onMalloc)(
size_t sz,
void* pUserData);
301 void* (* onRealloc)(
void* p,
size_t sz,
void* pUserData);
302 void (* onFree)(
void* p,
void* pUserData);
743 char pOriginationDate[10];
744 char pOriginationTime[8];
1127#ifndef DR_WAV_NO_CONVERSION_API
1238#ifndef DR_WAV_NO_STDIO
1294#ifndef DR_WAV_NO_CONVERSION_API
1303#ifndef DR_WAV_NO_STDIO
1357#if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
1363#pragma options opt off
1370#ifndef DR_WAV_NO_STDIO
1372#ifndef DR_WAV_NO_WCHAR
1380#define DRWAV_ASSERT(expression) assert(expression)
1383#define DRWAV_MALLOC(sz) malloc((sz))
1385#ifndef DRWAV_REALLOC
1386#define DRWAV_REALLOC(p, sz) realloc((p), (sz))
1389#define DRWAV_FREE(p) free((p))
1391#ifndef DRWAV_COPY_MEMORY
1392#define DRWAV_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz))
1394#ifndef DRWAV_ZERO_MEMORY
1395#define DRWAV_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
1397#ifndef DRWAV_ZERO_OBJECT
1398#define DRWAV_ZERO_OBJECT(p) DRWAV_ZERO_MEMORY((p), sizeof(*p))
1401#define drwav_countof(x) (sizeof(x) / sizeof(x[0]))
1402#define drwav_align(x, a) ((((x) + (a) - 1) / (a)) * (a))
1403#define drwav_min(a, b) (((a) < (b)) ? (a) : (b))
1404#define drwav_max(a, b) (((a) > (b)) ? (a) : (b))
1405#define drwav_clamp(x, lo, hi) (drwav_max((lo), drwav_min((hi), (x))))
1406#define drwav_offset_ptr(p, offset) (((drwav_uint8*)(p)) + (offset))
1408#define DRWAV_MAX_SIMD_VECTOR_SIZE 32
1411#if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC))
1413#elif defined(__i386) || defined(_M_IX86)
1415#elif defined(__arm__) || defined(_M_ARM)
1422 #define DRWAV_INLINE __forceinline
1423#elif defined(__GNUC__)
1431 #if defined(__STRICT_ANSI__)
1432 #define DRWAV_GNUC_INLINE_HINT __inline__
1434 #define DRWAV_GNUC_INLINE_HINT inline
1437 #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
1438 #define DRWAV_INLINE DRWAV_GNUC_INLINE_HINT __attribute__((always_inline))
1440 #define DRWAV_INLINE DRWAV_GNUC_INLINE_HINT
1442#elif defined(__WATCOMC__)
1443 #define DRWAV_INLINE __inline
1445 #define DRWAV_INLINE
1450#if defined(SIZE_MAX)
1451 #define DRWAV_SIZE_MAX SIZE_MAX
1453 #if defined(_WIN64) || defined(_LP64) || defined(__LP64__)
1454 #define DRWAV_SIZE_MAX ((drwav_uint64)0xFFFFFFFFFFFFFFFF)
1456 #define DRWAV_SIZE_MAX 0xFFFFFFFF
1462#define DRWAV_INT64_MIN ((drwav_int64) ((drwav_uint64)0x80000000 << 32))
1463#define DRWAV_INT64_MAX ((drwav_int64)(((drwav_uint64)0x7FFFFFFF << 32) | 0xFFFFFFFF))
1465#if defined(_MSC_VER) && _MSC_VER >= 1400
1466 #define DRWAV_HAS_BYTESWAP16_INTRINSIC
1467 #define DRWAV_HAS_BYTESWAP32_INTRINSIC
1468 #define DRWAV_HAS_BYTESWAP64_INTRINSIC
1469#elif defined(__clang__)
1470 #if defined(__has_builtin)
1471 #if __has_builtin(__builtin_bswap16)
1472 #define DRWAV_HAS_BYTESWAP16_INTRINSIC
1474 #if __has_builtin(__builtin_bswap32)
1475 #define DRWAV_HAS_BYTESWAP32_INTRINSIC
1477 #if __has_builtin(__builtin_bswap64)
1478 #define DRWAV_HAS_BYTESWAP64_INTRINSIC
1481#elif defined(__GNUC__)
1482 #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
1483 #define DRWAV_HAS_BYTESWAP32_INTRINSIC
1484 #define DRWAV_HAS_BYTESWAP64_INTRINSIC
1486 #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
1487 #define DRWAV_HAS_BYTESWAP16_INTRINSIC
1515#ifndef DRWAV_MAX_SAMPLE_RATE
1516#define DRWAV_MAX_SAMPLE_RATE 384000
1518#ifndef DRWAV_MAX_CHANNELS
1519#define DRWAV_MAX_CHANNELS 256
1521#ifndef DRWAV_MAX_BITS_PER_SAMPLE
1522#define DRWAV_MAX_BITS_PER_SAMPLE 64
1525static const drwav_uint8 drwavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00};
1526static const drwav_uint8 drwavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
1528static const drwav_uint8 drwavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
1529static const drwav_uint8 drwavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
1530static const drwav_uint8 drwavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
1534static DRWAV_INLINE
int drwav__is_little_endian(
void)
1536#if defined(DRWAV_X86) || defined(DRWAV_X64)
1538#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
1542 return (*(
char*)&n) == 1;
1550 for (i = 0; i < 16; ++i) {
1558#ifdef DRWAV_HAS_BYTESWAP16_INTRINSIC
1559 #if defined(_MSC_VER)
1560 return _byteswap_ushort(n);
1561 #elif defined(__GNUC__) || defined(__clang__)
1562 return __builtin_bswap16(n);
1564 #error "This compiler does not support the byte swap intrinsic."
1567 return ((n & 0xFF00) >> 8) |
1568 ((n & 0x00FF) << 8);
1574#ifdef DRWAV_HAS_BYTESWAP32_INTRINSIC
1575 #if defined(_MSC_VER)
1576 return _byteswap_ulong(n);
1577 #elif defined(__GNUC__) || defined(__clang__)
1578 #if defined(DRWAV_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(DRWAV_64BIT)
1581 __asm__ __volatile__ (
1582 #
if defined(DRWAV_64BIT)
1583 "rev %w[out], %w[in]" : [out]
"=r"(r) : [in]
"r"(n)
1585 "rev %[out], %[in]" : [out]
"=r"(r) : [in]
"r"(n)
1590 return __builtin_bswap32(n);
1593 #error "This compiler does not support the byte swap intrinsic."
1596 return ((n & 0xFF000000) >> 24) |
1597 ((n & 0x00FF0000) >> 8) |
1598 ((n & 0x0000FF00) << 8) |
1599 ((n & 0x000000FF) << 24);
1605#ifdef DRWAV_HAS_BYTESWAP64_INTRINSIC
1606 #if defined(_MSC_VER)
1607 return _byteswap_uint64(n);
1608 #elif defined(__GNUC__) || defined(__clang__)
1609 return __builtin_bswap64(n);
1611 #error "This compiler does not support the byte swap intrinsic."
1615 return ((n & ((
drwav_uint64)0xFF000000 << 32)) >> 56) |
1635 for (iSample = 0; iSample < sampleCount; iSample += 1) {
1636 pSamples[iSample] = drwav__bswap_s16(pSamples[iSample]);
1641static DRWAV_INLINE
void drwav__bswap_s24(
drwav_uint8* p)
1652 for (iSample = 0; iSample < sampleCount; iSample += 1) {
1654 drwav__bswap_s24(pSample);
1667 for (iSample = 0; iSample < sampleCount; iSample += 1) {
1668 pSamples[iSample] = drwav__bswap_s32(pSamples[iSample]);
1681 for (iSample = 0; iSample < sampleCount; iSample += 1) {
1682 pSamples[iSample] = drwav__bswap_s64(pSamples[iSample]);
1687static DRWAV_INLINE
float drwav__bswap_f32(
float n)
1694 x.i = drwav__bswap32(x.i);
1699static DRWAV_INLINE
void drwav__bswap_samples_f32(
float* pSamples,
drwav_uint64 sampleCount)
1702 for (iSample = 0; iSample < sampleCount; iSample += 1) {
1703 pSamples[iSample] = drwav__bswap_f32(pSamples[iSample]);
1708static DRWAV_INLINE
void drwav__bswap_samples(
void* pSamples,
drwav_uint64 sampleCount,
drwav_uint32 bytesPerSample)
1710 switch (bytesPerSample)
1718 drwav__bswap_samples_s16((
drwav_int16*)pSamples, sampleCount);
1722 drwav__bswap_samples_s24((
drwav_uint8*)pSamples, sampleCount);
1726 drwav__bswap_samples_s32((
drwav_int32*)pSamples, sampleCount);
1730 drwav__bswap_samples_s64((
drwav_int64*)pSamples, sampleCount);
1764 if (drwav_is_container_be(container)) {
1765 return drwav_bytes_to_u16_be(data);
1767 return drwav_bytes_to_u16_le(data);
1784 if (drwav_is_container_be(container)) {
1785 return drwav_bytes_to_u32_be(data);
1787 return drwav_bytes_to_u32_le(data);
1799 int sign = exponent >> 15;
1805 if (exponent == 0 && significand == 0) {
1807 }
else if (exponent == 0x7FFF) {
1808 return sign ? DRWAV_INT64_MIN : DRWAV_INT64_MAX;
1813 if (exponent > 63) {
1814 return sign ? DRWAV_INT64_MIN : DRWAV_INT64_MAX;
1815 }
else if (exponent < 1) {
1819 significand >>= (63 - exponent);
1829DRWAV_PRIVATE void* drwav__malloc_default(
size_t sz,
void* pUserData)
1832 return DRWAV_MALLOC(sz);
1835DRWAV_PRIVATE void* drwav__realloc_default(
void* p,
size_t sz,
void* pUserData)
1838 return DRWAV_REALLOC(p, sz);
1841DRWAV_PRIVATE void drwav__free_default(
void* p,
void* pUserData)
1850 if (pAllocationCallbacks == NULL) {
1854 if (pAllocationCallbacks->
onMalloc != NULL) {
1859 if (pAllocationCallbacks->
onRealloc != NULL) {
1868 if (pAllocationCallbacks == NULL) {
1872 if (pAllocationCallbacks->
onRealloc != NULL) {
1877 if (pAllocationCallbacks->
onMalloc != NULL && pAllocationCallbacks->
onFree != NULL) {
1886 DRWAV_COPY_MEMORY(p2, p, szOld);
1898 if (p == NULL || pAllocationCallbacks == NULL) {
1902 if (pAllocationCallbacks->
onFree != NULL) {
1910 if (pAllocationCallbacks != NULL) {
1912 return *pAllocationCallbacks;
1917 allocationCallbacks.
onMalloc = drwav__malloc_default;
1918 allocationCallbacks.
onRealloc = drwav__realloc_default;
1919 allocationCallbacks.
onFree = drwav__free_default;
1920 return allocationCallbacks;
1934 return (
unsigned int)(chunkSize % 2);
1939 return (
unsigned int)(chunkSize % 8);
1951 if (onRead(pUserData, pHeaderOut->
id.
fourcc, 4) != 4) {
1955 if (onRead(pUserData, sizeInBytes, 4) != 4) {
1959 pHeaderOut->
sizeInBytes = drwav_bytes_to_u32_ex(sizeInBytes, container);
1962 *pRunningBytesReadOut += 8;
1966 if (onRead(pUserData, pHeaderOut->
id.
guid, 16) != 16) {
1970 if (onRead(pUserData, sizeInBytes, 8) != 8) {
1976 *pRunningBytesReadOut += 24;
1987 while (bytesRemainingToSeek > 0) {
1988 if (bytesRemainingToSeek > 0x7FFFFFFF) {
1992 bytesRemainingToSeek -= 0x7FFFFFFF;
1994 if (!onSeek(pUserData, (
int)bytesRemainingToSeek,
DRWAV_SEEK_CUR)) {
1997 bytesRemainingToSeek = 0;
2006 if (offset <= 0x7FFFFFFF) {
2014 offset -= 0x7FFFFFFF;
2017 if (offset <= 0x7FFFFFFF) {
2024 offset -= 0x7FFFFFFF;
2037 DRWAV_ASSERT(onRead != NULL);
2038 DRWAV_ASSERT(pCursor != NULL);
2040 bytesRead = onRead(pUserData, pBufferOut, bytesToRead);
2041 *pCursor += bytesRead;
2048 DRWAV_ASSERT(onSeek != NULL);
2049 DRWAV_ASSERT(pCursor != NULL);
2051 if (!onSeek(pUserData, offset, origin)) {
2066#define DRWAV_SMPL_BYTES 36
2067#define DRWAV_SMPL_LOOP_BYTES 24
2068#define DRWAV_INST_BYTES 7
2069#define DRWAV_ACID_BYTES 24
2070#define DRWAV_CUE_BYTES 4
2071#define DRWAV_BEXT_BYTES 602
2072#define DRWAV_BEXT_DESCRIPTION_BYTES 256
2073#define DRWAV_BEXT_ORIGINATOR_NAME_BYTES 32
2074#define DRWAV_BEXT_ORIGINATOR_REF_BYTES 32
2075#define DRWAV_BEXT_RESERVED_BYTES 180
2076#define DRWAV_BEXT_UMID_BYTES 64
2077#define DRWAV_CUE_POINT_BYTES 24
2078#define DRWAV_LIST_LABEL_OR_NOTE_BYTES 4
2079#define DRWAV_LIST_LABELLED_TEXT_BYTES 20
2081#define DRWAV_METADATA_ALIGNMENT 8
2085 drwav__metadata_parser_stage_count,
2086 drwav__metadata_parser_stage_read
2087} drwav__metadata_parser_stage;
2093 void *pReadSeekUserData;
2094 drwav__metadata_parser_stage stage;
2101} drwav__metadata_parser;
2103DRWAV_PRIVATE size_t drwav__metadata_memory_capacity(drwav__metadata_parser* pParser)
2106 if (cap > DRWAV_SIZE_MAX) {
2120 pParser->pDataCursor += align - modulo;
2124 pResult = pParser->pDataCursor;
2130 DRWAV_ASSERT((pResult + size) <= (pParser->pData + drwav__metadata_memory_capacity(pParser)));
2132 pParser->pDataCursor += size;
2136DRWAV_PRIVATE void drwav__metadata_request_extra_memory_for_stage_2(drwav__metadata_parser* pParser,
size_t bytes,
size_t align)
2138 size_t extra = bytes + (align ? (align - 1) : 0);
2139 pParser->extraCapacity += extra;
2144 if (pParser->extraCapacity != 0 || pParser->metadataCount != 0) {
2145 pAllocationCallbacks->
onFree(pParser->pData, pAllocationCallbacks->
pUserData);
2147 pParser->pData = (
drwav_uint8*)pAllocationCallbacks->
onMalloc(drwav__metadata_memory_capacity(pParser), pAllocationCallbacks->
pUserData);
2148 pParser->pDataCursor = pParser->pData;
2150 if (pParser->pData == NULL) {
2160 pParser->metadataCursor = 0;
2166DRWAV_PRIVATE size_t drwav__metadata_parser_read(drwav__metadata_parser* pParser,
void* pBufferOut,
size_t bytesToRead,
drwav_uint64* pCursor)
2168 if (pCursor != NULL) {
2169 return drwav__on_read(pParser->onRead, pParser->pReadSeekUserData, pBufferOut, bytesToRead, pCursor);
2171 return pParser->onRead(pParser->pReadSeekUserData, pBufferOut, bytesToRead);
2179 size_t bytesJustRead;
2181 if (pMetadata == NULL) {
2185 bytesJustRead = drwav__metadata_parser_read(pParser, smplHeaderData,
sizeof(smplHeaderData), &totalBytesRead);
2187 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2188 DRWAV_ASSERT(pChunkHeader != NULL);
2190 if (pMetadata != NULL && bytesJustRead ==
sizeof(smplHeaderData)) {
2204 calculatedLoopCount = (pChunkHeader->
sizeInBytes - DRWAV_SMPL_BYTES) / DRWAV_SMPL_LOOP_BYTES;
2205 if (loopCount != calculatedLoopCount) {
2206 return totalBytesRead;
2229 bytesJustRead = drwav__metadata_parser_read(pParser, smplLoopData,
sizeof(smplLoopData), &totalBytesRead);
2231 if (bytesJustRead ==
sizeof(smplLoopData)) {
2257 DRWAV_ZERO_OBJECT(&pMetadata->
data.
smpl);
2261 return totalBytesRead;
2266 drwav_uint8 cueHeaderSectionData[DRWAV_CUE_BYTES];
2268 size_t bytesJustRead;
2270 if (pMetadata == NULL) {
2274 bytesJustRead = drwav__metadata_parser_read(pParser, cueHeaderSectionData,
sizeof(cueHeaderSectionData), &totalBytesRead);
2276 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2278 if (bytesJustRead ==
sizeof(cueHeaderSectionData)) {
2295 bytesJustRead = drwav__metadata_parser_read(pParser, cuePointData,
sizeof(cuePointData), &totalBytesRead);
2297 if (bytesJustRead ==
sizeof(cuePointData)) {
2315 return totalBytesRead;
2323 if (pMetadata == NULL) {
2327 bytesRead = drwav__metadata_parser_read(pParser, instData,
sizeof(instData), NULL);
2329 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2331 if (bytesRead ==
sizeof(instData)) {
2350 if (pMetadata == NULL) {
2354 bytesRead = drwav__metadata_parser_read(pParser, acidData,
sizeof(acidData), NULL);
2356 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2358 if (bytesRead ==
sizeof(acidData)) {
2384DRWAV_PRIVATE size_t drwav__strlen_clamped(
const char* str,
size_t maxToRead)
2388 while (*str++ && result < maxToRead) {
2395DRWAV_PRIVATE char* drwav__metadata_copy_string(drwav__metadata_parser* pParser,
const char* str,
size_t maxToRead)
2397 size_t len = drwav__strlen_clamped(str, maxToRead);
2400 char* result = (
char*)drwav__metadata_get_memory(pParser, len + 1, 1);
2401 DRWAV_ASSERT(result != NULL);
2403 DRWAV_COPY_MEMORY(result, str, len);
2414 const void* pBuffer;
2417} drwav_buffer_reader;
2419DRWAV_PRIVATE drwav_result drwav_buffer_reader_init(
const void* pBuffer,
size_t sizeInBytes, drwav_buffer_reader* pReader)
2421 DRWAV_ASSERT(pBuffer != NULL);
2422 DRWAV_ASSERT(pReader != NULL);
2424 DRWAV_ZERO_OBJECT(pReader);
2426 pReader->pBuffer = pBuffer;
2427 pReader->sizeInBytes = sizeInBytes;
2428 pReader->cursor = 0;
2433DRWAV_PRIVATE const void* drwav_buffer_reader_ptr(
const drwav_buffer_reader* pReader)
2435 DRWAV_ASSERT(pReader != NULL);
2437 return drwav_offset_ptr(pReader->pBuffer, pReader->cursor);
2442 DRWAV_ASSERT(pReader != NULL);
2444 if (pReader->cursor + bytesToSeek > pReader->sizeInBytes) {
2448 pReader->cursor += bytesToSeek;
2453DRWAV_PRIVATE drwav_result drwav_buffer_reader_read(drwav_buffer_reader* pReader,
void* pDst,
size_t bytesToRead,
size_t* pBytesRead)
2456 size_t bytesRemaining;
2458 DRWAV_ASSERT(pReader != NULL);
2460 if (pBytesRead != NULL) {
2464 bytesRemaining = (pReader->sizeInBytes - pReader->cursor);
2465 if (bytesToRead > bytesRemaining) {
2466 bytesToRead = bytesRemaining;
2471 result = drwav_buffer_reader_seek(pReader, bytesToRead);
2474 DRWAV_COPY_MEMORY(pDst, drwav_buffer_reader_ptr(pReader), bytesToRead);
2475 pReader->cursor += bytesToRead;
2478 DRWAV_ASSERT(pReader->cursor <= pReader->sizeInBytes);
2481 if (pBytesRead != NULL) {
2482 *pBytesRead = bytesToRead;
2495 DRWAV_ASSERT(pReader != NULL);
2496 DRWAV_ASSERT(pDst != NULL);
2500 result = drwav_buffer_reader_read(pReader, data,
sizeof(*pDst), &bytesRead);
2501 if (result !=
DRWAV_SUCCESS || bytesRead !=
sizeof(*pDst)) {
2516 DRWAV_ASSERT(pReader != NULL);
2517 DRWAV_ASSERT(pDst != NULL);
2521 result = drwav_buffer_reader_read(pReader, data,
sizeof(*pDst), &bytesRead);
2522 if (result !=
DRWAV_SUCCESS || bytesRead !=
sizeof(*pDst)) {
2536 size_t bytesRead = drwav__metadata_parser_read(pParser, bextData,
sizeof(bextData), NULL);
2538 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2540 if (bytesRead ==
sizeof(bextData)) {
2541 drwav_buffer_reader reader;
2548 if (drwav_buffer_reader_init(bextData, bytesRead, &reader) ==
DRWAV_SUCCESS) {
2549 pMetadata->
data.
bext.
pDescription = drwav__metadata_copy_string(pParser, (
const char*)drwav_buffer_reader_ptr(&reader), DRWAV_BEXT_DESCRIPTION_BYTES);
2550 drwav_buffer_reader_seek(&reader, DRWAV_BEXT_DESCRIPTION_BYTES);
2552 pMetadata->
data.
bext.
pOriginatorName = drwav__metadata_copy_string(pParser, (
const char*)drwav_buffer_reader_ptr(&reader), DRWAV_BEXT_ORIGINATOR_NAME_BYTES);
2553 drwav_buffer_reader_seek(&reader, DRWAV_BEXT_ORIGINATOR_NAME_BYTES);
2555 pMetadata->
data.
bext.
pOriginatorReference = drwav__metadata_copy_string(pParser, (
const char*)drwav_buffer_reader_ptr(&reader), DRWAV_BEXT_ORIGINATOR_REF_BYTES);
2556 drwav_buffer_reader_seek(&reader, DRWAV_BEXT_ORIGINATOR_REF_BYTES);
2561 drwav_buffer_reader_read_u32(&reader, &timeReferenceLow);
2562 drwav_buffer_reader_read_u32(&reader, &timeReferenceHigh);
2567 pMetadata->
data.
bext.
pUMID = drwav__metadata_get_memory(pParser, DRWAV_BEXT_UMID_BYTES, 1);
2568 drwav_buffer_reader_read(&reader, pMetadata->
data.
bext.
pUMID, DRWAV_BEXT_UMID_BYTES, NULL);
2576 DRWAV_ASSERT((drwav_offset_ptr(drwav_buffer_reader_ptr(&reader), DRWAV_BEXT_RESERVED_BYTES)) == (bextData + DRWAV_BEXT_BYTES));
2578 extraBytes = (
size_t)(chunkSize - DRWAV_BEXT_BYTES);
2579 if (extraBytes > 0) {
2583 bytesRead += drwav__metadata_parser_read(pParser, pMetadata->
data.
bext.
pCodingHistory, extraBytes, NULL);
2597 drwav_uint8 cueIDBuffer[DRWAV_LIST_LABEL_OR_NOTE_BYTES];
2599 size_t bytesJustRead = drwav__metadata_parser_read(pParser, cueIDBuffer,
sizeof(cueIDBuffer), &totalBytesRead);
2601 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2603 if (bytesJustRead ==
sizeof(cueIDBuffer)) {
2606 pMetadata->
type = type;
2609 sizeIncludingNullTerminator = (
drwav_uint32)chunkSize - DRWAV_LIST_LABEL_OR_NOTE_BYTES;
2610 if (sizeIncludingNullTerminator > 0) {
2612 pMetadata->
data.
labelOrNote.
pString = (
char*)drwav__metadata_get_memory(pParser, sizeIncludingNullTerminator, 1);
2615 drwav__metadata_parser_read(pParser, pMetadata->
data.
labelOrNote.
pString, sizeIncludingNullTerminator, &totalBytesRead);
2622 return totalBytesRead;
2629 size_t bytesJustRead = drwav__metadata_parser_read(pParser,
buffer,
sizeof(
buffer), &totalBytesRead);
2631 DRWAV_ASSERT(pParser->stage == drwav__metadata_parser_stage_read);
2633 if (bytesJustRead ==
sizeof(
buffer)) {
2648 sizeIncludingNullTerminator = (
drwav_uint32)chunkSize - DRWAV_LIST_LABELLED_TEXT_BYTES;
2649 if (sizeIncludingNullTerminator > 0) {
2661 return totalBytesRead;
2669 if (pParser->stage == drwav__metadata_parser_stage_count) {
2670 pParser->metadataCount += 1;
2671 drwav__metadata_request_extra_memory_for_stage_2(pParser, stringSizeWithNullTerminator, 1);
2673 drwav_metadata* pMetadata = &pParser->pMetadata[pParser->metadataCursor];
2674 pMetadata->
type = type;
2675 if (stringSizeWithNullTerminator > 0) {
2677 pMetadata->
data.
infoText.
pString = (
char*)drwav__metadata_get_memory(pParser, stringSizeWithNullTerminator, 1);
2680 bytesRead = drwav__metadata_parser_read(pParser, pMetadata->
data.
infoText.
pString, (
size_t)stringSizeWithNullTerminator, NULL);
2681 if (bytesRead == chunkSize) {
2682 pParser->metadataCursor += 1;
2689 pParser->metadataCursor += 1;
2708 if (pParser->stage == drwav__metadata_parser_stage_count) {
2709 pParser->metadataCount += 1;
2710 drwav__metadata_request_extra_memory_for_stage_2(pParser, (
size_t)chunkSize, 1);
2712 drwav_metadata* pMetadata = &pParser->pMetadata[pParser->metadataCursor];
2725 pParser->metadataCursor += 1;
2745 if (pChunkHeader->
sizeInBytes >= DRWAV_SMPL_BYTES) {
2746 if (pParser->stage == drwav__metadata_parser_stage_count) {
2748 size_t bytesJustRead;
2750 if (!pParser->onSeek(pParser->pReadSeekUserData, 28,
DRWAV_SEEK_CUR)) {
2755 bytesJustRead = drwav__metadata_parser_read(pParser,
buffer,
sizeof(
buffer), &bytesRead);
2756 if (bytesJustRead ==
sizeof(
buffer)) {
2761 calculatedLoopCount = (pChunkHeader->
sizeInBytes - DRWAV_SMPL_BYTES) / DRWAV_SMPL_LOOP_BYTES;
2762 if (calculatedLoopCount == loopCount) {
2763 bytesJustRead = drwav__metadata_parser_read(pParser,
buffer,
sizeof(
buffer), &bytesRead);
2764 if (bytesJustRead ==
sizeof(
buffer)) {
2767 pParser->metadataCount += 1;
2768 drwav__metadata_request_extra_memory_for_stage_2(pParser,
sizeof(
drwav_smpl_loop) * loopCount, DRWAV_METADATA_ALIGNMENT);
2769 drwav__metadata_request_extra_memory_for_stage_2(pParser, samplerSpecificDataSizeInBytes, 1);
2776 bytesRead = drwav__read_smpl_to_metadata_obj(pParser, pChunkHeader, &pParser->pMetadata[pParser->metadataCursor]);
2778 pParser->metadataCursor += 1;
2787 if (pChunkHeader->
sizeInBytes == DRWAV_INST_BYTES) {
2788 if (pParser->stage == drwav__metadata_parser_stage_count) {
2789 pParser->metadataCount += 1;
2791 bytesRead = drwav__read_inst_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor]);
2793 pParser->metadataCursor += 1;
2802 if (pChunkHeader->
sizeInBytes == DRWAV_ACID_BYTES) {
2803 if (pParser->stage == drwav__metadata_parser_stage_count) {
2804 pParser->metadataCount += 1;
2806 bytesRead = drwav__read_acid_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor]);
2808 pParser->metadataCursor += 1;
2817 if (pChunkHeader->
sizeInBytes >= DRWAV_CUE_BYTES) {
2818 if (pParser->stage == drwav__metadata_parser_stage_count) {
2821 pParser->metadataCount += 1;
2822 cueCount = (
size_t)(pChunkHeader->
sizeInBytes - DRWAV_CUE_BYTES) / DRWAV_CUE_POINT_BYTES;
2823 drwav__metadata_request_extra_memory_for_stage_2(pParser,
sizeof(
drwav_cue_point) * cueCount, DRWAV_METADATA_ALIGNMENT);
2825 bytesRead = drwav__read_cue_to_metadata_obj(pParser, pChunkHeader, &pParser->pMetadata[pParser->metadataCursor]);
2827 pParser->metadataCursor += 1;
2836 if (pChunkHeader->
sizeInBytes >= DRWAV_BEXT_BYTES) {
2837 if (pParser->stage == drwav__metadata_parser_stage_count) {
2839 char buffer[DRWAV_BEXT_DESCRIPTION_BYTES + 1];
2840 size_t allocSizeNeeded = DRWAV_BEXT_UMID_BYTES;
2841 size_t bytesJustRead;
2843 buffer[DRWAV_BEXT_DESCRIPTION_BYTES] =
'\0';
2844 bytesJustRead = drwav__metadata_parser_read(pParser,
buffer, DRWAV_BEXT_DESCRIPTION_BYTES, &bytesRead);
2845 if (bytesJustRead != DRWAV_BEXT_DESCRIPTION_BYTES) {
2848 allocSizeNeeded += drwav__strlen(
buffer) + 1;
2850 buffer[DRWAV_BEXT_ORIGINATOR_NAME_BYTES] =
'\0';
2851 bytesJustRead = drwav__metadata_parser_read(pParser,
buffer, DRWAV_BEXT_ORIGINATOR_NAME_BYTES, &bytesRead);
2852 if (bytesJustRead != DRWAV_BEXT_ORIGINATOR_NAME_BYTES) {
2855 allocSizeNeeded += drwav__strlen(
buffer) + 1;
2857 buffer[DRWAV_BEXT_ORIGINATOR_REF_BYTES] =
'\0';
2858 bytesJustRead = drwav__metadata_parser_read(pParser,
buffer, DRWAV_BEXT_ORIGINATOR_REF_BYTES, &bytesRead);
2859 if (bytesJustRead != DRWAV_BEXT_ORIGINATOR_REF_BYTES) {
2862 allocSizeNeeded += drwav__strlen(
buffer) + 1;
2865 drwav__metadata_request_extra_memory_for_stage_2(pParser, allocSizeNeeded, 1);
2867 pParser->metadataCount += 1;
2869 bytesRead = drwav__read_bext_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], pChunkHeader->
sizeInBytes);
2871 pParser->metadataCursor += 1;
2881 while (bytesRead < pChunkHeader->sizeInBytes) {
2886 drwav_uint64 bytesJustRead = drwav__metadata_parser_read(pParser, subchunkId,
sizeof(subchunkId), &bytesRead);
2887 if (bytesJustRead !=
sizeof(subchunkId)) {
2910 bytesJustRead = drwav__metadata_parser_read(pParser, subchunkSizeBuffer,
sizeof(subchunkSizeBuffer), &bytesRead);
2911 if (bytesJustRead !=
sizeof(subchunkSizeBuffer)) {
2917 if (subchunkDataSize >= DRWAV_LIST_LABEL_OR_NOTE_BYTES) {
2918 drwav_uint64 stringSizeWithNullTerm = subchunkDataSize - DRWAV_LIST_LABEL_OR_NOTE_BYTES;
2919 if (pParser->stage == drwav__metadata_parser_stage_count) {
2920 pParser->metadataCount += 1;
2921 drwav__metadata_request_extra_memory_for_stage_2(pParser, (
size_t)stringSizeWithNullTerm, 1);
2924 if (subchunkBytesRead == subchunkDataSize) {
2925 pParser->metadataCursor += 1;
2934 if (subchunkDataSize >= DRWAV_LIST_LABELLED_TEXT_BYTES) {
2935 drwav_uint64 stringSizeWithNullTerminator = subchunkDataSize - DRWAV_LIST_LABELLED_TEXT_BYTES;
2936 if (pParser->stage == drwav__metadata_parser_stage_count) {
2937 pParser->metadataCount += 1;
2938 drwav__metadata_request_extra_memory_for_stage_2(pParser, (
size_t)stringSizeWithNullTerminator, 1);
2940 subchunkBytesRead = drwav__read_list_labelled_cue_region_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], subchunkDataSize);
2941 if (subchunkBytesRead == subchunkDataSize) {
2942 pParser->metadataCursor += 1;
2979 subchunkBytesRead = drwav__metadata_process_unknown_chunk(pParser, subchunkId, subchunkDataSize, listType);
2982 bytesRead += subchunkBytesRead;
2983 DRWAV_ASSERT(subchunkBytesRead <= subchunkDataSize);
2985 if (subchunkBytesRead < subchunkDataSize) {
2986 drwav_uint64 bytesToSeek = subchunkDataSize - subchunkBytesRead;
2988 if (!pParser->onSeek(pParser->pReadSeekUserData, (
int)bytesToSeek,
DRWAV_SEEK_CUR)) {
2991 bytesRead += bytesToSeek;
2994 if ((subchunkDataSize % 2) == 1) {
2995 if (!pParser->onSeek(pParser->pReadSeekUserData, 1,
DRWAV_SEEK_CUR)) {
3031 return bytesPerFrame;
3049 if (pWav == NULL || onRead == NULL || onSeek == NULL) {
3053 DRWAV_ZERO_MEMORY(pWav,
sizeof(*pWav));
3057 pWav->
pUserData = pReadSeekTellUserData;
3058 pWav->
allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
3075 unsigned short translatedFormatTag;
3079 drwav__metadata_parser metadataParser;
3088 DRWAV_ZERO_OBJECT(&fmt);
3091 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, riff,
sizeof(riff), &cursor) !=
sizeof(riff)) {
3110 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, riff2,
sizeof(riff2), &cursor) !=
sizeof(riff2)) {
3114 for (i = 0; i < 12; ++i) {
3115 if (riff2[i] != drwavGUID_W64_RIFF[i+4]) {
3132 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, chunkSizeBytes,
sizeof(chunkSizeBytes), &cursor) !=
sizeof(chunkSizeBytes)) {
3137 if (drwav_bytes_to_u32_ex(chunkSizeBytes, pWav->
container) < 36) {
3147 if (drwav_bytes_to_u32_le(chunkSizeBytes) != 0xFFFFFFFF) {
3154 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, wave,
sizeof(wave), &cursor) !=
sizeof(wave)) {
3165 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, chunkSizeBytes,
sizeof(chunkSizeBytes), &cursor) !=
sizeof(chunkSizeBytes)) {
3173 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, wave,
sizeof(wave), &cursor) !=
sizeof(wave)) {
3184 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, chunkSizeBytes,
sizeof(chunkSizeBytes), &cursor) !=
sizeof(chunkSizeBytes)) {
3188 if (drwav_bytes_to_u32_be(chunkSizeBytes) < 18) {
3192 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, aiff,
sizeof(aiff), &cursor) !=
sizeof(aiff)) {
3228 bytesRemainingInChunk -= 8;
3233 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, sizeBytes,
sizeof(sizeBytes), &cursor) !=
sizeof(sizeBytes)) {
3236 bytesRemainingInChunk -= 8;
3241 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, sizeBytes,
sizeof(sizeBytes), &cursor) !=
sizeof(sizeBytes)) {
3244 bytesRemainingInChunk -= 8;
3249 if (!drwav__seek_forward(pWav->
onSeek, bytesRemainingInChunk, pWav->
pUserData)) {
3252 cursor += bytesRemainingInChunk;
3256 metadataStartPos = cursor;
3272 DRWAV_ZERO_MEMORY(&metadataParser,
sizeof(metadataParser));
3273 if (isProcessingMetadata) {
3274 metadataParser.onRead = pWav->
onRead;
3275 metadataParser.onSeek = pWav->
onSeek;
3276 metadataParser.pReadSeekUserData = pWav->
pUserData;
3277 metadataParser.stage = drwav__metadata_parser_stage_count;
3302 if (!sequential && onChunk != NULL) {
3309 if (callbackBytesRead > 0) {
3326 if (pWav->
onRead(pWav->
pUserData, fmtData,
sizeof(fmtData)) !=
sizeof(fmtData)) {
3329 cursor +=
sizeof(fmtData);
3345 int bytesReadSoFar = 0;
3347 if (pWav->
onRead(pWav->
pUserData, fmt_cbSize,
sizeof(fmt_cbSize)) !=
sizeof(fmt_cbSize)) {
3350 cursor +=
sizeof(fmt_cbSize);
3352 bytesReadSoFar = 18;
3372 drwav_bytes_to_guid(fmtext + 6, fmt.
subFormat);
3409 dataChunkSize = chunkSize;
3413 if (sequential || !isProcessingMetadata) {
3420 cursor += chunkSize;
3431 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, &sampleCount, 4, &cursor) != 4) {
3442 sampleCountFromFactChunk = drwav_bytes_to_u32_ex(sampleCount, pWav->
container);
3444 sampleCountFromFactChunk = 0;
3447 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, &sampleCountFromFactChunk, 8, &cursor) != 8) {
3461 cursor += chunkSize;
3479 if (isAIFCFormType) {
3480 commDataBytesToRead = 24;
3485 commDataBytesToRead = 18;
3491 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, commData, commDataBytesToRead, &cursor) != commDataBytesToRead) {
3496 channels = drwav_bytes_to_u16_ex (commData + 0, pWav->
container);
3497 frameCount = drwav_bytes_to_u32_ex (commData + 2, pWav->
container);
3498 sampleSizeInBits = drwav_bytes_to_u16_ex (commData + 6, pWav->
container);
3499 sampleRate = drwav_aiff_extented_to_s64(commData + 8);
3501 if (sampleRate < 0 || sampleRate > 0xFFFFFFFF) {
3505 if (isAIFCFormType) {
3514 if (sampleSizeInBits == 8) {
3528 sampleSizeInBits = 4;
3534 (void)compressionFormat;
3535 (void)sampleSizeInBits;
3546 aiffFrameCount = frameCount;
3576 if (isAIFCFormType) {
3580 cursor += (chunkSize - commDataBytesToRead);
3595 if (drwav__on_read(pWav->
onRead, pWav->
pUserData, offsetAndBlockSizeData,
sizeof(offsetAndBlockSizeData), &cursor) !=
sizeof(offsetAndBlockSizeData)) {
3600 offset = drwav_bytes_to_u32_ex(offsetAndBlockSizeData + 0, pWav->
container);
3604 dataChunkSize = chunkSize;
3605 if (dataChunkSize > offset) {
3606 dataChunkSize -= offset;
3612 if (foundChunk_fmt) {
3637 chunkSize -=
sizeof(offsetAndBlockSizeData);
3642 cursor += chunkSize;
3650 if (isProcessingMetadata) {
3665 cursor += chunkSize;
3669 if (!foundChunk_fmt || !foundChunk_data) {
3703 if (isProcessingMetadata && metadataParser.metadataCount > 0) {
3713 metadataParser.stage = drwav__metadata_parser_stage_read;
3734 pWav->
pMetadata = metadataParser.pMetadata;
3771 dataChunkSize += bytesRead;
3773 if (bytesRead <
sizeof(temp)) {
3802 if (!drwav__is_compressed_format_tag(translatedFormatTag)) {
3803 drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
3804 if (bytesPerFrame > 0) {
3805 dataChunkSize -= (dataChunkSize % bytesPerFrame);
3812 if (sampleCountFromFactChunk != 0) {
3814 }
else if (aiffFrameCount != 0) {
3817 drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
3818 if (bytesPerFrame == 0) {
3830 if ((blockCount * fmt.
blockAlign) < dataChunkSize) {
3835 totalBlockHeaderSizeInBytes = blockCount * (6*fmt.
channels);
3843 if ((blockCount * fmt.
blockAlign) < dataChunkSize) {
3848 totalBlockHeaderSizeInBytes = blockCount * (4*fmt.
channels);
3865 if (drwav_get_bytes_per_pcm_frame(pWav) == 0) {
3870#ifdef DR_WAV_LIBSNDFILE_COMPAT
3894 return drwav_init_ex(pWav, onRead, onSeek, onTell, NULL, pUserData, NULL, 0, pAllocationCallbacks);
3899 if (!drwav_preinit(pWav, onRead, onSeek, onTell, pReadSeekTellUserData, pAllocationCallbacks)) {
3903 return drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
3908 if (!drwav_preinit(pWav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
3928 DRWAV_ASSERT(pWav != NULL);
3929 DRWAV_ASSERT(pWav->
onWrite != NULL);
3937 DRWAV_ASSERT(pWav != NULL);
3938 DRWAV_ASSERT(pWav->
onWrite != NULL);
3945 DRWAV_ASSERT(pWav != NULL);
3946 DRWAV_ASSERT(pWav->
onWrite != NULL);
3948 if (!drwav__is_little_endian()) {
3949 value = drwav__bswap16(value);
3952 return drwav__write(pWav, &value, 2);
3957 DRWAV_ASSERT(pWav != NULL);
3958 DRWAV_ASSERT(pWav->
onWrite != NULL);
3960 if (!drwav__is_little_endian()) {
3961 value = drwav__bswap32(value);
3964 return drwav__write(pWav, &value, 4);
3969 DRWAV_ASSERT(pWav != NULL);
3970 DRWAV_ASSERT(pWav->
onWrite != NULL);
3972 if (!drwav__is_little_endian()) {
3973 value = drwav__bswap64(value);
3976 return drwav__write(pWav, &value, 8);
3986 DRWAV_ASSERT(pWav != NULL);
3987 DRWAV_ASSERT(pWav->
onWrite != NULL);
3991 if (!drwav__is_little_endian()) {
3992 u.u32 = drwav__bswap32(u.u32);
3995 return drwav__write(pWav, &u.u32, 4);
3998DRWAV_PRIVATE size_t drwav__write_or_count(
drwav* pWav,
const void* pData,
size_t dataSize)
4004 return drwav__write(pWav, pData, dataSize);
4013 return drwav__write_byte(pWav,
byte);
4022 return drwav__write_u16ne_to_le(pWav, value);
4031 return drwav__write_u32ne_to_le(pWav, value);
4041 return drwav__write_u64ne_to_le(pWav, value);
4051 return drwav__write_f32ne_to_le(pWav, value);
4054DRWAV_PRIVATE size_t drwav__write_or_count_string_to_fixed_size_buf(
drwav* pWav,
char* str,
size_t bufFixedSize)
4059 return bufFixedSize;
4062 len = drwav__strlen_clamped(str, bufFixedSize);
4063 drwav__write_or_count(pWav, str, len);
4065 if (len < bufFixedSize) {
4067 for (i = 0; i < bufFixedSize - len; ++i) {
4068 drwav__write_byte(pWav, 0);
4072 return bufFixedSize;
4079 size_t bytesWritten = 0;
4084 if (pMetadatas == NULL || metadataCount == 0) {
4088 for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
4100 switch (pMetadata->
type) {
4107 bytesWritten += drwav__write_or_count(pWav,
"smpl", 4);
4108 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4111 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
smpl.
productId);
4115 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
smpl.
smpteFormat);
4116 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
smpl.
smpteOffset);
4122 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
smpl.
pLoops[iLoop].
type);
4136 chunkSize = DRWAV_INST_BYTES;
4138 bytesWritten += drwav__write_or_count(pWav,
"inst", 4);
4139 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4143 bytesWritten += drwav__write_or_count(pWav, &pMetadata->
data.
inst.
lowNote, 1);
4144 bytesWritten += drwav__write_or_count(pWav, &pMetadata->
data.
inst.
highNote, 1);
4155 bytesWritten += drwav__write_or_count(pWav,
"cue ", 4);
4156 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4159 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
cue.
pCuePoints[iCuePoint].
id);
4170 chunkSize = DRWAV_ACID_BYTES;
4172 bytesWritten += drwav__write_or_count(pWav,
"acid", 4);
4173 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4174 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
acid.
flags);
4176 bytesWritten += drwav__write_or_count_u16ne_to_le(pWav, pMetadata->
data.
acid.
reserved1);
4177 bytesWritten += drwav__write_or_count_f32ne_to_le(pWav, pMetadata->
data.
acid.
reserved2);
4178 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, pMetadata->
data.
acid.
numBeats);
4181 bytesWritten += drwav__write_or_count_f32ne_to_le(pWav, pMetadata->
data.
acid.
tempo);
4186 char reservedBuf[DRWAV_BEXT_RESERVED_BYTES];
4192 bytesWritten += drwav__write_or_count(pWav,
"bext", 4);
4193 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4195 bytesWritten += drwav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->
data.
bext.
pDescription, DRWAV_BEXT_DESCRIPTION_BYTES);
4196 bytesWritten += drwav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->
data.
bext.
pOriginatorName, DRWAV_BEXT_ORIGINATOR_NAME_BYTES);
4197 bytesWritten += drwav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->
data.
bext.
pOriginatorReference, DRWAV_BEXT_ORIGINATOR_REF_BYTES);
4203 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, timeReferenceLow);
4204 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, timeReferenceHigh);
4206 bytesWritten += drwav__write_or_count_u16ne_to_le(pWav, pMetadata->
data.
bext.
version);
4207 bytesWritten += drwav__write_or_count(pWav, pMetadata->
data.
bext.
pUMID, DRWAV_BEXT_UMID_BYTES);
4214 DRWAV_ZERO_MEMORY(reservedBuf,
sizeof(reservedBuf));
4215 bytesWritten += drwav__write_or_count(pWav, reservedBuf,
sizeof(reservedBuf));
4227 bytesWritten += drwav__write_or_count(pWav, pMetadata->
data.
unknown.
id, 4);
4228 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4235 if ((chunkSize % 2) != 0) {
4236 bytesWritten += drwav__write_or_count_byte(pWav, 0);
4242 for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
4253 if ((chunkSize % 2) != 0) {
4258 bytesWritten += drwav__write_or_count(pWav,
"LIST", 4);
4259 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4260 bytesWritten += drwav__write_or_count(pWav,
"INFO", 4);
4262 for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
4267 const char* pID = NULL;
4269 switch (pMetadata->
type) {
4287 DRWAV_ASSERT(pID != NULL);
4291 bytesWritten += drwav__write_or_count(pWav, pID, 4);
4292 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, subchunkSize);
4294 bytesWritten += drwav__write_or_count_byte(pWav,
'\0');
4300 bytesWritten += drwav__write_or_count(pWav, pMetadata->
data.
unknown.
id, 4);
4302 bytesWritten += drwav__write_or_count(pWav, pMetadata->
data.
unknown.
pData, subchunkSize);
4306 if ((subchunkSize % 2) != 0) {
4307 bytesWritten += drwav__write_or_count_byte(pWav, 0);
4315 for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
4318 switch (pMetadata->
type)
4324 chunkSize += DRWAV_LIST_LABEL_OR_NOTE_BYTES;
4334 chunkSize += DRWAV_LIST_LABELLED_TEXT_BYTES;
4352 if ((chunkSize % 2) != 0) {
4357 bytesWritten += drwav__write_or_count(pWav,
"LIST", 4);
4358 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, chunkSize);
4359 bytesWritten += drwav__write_or_count(pWav,
"adtl", 4);
4361 for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
4365 switch (pMetadata->
type)
4371 const char *pID = NULL;
4380 DRWAV_ASSERT(pID != NULL);
4383 subchunkSize = DRWAV_LIST_LABEL_OR_NOTE_BYTES;
4385 bytesWritten += drwav__write_or_count(pWav, pID, 4);
4387 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, subchunkSize);
4391 bytesWritten += drwav__write_or_count_byte(pWav,
'\0');
4397 subchunkSize = DRWAV_LIST_LABELLED_TEXT_BYTES;
4399 bytesWritten += drwav__write_or_count(pWav,
"ltxt", 4);
4403 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, subchunkSize);
4416 bytesWritten += drwav__write_or_count_byte(pWav,
'\0');
4426 bytesWritten += drwav__write_or_count(pWav, pMetadata->
data.
unknown.
id, 4);
4427 bytesWritten += drwav__write_or_count_u32ne_to_le(pWav, subchunkSize);
4428 bytesWritten += drwav__write_or_count(pWav, pMetadata->
data.
unknown.
pData, subchunkSize);
4435 if ((subchunkSize % 2) != 0) {
4436 bytesWritten += drwav__write_or_count_byte(pWav, 0);
4441 DRWAV_ASSERT((bytesWritten % 2) == 0);
4443 return bytesWritten;
4448 drwav_uint64 chunkSize = 4 + 24 + (
drwav_uint64)drwav__write_or_count_metadata(NULL, pMetadata, metadataCount) + 8 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize);
4449 if (chunkSize > 0xFFFFFFFFUL) {
4450 chunkSize = 0xFFFFFFFFUL;
4458 if (dataChunkSize <= 0xFFFFFFFFUL) {
4461 return 0xFFFFFFFFUL;
4467 drwav_uint64 dataSubchunkPaddingSize = drwav__chunk_padding_size_w64(dataChunkSize);
4469 return 80 + 24 + dataChunkSize + dataSubchunkPaddingSize;
4474 return 24 + dataChunkSize;
4479 drwav_uint64 chunkSize = 4 + 36 + 24 + (
drwav_uint64)drwav__write_or_count_metadata(NULL, metadata, numMetadata) + 8 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize);
4480 if (chunkSize > 0xFFFFFFFFUL) {
4481 chunkSize = 0xFFFFFFFFUL;
4489 return dataChunkSize;
4496 if (pWav == NULL || onWrite == NULL) {
4500 if (!isSequential && onSeek == NULL) {
4512 DRWAV_ZERO_MEMORY(pWav,
sizeof(*pWav));
4516 pWav->
allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
4539 size_t runningPos = 0;
4556 if (initialDataChunkSize > (0xFFFFFFFFUL - 36)) {
4568 runningPos += drwav__write(pWav,
"RIFF", 4);
4569 runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeRIFF);
4570 runningPos += drwav__write(pWav,
"WAVE", 4);
4572 drwav_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize;
4573 runningPos += drwav__write(pWav, drwavGUID_W64_RIFF, 16);
4574 runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeRIFF);
4575 runningPos += drwav__write(pWav, drwavGUID_W64_WAVE, 16);
4577 runningPos += drwav__write(pWav,
"RF64", 4);
4578 runningPos += drwav__write_u32ne_to_le(pWav, 0xFFFFFFFF);
4579 runningPos += drwav__write(pWav,
"WAVE", 4);
4588 drwav_uint64 initialRiffChunkSize = 8 + initialds64ChunkSize + initialDataChunkSize;
4590 runningPos += drwav__write(pWav,
"ds64", 4);
4591 runningPos += drwav__write_u32ne_to_le(pWav, initialds64ChunkSize);
4592 runningPos += drwav__write_u64ne_to_le(pWav, initialRiffChunkSize);
4593 runningPos += drwav__write_u64ne_to_le(pWav, initialDataChunkSize);
4594 runningPos += drwav__write_u64ne_to_le(pWav, totalSampleCount);
4595 runningPos += drwav__write_u32ne_to_le(pWav, 0);
4602 runningPos += drwav__write(pWav,
"fmt ", 4);
4603 runningPos += drwav__write_u32ne_to_le(pWav, (
drwav_uint32)chunkSizeFMT);
4606 runningPos += drwav__write(pWav, drwavGUID_W64_FMT, 16);
4607 runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeFMT);
4610 runningPos += drwav__write_u16ne_to_le(pWav, pWav->
fmt.
formatTag);
4611 runningPos += drwav__write_u16ne_to_le(pWav, pWav->
fmt.
channels);
4612 runningPos += drwav__write_u32ne_to_le(pWav, pWav->
fmt.
sampleRate);
4614 runningPos += drwav__write_u16ne_to_le(pWav, pWav->
fmt.
blockAlign);
4628 runningPos += drwav__write(pWav,
"data", 4);
4629 runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeDATA);
4631 drwav_uint64 chunkSizeDATA = 24 + initialDataChunkSize;
4632 runningPos += drwav__write(pWav, drwavGUID_W64_DATA, 16);
4633 runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeDATA);
4635 runningPos += drwav__write(pWav,
"data", 4);
4636 runningPos += drwav__write_u32ne_to_le(pWav, 0xFFFFFFFF);
4653 if (!drwav_preinit_write(pWav, pFormat,
DRWAV_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
4657 return drwav_init_write__internal(pWav, pFormat, 0);
4662 if (!drwav_preinit_write(pWav, pFormat,
DRWAV_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) {
4666 return drwav_init_write__internal(pWav, pFormat, totalSampleCount);
4671 if (pFormat == NULL) {
4680 if (!drwav_preinit_write(pWav, pFormat,
DRWAV_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
4687 return drwav_init_write__internal(pWav, pFormat, 0);
4699 riffChunkSizeBytes = drwav__riff_chunk_size_riff(targetDataSizeBytes, pMetadata, metadataCount);
4700 fileSizeBytes = (8 + riffChunkSizeBytes);
4702 riffChunkSizeBytes = drwav__riff_chunk_size_w64(targetDataSizeBytes);
4703 fileSizeBytes = riffChunkSizeBytes;
4705 riffChunkSizeBytes = drwav__riff_chunk_size_rf64(targetDataSizeBytes, pMetadata, metadataCount);
4706 fileSizeBytes = (8 + riffChunkSizeBytes);
4709 return fileSizeBytes;
4713#ifndef DR_WAV_NO_STDIO
4837 #if defined(ENOTEMPTY) && ENOTEMPTY != EEXIST
4993 #ifdef EPROTONOSUPPORT
4996 #ifdef ESOCKTNOSUPPORT
5011 #ifdef EADDRNOTAVAIL
5107 #ifdef ENOTRECOVERABLE
5124#if defined(_MSC_VER) && _MSC_VER >= 1400
5128 if (ppFile != NULL) {
5132 if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
5136#if defined(_MSC_VER) && _MSC_VER >= 1400
5137 err = fopen_s(ppFile, pFilePath, pOpenMode);
5139 return drwav_result_from_errno(err);
5142#if defined(_WIN32) || defined(__APPLE__)
5143 *ppFile = fopen(pFilePath, pOpenMode);
5145 #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
5146 *ppFile = fopen64(pFilePath, pOpenMode);
5148 *ppFile = fopen(pFilePath, pOpenMode);
5151 if (*ppFile == NULL) {
5177 #if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
5178 #define DRWAV_HAS_WFOPEN
5182#ifndef DR_WAV_NO_WCHAR
5185 if (ppFile != NULL) {
5189 if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
5193#if defined(DRWAV_HAS_WFOPEN)
5196 #if defined(_MSC_VER) && _MSC_VER >= 1400
5197 errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode);
5199 return drwav_result_from_errno(err);
5202 *ppFile = _wfopen(pFilePath, pOpenMode);
5203 if (*ppFile == NULL) {
5204 return drwav_result_from_errno(errno);
5207 (void)pAllocationCallbacks;
5223 #if defined(__DJGPP__)
5231 const wchar_t* pFilePathTemp = pFilePath;
5232 char* pFilePathMB = NULL;
5233 char pOpenModeMB[32] = {0};
5236 DRWAV_ZERO_OBJECT(&mbs);
5237 lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs);
5238 if (lenMB == (
size_t)-1) {
5239 return drwav_result_from_errno(errno);
5242 pFilePathMB = (
char*)drwav__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks);
5243 if (pFilePathMB == NULL) {
5247 pFilePathTemp = pFilePath;
5248 DRWAV_ZERO_OBJECT(&mbs);
5249 wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs);
5255 if (pOpenMode[i] == 0) {
5256 pOpenModeMB[i] =
'\0';
5260 pOpenModeMB[i] = (char)pOpenMode[i];
5265 *ppFile = fopen(pFilePathMB, pOpenModeMB);
5267 drwav__free_from_callbacks(pFilePathMB, pAllocationCallbacks);
5271 if (*ppFile == NULL) {
5282DRWAV_PRIVATE size_t drwav__on_read_stdio(
void* pUserData,
void* pBufferOut,
size_t bytesToRead)
5284 return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
5287DRWAV_PRIVATE size_t drwav__on_write_stdio(
void* pUserData,
const void* pData,
size_t bytesToWrite)
5289 return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData);
5294 int whence = SEEK_SET;
5301 return fseek((FILE*)pUserData, offset, whence) == 0;
5306 FILE* pFileStdio = (FILE*)pUserData;
5310 DRWAV_ASSERT(pFileStdio != NULL);
5311 DRWAV_ASSERT(pCursor != NULL);
5313#if defined(_WIN32) && !defined(NXDK)
5314 #if defined(_MSC_VER) && _MSC_VER > 1200
5315 result = _ftelli64(pFileStdio);
5317 result = ftell(pFileStdio);
5320 result = ftell(pFileStdio);
5338 result = drwav_preinit(pWav, drwav__on_read_stdio, drwav__on_seek_stdio, drwav__on_tell_stdio, (
void*)pFile, pAllocationCallbacks);
5344 result = drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
5361 return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
5364#ifndef DR_WAV_NO_WCHAR
5373 if (drwav_wfopen(&pFile, filename, L
"rb", pAllocationCallbacks) !=
DRWAV_SUCCESS) {
5378 return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
5390 return drwav_init_file__internal_FILE(pWav, pFile, NULL, NULL, flags |
DRWAV_WITH_METADATA, pAllocationCallbacks);
5393#ifndef DR_WAV_NO_WCHAR
5397 if (drwav_wfopen(&pFile, filename, L
"rb", pAllocationCallbacks) !=
DRWAV_SUCCESS) {
5402 return drwav_init_file__internal_FILE(pWav, pFile, NULL, NULL, flags |
DRWAV_WITH_METADATA, pAllocationCallbacks);
5411 result = drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio, (
void*)pFile, pAllocationCallbacks);
5417 result = drwav_init_write__internal(pWav, pFormat, totalSampleCount);
5434 return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
5437#ifndef DR_WAV_NO_WCHAR
5441 if (drwav_wfopen(&pFile, filename, L
"wb", pAllocationCallbacks) !=
DRWAV_SUCCESS) {
5446 return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
5452 return drwav_init_file_write__internal(pWav, filename, pFormat, 0,
DRWAV_FALSE, pAllocationCallbacks);
5457 return drwav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount,
DRWAV_TRUE, pAllocationCallbacks);
5462 if (pFormat == NULL) {
5469#ifndef DR_WAV_NO_WCHAR
5472 return drwav_init_file_write_w__internal(pWav, filename, pFormat, 0,
DRWAV_FALSE, pAllocationCallbacks);
5477 return drwav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount,
DRWAV_TRUE, pAllocationCallbacks);
5482 if (pFormat == NULL) {
5492DRWAV_PRIVATE size_t drwav__on_read_memory(
void* pUserData,
void* pBufferOut,
size_t bytesToRead)
5495 size_t bytesRemaining;
5497 DRWAV_ASSERT(pWav != NULL);
5501 if (bytesToRead > bytesRemaining) {
5502 bytesToRead = bytesRemaining;
5505 if (bytesToRead > 0) {
5518 DRWAV_ASSERT(pWav != NULL);
5527 DRWAV_ASSERT(!
"Invalid seek origin");
5531 newCursor += offset;
5533 if (newCursor < 0) {
5545DRWAV_PRIVATE size_t drwav__on_write_memory(
void* pUserData,
const void* pDataIn,
size_t bytesToWrite)
5548 size_t bytesRemaining;
5550 DRWAV_ASSERT(pWav != NULL);
5554 if (bytesRemaining < bytesToWrite) {
5565 if (pNewData == NULL) {
5582 return bytesToWrite;
5590 DRWAV_ASSERT(pWav != NULL);
5599 DRWAV_ASSERT(!
"Invalid seek origin");
5603 newCursor += offset;
5605 if (newCursor < 0) {
5621 DRWAV_ASSERT(pWav != NULL);
5622 DRWAV_ASSERT(pCursor != NULL);
5635 if (data == NULL || dataSize == 0) {
5639 if (!drwav_preinit(pWav, drwav__on_read_memory, drwav__on_seek_memory, drwav__on_tell_memory, pWav, pAllocationCallbacks)) {
5647 return drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
5652 if (data == NULL || dataSize == 0) {
5656 if (!drwav_preinit(pWav, drwav__on_read_memory, drwav__on_seek_memory, drwav__on_tell_memory, pWav, pAllocationCallbacks)) {
5670 if (ppData == NULL || pDataSize == NULL) {
5677 if (!drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, pWav, pAllocationCallbacks)) {
5687 return drwav_init_write__internal(pWav, pFormat, totalSampleCount);
5692 return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0,
DRWAV_FALSE, pAllocationCallbacks);
5697 return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount,
DRWAV_TRUE, pAllocationCallbacks);
5702 if (pFormat == NULL) {
5734 if (paddingSize > 0) {
5736 drwav__write(pWav, &paddingData, paddingSize);
5748 drwav__write_u32ne_to_le(pWav, riffChunkSize);
5754 drwav__write_u32ne_to_le(pWav, dataChunkSize);
5760 drwav__write_u64ne_to_le(pWav, riffChunkSize);
5766 drwav__write_u64ne_to_le(pWav, dataChunkSize);
5770 int ds64BodyPos = 12 + 8;
5775 drwav__write_u64ne_to_le(pWav, riffChunkSize);
5781 drwav__write_u64ne_to_le(pWav, dataChunkSize);
5796#ifndef DR_WAV_NO_STDIO
5801 if (pWav->
onRead == drwav__on_read_stdio || pWav->
onWrite == drwav__on_write_stdio) {
5816 if (pWav == NULL || bytesToRead == 0) {
5824 if (bytesToRead == 0) {
5828 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
5829 if (bytesPerFrame == 0) {
5833 if (pBufferOut != NULL) {
5838 while (bytesRead < bytesToRead) {
5839 size_t bytesToSeek = (bytesToRead - bytesRead);
5840 if (bytesToSeek > 0x7FFFFFFF) {
5841 bytesToSeek = 0x7FFFFFFF;
5848 bytesRead += bytesToSeek;
5852 while (bytesRead < bytesToRead) {
5855 size_t bytesToSeek = (bytesToRead - bytesRead);
5856 if (bytesToSeek >
sizeof(
buffer)) {
5857 bytesToSeek =
sizeof(
buffer);
5861 bytesRead += bytesSeeked;
5863 if (bytesSeeked < bytesToSeek) {
5883 if (pWav == NULL || framesToRead == 0) {
5893 if (framesToRead > framesRemainingInFile) {
5894 framesToRead = framesRemainingInFile;
5897 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
5898 if (bytesPerFrame == 0) {
5903 bytesToRead = framesToRead * bytesPerFrame;
5904 if (bytesToRead > DRWAV_SIZE_MAX) {
5905 bytesToRead = (DRWAV_SIZE_MAX / bytesPerFrame) * bytesPerFrame;
5912 if (bytesToRead == 0) {
5916 return drwav_read_raw(pWav, (
size_t)bytesToRead, pBufferOut) / bytesPerFrame;
5923 if (pBufferOut != NULL) {
5924 drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
5925 if (bytesPerFrame == 0) {
5929 drwav__bswap_samples(pBufferOut, framesRead*pWav->
channels, bytesPerFrame/pWav->
channels);
5939 if (drwav_is_container_be(pWav->
container)) {
5946 if (drwav__is_little_endian()) {
5957 if (drwav__is_little_endian()) {
5970 if (pBufferOut != NULL) {
5973 for (iSample = 0; iSample < framesRead * pWav->
channels; iSample += 1) {
5998 DRWAV_ZERO_OBJECT(&pWav->
msadpcm);
6000 DRWAV_ZERO_OBJECT(&pWav->
ima);
6016 if (pWav == NULL || pWav->
onSeek == NULL) {
6046 if (targetFrameIndex < pWav->readCursorInPCMFrames) {
6047 if (!drwav_seek_to_first_pcm_frame(pWav)) {
6056 while (offsetInFrames > 0) {
6059 if (framesToRead > drwav_countof(devnull)/pWav->
channels) {
6060 framesToRead = drwav_countof(devnull)/pWav->
channels;
6064 framesRead = drwav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, devnull);
6066 framesRead = drwav_read_pcm_frames_s16__ima(pWav, framesToRead, devnull);
6071 if (framesRead != framesToRead) {
6075 offsetInFrames -= framesRead;
6085 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
6086 if (bytesPerFrame == 0) {
6094 targetBytePos = targetFrameIndex * bytesPerFrame;
6096 if (currentBytePos < targetBytePos) {
6098 offset = (targetBytePos - currentBytePos);
6101 if (!drwav_seek_to_first_pcm_frame(pWav)) {
6104 offset = targetBytePos;
6107 while (offset > 0) {
6108 int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset);
6124 if (pCursor == NULL) {
6141 if (pLength == NULL) {
6159 size_t bytesWritten;
6161 if (pWav == NULL || bytesToWrite == 0 || pData == NULL) {
6168 return bytesWritten;
6177 if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
6182 if (bytesToWrite > DRWAV_SIZE_MAX) {
6189 while (bytesToWrite > 0) {
6190 size_t bytesJustWritten;
6193 bytesToWriteThisIteration = bytesToWrite;
6194 DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX);
6196 bytesJustWritten =
drwav_write_raw(pWav, (
size_t)bytesToWriteThisIteration, pRunningData);
6197 if (bytesJustWritten == 0) {
6201 bytesToWrite -= bytesJustWritten;
6202 bytesWritten += bytesJustWritten;
6203 pRunningData += bytesJustWritten;
6216 if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
6221 if (bytesToWrite > DRWAV_SIZE_MAX) {
6228 bytesPerSample = drwav_get_bytes_per_pcm_frame(pWav) / pWav->
channels;
6229 if (bytesPerSample == 0) {
6233 while (bytesToWrite > 0) {
6236 size_t bytesJustWritten;
6239 bytesToWriteThisIteration = bytesToWrite;
6240 DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX);
6246 sampleCount =
sizeof(temp)/bytesPerSample;
6248 if (bytesToWriteThisIteration > ((
drwav_uint64)sampleCount)*bytesPerSample) {
6249 bytesToWriteThisIteration = ((
drwav_uint64)sampleCount)*bytesPerSample;
6252 DRWAV_COPY_MEMORY(temp, pRunningData, (
size_t)bytesToWriteThisIteration);
6253 drwav__bswap_samples(temp, sampleCount, bytesPerSample);
6255 bytesJustWritten =
drwav_write_raw(pWav, (
size_t)bytesToWriteThisIteration, temp);
6256 if (bytesJustWritten == 0) {
6260 bytesToWrite -= bytesJustWritten;
6261 bytesWritten += bytesJustWritten;
6262 pRunningData += bytesJustWritten;
6270 if (drwav__is_little_endian()) {
6283 230, 230, 230, 230, 307, 409, 512, 614,
6284 768, 614, 512, 409, 307, 230, 230, 230
6286 static const drwav_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460, 392 };
6287 static const drwav_int32 coeff2Table[] = { 0, -256, 0, 64, 0, -208, -232 };
6289 DRWAV_ASSERT(pWav != NULL);
6290 DRWAV_ASSERT(framesToRead > 0);
6295 DRWAV_ASSERT(framesToRead > 0);
6302 if (pWav->
onRead(pWav->
pUserData, header,
sizeof(header)) !=
sizeof(header)) {
6303 return totalFramesRead;
6317 return totalFramesRead;
6322 if (pWav->
onRead(pWav->
pUserData, header,
sizeof(header)) !=
sizeof(header)) {
6323 return totalFramesRead;
6345 return totalFramesRead;
6352 if (pBufferOut != NULL) {
6354 for (iSample = 0; iSample < pWav->
channels; iSample += 1) {
6362 totalFramesRead += 1;
6367 if (framesToRead == 0) {
6385 return totalFramesRead;
6390 nibble0 = ((nibbles & 0xF0) >> 4);
if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; }
6391 nibble1 = ((nibbles & 0x0F) >> 0);
if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; }
6400 return totalFramesRead;
6405 newSample0 = drwav_clamp(newSample0, -32768, 32767);
6415 newSample1 = drwav_clamp(newSample1, -32768, 32767);
6432 return totalFramesRead;
6437 newSample0 = drwav_clamp(newSample0, -32768, 32767);
6447 return totalFramesRead;
6452 newSample1 = drwav_clamp(newSample1, -32768, 32767);
6467 return totalFramesRead;
6477 -1, -1, -1, -1, 2, 4, 6, 8,
6478 -1, -1, -1, -1, 2, 4, 6, 8
6482 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
6483 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
6484 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
6485 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
6486 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
6487 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
6488 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
6489 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
6490 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
6493 DRWAV_ASSERT(pWav != NULL);
6494 DRWAV_ASSERT(framesToRead > 0);
6499 DRWAV_ASSERT(framesToRead > 0);
6506 if (pWav->
onRead(pWav->
pUserData, header,
sizeof(header)) !=
sizeof(header)) {
6507 return totalFramesRead;
6511 if (header[2] >= drwav_countof(stepTable)) {
6514 return totalFramesRead;
6524 if (pWav->
onRead(pWav->
pUserData, header,
sizeof(header)) !=
sizeof(header)) {
6525 return totalFramesRead;
6529 if (header[2] >= drwav_countof(stepTable) || header[6] >= drwav_countof(stepTable)) {
6532 return totalFramesRead;
6548 if (pBufferOut != NULL) {
6550 for (iSample = 0; iSample < pWav->
channels; iSample += 1) {
6557 totalFramesRead += 1;
6562 if (framesToRead == 0) {
6579 for (iChannel = 0; iChannel < pWav->
channels; ++iChannel) {
6584 return totalFramesRead;
6588 for (iByte = 0; iByte < 4; ++iByte) {
6589 drwav_uint8 nibble0 = ((nibbles[iByte] & 0x0F) >> 0);
6590 drwav_uint8 nibble1 = ((nibbles[iByte] & 0xF0) >> 4);
6596 if (nibble0 & 1)
diff += step >> 2;
6597 if (nibble0 & 2)
diff += step >> 1;
6598 if (nibble0 & 4)
diff += step;
6601 predictor = drwav_clamp(predictor +
diff, -32768, 32767);
6611 if (nibble1 & 1)
diff += step >> 2;
6612 if (nibble1 & 2)
diff += step >> 1;
6613 if (nibble1 & 4)
diff += step;
6616 predictor = drwav_clamp(predictor +
diff, -32768, 32767);
6626 return totalFramesRead;
6630#ifndef DR_WAV_NO_CONVERSION_API
6631static const unsigned short g_drwavAlawTable[256] = {
6632 0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580,
6633 0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0,
6634 0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600,
6635 0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00,
6636 0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58,
6637 0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58,
6638 0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
6639 0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0,
6640 0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80,
6641 0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40,
6642 0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00,
6643 0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500,
6644 0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8,
6645 0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
6646 0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0,
6647 0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350
6650static const unsigned short g_drwavMulawTable[256] = {
6651 0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84,
6652 0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84,
6653 0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004,
6654 0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844,
6655 0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64,
6656 0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74,
6657 0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
6658 0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000,
6659 0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C,
6660 0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C,
6661 0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC,
6662 0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC,
6663 0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C,
6664 0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
6665 0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084,
6666 0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000
6671 return (
short)g_drwavAlawTable[sampleIn];
6676 return (
short)g_drwavMulawTable[sampleIn];
6686 if (bytesPerSample == 1) {
6693 if (bytesPerSample == 2) {
6694 for (i = 0; i < totalSampleCount; ++i) {
6699 if (bytesPerSample == 3) {
6703 if (bytesPerSample == 4) {
6710 if (bytesPerSample > 8) {
6711 DRWAV_ZERO_MEMORY(pOut, totalSampleCount *
sizeof(*pOut));
6717 for (i = 0; i < totalSampleCount; ++i) {
6719 unsigned int shift = (8 - bytesPerSample) * 8;
6722 for (j = 0; j < bytesPerSample; j += 1) {
6723 DRWAV_ASSERT(j < 8);
6735 if (bytesPerSample == 4) {
6738 }
else if (bytesPerSample == 8) {
6743 DRWAV_ZERO_MEMORY(pOut, totalSampleCount *
sizeof(*pOut));
6761 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
6762 if (bytesPerFrame == 0) {
6766 bytesPerSample = bytesPerFrame / pWav->
channels;
6767 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
6771 totalFramesRead = 0;
6773 while (framesToRead > 0) {
6774 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
6776 if (framesRead == 0) {
6780 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
6783 samplesRead = framesRead * pWav->
channels;
6784 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
6789 drwav__pcm_to_s16(pBufferOut, sampleData, (
size_t)samplesRead, bytesPerSample);
6791 pBufferOut += samplesRead;
6792 framesToRead -= framesRead;
6793 totalFramesRead += framesRead;
6796 return totalFramesRead;
6807 if (pBufferOut == NULL) {
6811 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
6812 if (bytesPerFrame == 0) {
6816 bytesPerSample = bytesPerFrame / pWav->
channels;
6817 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
6821 totalFramesRead = 0;
6823 while (framesToRead > 0) {
6824 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
6826 if (framesRead == 0) {
6830 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
6833 samplesRead = framesRead * pWav->
channels;
6834 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
6839 drwav__ieee_to_s16(pBufferOut, sampleData, (
size_t)samplesRead, bytesPerSample);
6841 pBufferOut += samplesRead;
6842 framesToRead -= framesRead;
6843 totalFramesRead += framesRead;
6846 return totalFramesRead;
6857 if (pBufferOut == NULL) {
6861 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
6862 if (bytesPerFrame == 0) {
6866 bytesPerSample = bytesPerFrame / pWav->
channels;
6867 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
6871 totalFramesRead = 0;
6873 while (framesToRead > 0) {
6874 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
6876 if (framesRead == 0) {
6880 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
6883 samplesRead = framesRead * pWav->
channels;
6884 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
6897 #ifdef DR_WAV_LIBSNDFILE_COMPAT
6901 for (iSample = 0; iSample < samplesRead; iSample += 1) {
6902 pBufferOut[iSample] = -pBufferOut[iSample];
6908 pBufferOut += samplesRead;
6909 framesToRead -= framesRead;
6910 totalFramesRead += framesRead;
6913 return totalFramesRead;
6924 if (pBufferOut == NULL) {
6928 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
6929 if (bytesPerFrame == 0) {
6933 bytesPerSample = bytesPerFrame / pWav->
channels;
6934 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
6938 totalFramesRead = 0;
6940 while (framesToRead > 0) {
6941 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
6943 if (framesRead == 0) {
6947 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
6950 samplesRead = framesRead * pWav->
channels;
6951 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
6962 #ifdef DR_WAV_LIBSNDFILE_COMPAT
6966 for (iSample = 0; iSample < samplesRead; iSample += 1) {
6967 pBufferOut[iSample] = -pBufferOut[iSample];
6973 pBufferOut += samplesRead;
6974 framesToRead -= framesRead;
6975 totalFramesRead += framesRead;
6978 return totalFramesRead;
6983 if (pWav == NULL || framesToRead == 0) {
6987 if (pBufferOut == NULL) {
6997 return drwav_read_pcm_frames_s16__pcm(pWav, framesToRead, pBufferOut);
7001 return drwav_read_pcm_frames_s16__ieee(pWav, framesToRead, pBufferOut);
7005 return drwav_read_pcm_frames_s16__alaw(pWav, framesToRead, pBufferOut);
7009 return drwav_read_pcm_frames_s16__mulaw(pWav, framesToRead, pBufferOut);
7013 return drwav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, pBufferOut);
7017 return drwav_read_pcm_frames_s16__ima(pWav, framesToRead, pBufferOut);
7026 if (pBufferOut != NULL && drwav__is_little_endian() ==
DRWAV_FALSE) {
7027 drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->
channels);
7036 if (pBufferOut != NULL && drwav__is_little_endian() ==
DRWAV_TRUE) {
7037 drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->
channels);
7048 for (i = 0; i < sampleCount; ++i) {
7060 for (i = 0; i < sampleCount; ++i) {
7061 int x = ((int)(((
unsigned int)(((
const drwav_uint8*)pIn)[i*3+0]) << 8) | ((
unsigned int)(((
const drwav_uint8*)pIn)[i*3+1]) << 16) | ((
unsigned int)(((
const drwav_uint8*)pIn)[i*3+2])) << 24)) >> 8;
7071 for (i = 0; i < sampleCount; ++i) {
7082 for (i = 0; i < sampleCount; ++i) {
7085 c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
7087 r = (int)(c * 32767.5f);
7097 for (i = 0; i < sampleCount; ++i) {
7100 c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
7102 r = (int)(c * 32767.5);
7111 for (i = 0; i < sampleCount; ++i) {
7112 pOut[i] = drwav__alaw_to_s16(pIn[i]);
7119 for (i = 0; i < sampleCount; ++i) {
7120 pOut[i] = drwav__mulaw_to_s16(pIn[i]);
7125DRWAV_PRIVATE void drwav__pcm_to_f32(
float* pOut,
const drwav_uint8* pIn,
size_t sampleCount,
unsigned int bytesPerSample)
7130 if (bytesPerSample == 1) {
7136 if (bytesPerSample == 2) {
7140 if (bytesPerSample == 3) {
7144 if (bytesPerSample == 4) {
7151 if (bytesPerSample > 8) {
7152 DRWAV_ZERO_MEMORY(pOut, sampleCount *
sizeof(*pOut));
7158 for (i = 0; i < sampleCount; ++i) {
7160 unsigned int shift = (8 - bytesPerSample) * 8;
7163 for (j = 0; j < bytesPerSample; j += 1) {
7164 DRWAV_ASSERT(j < 8);
7170 *pOut++ = (float)((
drwav_int64)sample / 9223372036854775807.0);
7174DRWAV_PRIVATE void drwav__ieee_to_f32(
float* pOut,
const drwav_uint8* pIn,
size_t sampleCount,
unsigned int bytesPerSample)
7176 if (bytesPerSample == 4) {
7178 for (i = 0; i < sampleCount; ++i) {
7179 *pOut++ = ((
const float*)pIn)[i];
7182 }
else if (bytesPerSample == 8) {
7187 DRWAV_ZERO_MEMORY(pOut, sampleCount *
sizeof(*pOut));
7201 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7202 if (bytesPerFrame == 0) {
7206 bytesPerSample = bytesPerFrame / pWav->
channels;
7207 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7211 totalFramesRead = 0;
7213 while (framesToRead > 0) {
7214 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7216 if (framesRead == 0) {
7220 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7223 samplesRead = framesRead * pWav->
channels;
7224 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7229 drwav__pcm_to_f32(pBufferOut, sampleData, (
size_t)samplesRead, bytesPerSample);
7231 pBufferOut += samplesRead;
7232 framesToRead -= framesRead;
7233 totalFramesRead += framesRead;
7236 return totalFramesRead;
7248 totalFramesRead = 0;
7250 while (framesToRead > 0) {
7251 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead, drwav_countof(samples16)/pWav->
channels);
7253 if (framesRead == 0) {
7257 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7261 pBufferOut += framesRead*pWav->
channels;
7262 framesToRead -= framesRead;
7263 totalFramesRead += framesRead;
7266 return totalFramesRead;
7282 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7283 if (bytesPerFrame == 0) {
7287 bytesPerSample = bytesPerFrame / pWav->
channels;
7288 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7292 totalFramesRead = 0;
7294 while (framesToRead > 0) {
7295 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7297 if (framesRead == 0) {
7301 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7304 samplesRead = framesRead * pWav->
channels;
7305 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7310 drwav__ieee_to_f32(pBufferOut, sampleData, (
size_t)samplesRead, bytesPerSample);
7312 pBufferOut += samplesRead;
7313 framesToRead -= framesRead;
7314 totalFramesRead += framesRead;
7317 return totalFramesRead;
7328 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7329 if (bytesPerFrame == 0) {
7333 bytesPerSample = bytesPerFrame / pWav->
channels;
7334 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7338 totalFramesRead = 0;
7340 while (framesToRead > 0) {
7341 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7343 if (framesRead == 0) {
7347 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7350 samplesRead = framesRead * pWav->
channels;
7351 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7358 #ifdef DR_WAV_LIBSNDFILE_COMPAT
7362 for (iSample = 0; iSample < samplesRead; iSample += 1) {
7363 pBufferOut[iSample] = -pBufferOut[iSample];
7369 pBufferOut += samplesRead;
7370 framesToRead -= framesRead;
7371 totalFramesRead += framesRead;
7374 return totalFramesRead;
7385 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7386 if (bytesPerFrame == 0) {
7390 bytesPerSample = bytesPerFrame / pWav->
channels;
7391 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7395 totalFramesRead = 0;
7397 while (framesToRead > 0) {
7398 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7400 if (framesRead == 0) {
7404 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7407 samplesRead = framesRead * pWav->
channels;
7408 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7415 #ifdef DR_WAV_LIBSNDFILE_COMPAT
7419 for (iSample = 0; iSample < samplesRead; iSample += 1) {
7420 pBufferOut[iSample] = -pBufferOut[iSample];
7426 pBufferOut += samplesRead;
7427 framesToRead -= framesRead;
7428 totalFramesRead += framesRead;
7431 return totalFramesRead;
7436 if (pWav == NULL || framesToRead == 0) {
7440 if (pBufferOut == NULL) {
7445 if (framesToRead * pWav->
channels *
sizeof(
float) > DRWAV_SIZE_MAX) {
7446 framesToRead = DRWAV_SIZE_MAX /
sizeof(float) / pWav->
channels;
7450 return drwav_read_pcm_frames_f32__pcm(pWav, framesToRead, pBufferOut);
7454 return drwav_read_pcm_frames_f32__msadpcm_ima(pWav, framesToRead, pBufferOut);
7458 return drwav_read_pcm_frames_f32__ieee(pWav, framesToRead, pBufferOut);
7462 return drwav_read_pcm_frames_f32__alaw(pWav, framesToRead, pBufferOut);
7466 return drwav_read_pcm_frames_f32__mulaw(pWav, framesToRead, pBufferOut);
7475 if (pBufferOut != NULL && drwav__is_little_endian() ==
DRWAV_FALSE) {
7476 drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->
channels);
7485 if (pBufferOut != NULL && drwav__is_little_endian() ==
DRWAV_TRUE) {
7486 drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->
channels);
7497 if (pOut == NULL || pIn == NULL) {
7501#ifdef DR_WAV_LIBSNDFILE_COMPAT
7508 for (i = 0; i < sampleCount; ++i) {
7509 *pOut++ = (pIn[i] / 256.0f) * 2 - 1;
7512 for (i = 0; i < sampleCount; ++i) {
7514 x = x * 0.00784313725490196078f;
7526 if (pOut == NULL || pIn == NULL) {
7530 for (i = 0; i < sampleCount; ++i) {
7531 *pOut++ = pIn[i] * 0.000030517578125f;
7539 if (pOut == NULL || pIn == NULL) {
7543 for (i = 0; i < sampleCount; ++i) {
7550 *pOut++ = (float)(x * 0.00000011920928955078125);
7557 if (pOut == NULL || pIn == NULL) {
7561 for (i = 0; i < sampleCount; ++i) {
7562 *pOut++ = (float)(pIn[i] / 2147483648.0);
7570 if (pOut == NULL || pIn == NULL) {
7574 for (i = 0; i < sampleCount; ++i) {
7575 *pOut++ = (float)pIn[i];
7583 if (pOut == NULL || pIn == NULL) {
7587 for (i = 0; i < sampleCount; ++i) {
7588 *pOut++ = drwav__alaw_to_s16(pIn[i]) / 32768.0f;
7596 if (pOut == NULL || pIn == NULL) {
7600 for (i = 0; i < sampleCount; ++i) {
7601 *pOut++ = drwav__mulaw_to_s16(pIn[i]) / 32768.0f;
7612 if (bytesPerSample == 1) {
7618 if (bytesPerSample == 2) {
7622 if (bytesPerSample == 3) {
7626 if (bytesPerSample == 4) {
7627 for (i = 0; i < totalSampleCount; ++i) {
7635 if (bytesPerSample > 8) {
7636 DRWAV_ZERO_MEMORY(pOut, totalSampleCount *
sizeof(*pOut));
7642 for (i = 0; i < totalSampleCount; ++i) {
7644 unsigned int shift = (8 - bytesPerSample) * 8;
7647 for (j = 0; j < bytesPerSample; j += 1) {
7648 DRWAV_ASSERT(j < 8);
7660 if (bytesPerSample == 4) {
7663 }
else if (bytesPerSample == 8) {
7668 DRWAV_ZERO_MEMORY(pOut, totalSampleCount *
sizeof(*pOut));
7687 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7688 if (bytesPerFrame == 0) {
7692 bytesPerSample = bytesPerFrame / pWav->
channels;
7693 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7697 totalFramesRead = 0;
7699 while (framesToRead > 0) {
7700 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7702 if (framesRead == 0) {
7706 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7709 samplesRead = framesRead * pWav->
channels;
7710 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7715 drwav__pcm_to_s32(pBufferOut, sampleData, (
size_t)samplesRead, bytesPerSample);
7717 pBufferOut += samplesRead;
7718 framesToRead -= framesRead;
7719 totalFramesRead += framesRead;
7722 return totalFramesRead;
7734 while (framesToRead > 0) {
7735 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead, drwav_countof(samples16)/pWav->
channels);
7737 if (framesRead == 0) {
7741 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7745 pBufferOut += framesRead*pWav->
channels;
7746 framesToRead -= framesRead;
7747 totalFramesRead += framesRead;
7750 return totalFramesRead;
7761 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7762 if (bytesPerFrame == 0) {
7766 bytesPerSample = bytesPerFrame / pWav->
channels;
7767 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7771 totalFramesRead = 0;
7773 while (framesToRead > 0) {
7774 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7776 if (framesRead == 0) {
7780 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7783 samplesRead = framesRead * pWav->
channels;
7784 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7789 drwav__ieee_to_s32(pBufferOut, sampleData, (
size_t)samplesRead, bytesPerSample);
7791 pBufferOut += samplesRead;
7792 framesToRead -= framesRead;
7793 totalFramesRead += framesRead;
7796 return totalFramesRead;
7807 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7808 if (bytesPerFrame == 0) {
7812 bytesPerSample = bytesPerFrame / pWav->
channels;
7813 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7817 totalFramesRead = 0;
7819 while (framesToRead > 0) {
7820 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7822 if (framesRead == 0) {
7826 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7829 samplesRead = framesRead * pWav->
channels;
7830 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7837 #ifdef DR_WAV_LIBSNDFILE_COMPAT
7841 for (iSample = 0; iSample < samplesRead; iSample += 1) {
7842 pBufferOut[iSample] = -pBufferOut[iSample];
7848 pBufferOut += samplesRead;
7849 framesToRead -= framesRead;
7850 totalFramesRead += framesRead;
7853 return totalFramesRead;
7864 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
7865 if (bytesPerFrame == 0) {
7869 bytesPerSample = bytesPerFrame / pWav->
channels;
7870 if (bytesPerSample == 0 || (bytesPerFrame % pWav->
channels) != 0) {
7874 totalFramesRead = 0;
7876 while (framesToRead > 0) {
7877 drwav_uint64 framesToReadThisIteration = drwav_min(framesToRead,
sizeof(sampleData)/bytesPerFrame);
7879 if (framesRead == 0) {
7883 DRWAV_ASSERT(framesRead <= framesToReadThisIteration);
7886 samplesRead = framesRead * pWav->
channels;
7887 if ((samplesRead * bytesPerSample) >
sizeof(sampleData)) {
7894 #ifdef DR_WAV_LIBSNDFILE_COMPAT
7898 for (iSample = 0; iSample < samplesRead; iSample += 1) {
7899 pBufferOut[iSample] = -pBufferOut[iSample];
7905 pBufferOut += samplesRead;
7906 framesToRead -= framesRead;
7907 totalFramesRead += framesRead;
7910 return totalFramesRead;
7915 if (pWav == NULL || framesToRead == 0) {
7919 if (pBufferOut == NULL) {
7929 return drwav_read_pcm_frames_s32__pcm(pWav, framesToRead, pBufferOut);
7933 return drwav_read_pcm_frames_s32__msadpcm_ima(pWav, framesToRead, pBufferOut);
7937 return drwav_read_pcm_frames_s32__ieee(pWav, framesToRead, pBufferOut);
7941 return drwav_read_pcm_frames_s32__alaw(pWav, framesToRead, pBufferOut);
7945 return drwav_read_pcm_frames_s32__mulaw(pWav, framesToRead, pBufferOut);
7954 if (pBufferOut != NULL && drwav__is_little_endian() ==
DRWAV_FALSE) {
7955 drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->
channels);
7964 if (pBufferOut != NULL && drwav__is_little_endian() ==
DRWAV_TRUE) {
7965 drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->
channels);
7976 if (pOut == NULL || pIn == NULL) {
7980 for (i = 0; i < sampleCount; ++i) {
7981 *pOut++ = ((int)pIn[i] - 128) << 24;
7989 if (pOut == NULL || pIn == NULL) {
7993 for (i = 0; i < sampleCount; ++i) {
7994 *pOut++ = pIn[i] << 16;
8002 if (pOut == NULL || pIn == NULL) {
8006 for (i = 0; i < sampleCount; ++i) {
8007 unsigned int s0 = pIn[i*3 + 0];
8008 unsigned int s1 = pIn[i*3 + 1];
8009 unsigned int s2 = pIn[i*3 + 2];
8020 if (pOut == NULL || pIn == NULL) {
8024 for (i = 0; i < sampleCount; ++i) {
8033 if (pOut == NULL || pIn == NULL) {
8037 for (i = 0; i < sampleCount; ++i) {
8046 if (pOut == NULL || pIn == NULL) {
8050 for (i = 0; i < sampleCount; ++i) {
8051 *pOut++ = ((
drwav_int32)drwav__alaw_to_s16(pIn[i])) << 16;
8059 if (pOut == NULL || pIn == NULL) {
8063 for (i= 0; i < sampleCount; ++i) {
8064 *pOut++ = ((
drwav_int32)drwav__mulaw_to_s16(pIn[i])) << 16;
8076 DRWAV_ASSERT(pWav != NULL);
8085 if (sampleDataSize > DRWAV_SIZE_MAX) {
8091 if (pSampleData == NULL) {
8111 if (totalFrameCount) {
8118DRWAV_PRIVATE float* drwav__read_pcm_frames_and_close_f32(
drwav* pWav,
unsigned int* channels,
unsigned int* sampleRate,
drwav_uint64* totalFrameCount)
8124 DRWAV_ASSERT(pWav != NULL);
8133 if (sampleDataSize > DRWAV_SIZE_MAX) {
8138 pSampleData = (
float*)drwav__malloc_from_callbacks((
size_t)sampleDataSize, &pWav->
allocationCallbacks);
8139 if (pSampleData == NULL) {
8159 if (totalFrameCount) {
8172 DRWAV_ASSERT(pWav != NULL);
8181 if (sampleDataSize > DRWAV_SIZE_MAX) {
8187 if (pSampleData == NULL) {
8207 if (totalFrameCount) {
8223 if (sampleRateOut) {
8226 if (totalFrameCountOut) {
8227 *totalFrameCountOut = 0;
8230 if (!
drwav_init(&wav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
8234 return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8244 if (sampleRateOut) {
8247 if (totalFrameCountOut) {
8248 *totalFrameCountOut = 0;
8251 if (!
drwav_init(&wav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
8255 return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8265 if (sampleRateOut) {
8268 if (totalFrameCountOut) {
8269 *totalFrameCountOut = 0;
8272 if (!
drwav_init(&wav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
8276 return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8279#ifndef DR_WAV_NO_STDIO
8287 if (sampleRateOut) {
8290 if (totalFrameCountOut) {
8291 *totalFrameCountOut = 0;
8298 return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8308 if (sampleRateOut) {
8311 if (totalFrameCountOut) {
8312 *totalFrameCountOut = 0;
8319 return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8329 if (sampleRateOut) {
8332 if (totalFrameCountOut) {
8333 *totalFrameCountOut = 0;
8340 return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8344#ifndef DR_WAV_NO_WCHAR
8349 if (sampleRateOut) {
8355 if (totalFrameCountOut) {
8356 *totalFrameCountOut = 0;
8363 return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8370 if (sampleRateOut) {
8376 if (totalFrameCountOut) {
8377 *totalFrameCountOut = 0;
8384 return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8391 if (sampleRateOut) {
8397 if (totalFrameCountOut) {
8398 *totalFrameCountOut = 0;
8405 return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8417 if (sampleRateOut) {
8420 if (totalFrameCountOut) {
8421 *totalFrameCountOut = 0;
8428 return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8438 if (sampleRateOut) {
8441 if (totalFrameCountOut) {
8442 *totalFrameCountOut = 0;
8449 return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8459 if (sampleRateOut) {
8462 if (totalFrameCountOut) {
8463 *totalFrameCountOut = 0;
8470 return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
8477 if (pAllocationCallbacks != NULL) {
8478 drwav__free_from_callbacks(p, pAllocationCallbacks);
8480 drwav__free_default(p, NULL);
8496 return drwav_bytes_to_u32_le(data);
8531 for (i = 0; i < 16; i += 1) {
8551#pragma options opt reset
drwav_uint64 drwav_read_pcm_frames_s32be(drwav *pWav, drwav_uint64 framesToRead, drwav_int32 *pBufferOut)
void drwav_u8_to_s16(drwav_int16 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
drwav_bool32 drwav_init_file_with_metadata_w(drwav *pWav, const wchar_t *filename, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
@ drwav_metadata_location_invalid
@ drwav_metadata_location_inside_info_list
@ drwav_metadata_location_inside_adtl_list
@ drwav_metadata_location_top_level
#define DRWAV_OUT_OF_RANGE
#define DRWAV_VERSION_MINOR
#define DRWAV_SOCKET_NOT_SUPPORTED
#define DRWAV_ACCESS_DENIED
drwav_int32 drwav_bytes_to_s32(const drwav_uint8 *data)
drwav_int16 drwav_bytes_to_s16(const drwav_uint8 *data)
drwav_bool32 drwav_init_write_sequential(drwav *pWav, const drwav_data_format *pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void *pUserData, const drwav_allocation_callbacks *pAllocationCallbacks)
const char * drwav_version_string(void)
drwav_uint64 drwav_read_pcm_frames_f32be(drwav *pWav, drwav_uint64 framesToRead, float *pBufferOut)
#define DRWAV_TOO_MANY_LINKS
void drwav_s16_to_s32(drwav_int32 *pOut, const drwav_int16 *pIn, size_t sampleCount)
drwav_bool32(* drwav_tell_proc)(void *pUserData, drwav_int64 *pCursor)
void drwav_alaw_to_s32(drwav_int32 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
@ drwav_smpl_loop_type_backward
@ drwav_smpl_loop_type_pingpong
@ drwav_smpl_loop_type_forward
drwav_bool32 drwav_init_write_with_metadata(drwav *pWav, const drwav_data_format *pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void *pUserData, const drwav_allocation_callbacks *pAllocationCallbacks, drwav_metadata *pMetadata, drwav_uint32 metadataCount)
drwav_bool32 drwav_init_memory(drwav *pWav, const void *data, size_t dataSize, const drwav_allocation_callbacks *pAllocationCallbacks)
void drwav_f32_to_s32(drwav_int32 *pOut, const float *pIn, size_t sampleCount)
#define DRWAV_INVALID_DATA
void drwav_s24_to_s16(drwav_int16 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
drwav_bool32 drwav_init_memory_with_metadata(drwav *pWav, const void *data, size_t dataSize, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
void drwav_s24_to_s32(drwav_int32 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
#define DRWAV_UNAVAILABLE
float * drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_tell_proc onTell, void *pUserData, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_with_metadata(drwav *pWav, const char *filename, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
void drwav_u8_to_f32(float *pOut, const drwav_uint8 *pIn, size_t sampleCount)
drwav_uint64 drwav_read_pcm_frames_s16be(drwav *pWav, drwav_uint64 framesToRead, drwav_int16 *pBufferOut)
drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav *pWav, void **ppData, size_t *pDataSize, const drwav_data_format *pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_uint16 drwav_fmt_get_format(const drwav_fmt *pFMT)
drwav_bool32(* drwav_seek_proc)(void *pUserData, int offset, drwav_seek_origin origin)
drwav_uint64 drwav_read_pcm_frames(drwav *pWav, drwav_uint64 framesToRead, void *pBufferOut)
drwav_uint64 drwav_write_pcm_frames(drwav *pWav, drwav_uint64 framesToWrite, const void *pData)
#define DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED
drwav_bool32 drwav_init_memory_ex(drwav *pWav, const void *data, size_t dataSize, drwav_chunk_proc onChunk, void *pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_write_sequential(drwav *pWav, const char *filename, const drwav_data_format *pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_uint32 drwav_bool32
#define DRWAV_NOT_DIRECTORY
drwav_bool32 drwav_init_memory_write_sequential(drwav *pWav, void **ppData, size_t *pDataSize, const drwav_data_format *pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks *pAllocationCallbacks)
void drwav_mulaw_to_s16(drwav_int16 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
void drwav_f32_to_s16(drwav_int16 *pOut, const float *pIn, size_t sampleCount)
#define DR_WAVE_FORMAT_DVI_ADPCM
#define DRWAV_VERSION_STRING
drwav_bool32 drwav_init_write(drwav *pWav, const drwav_data_format *pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void *pUserData, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DRWAV_INVALID_ARGS
#define DRWAV_PROTOCOL_UNAVAILABLE
void drwav_alaw_to_s16(drwav_int16 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
#define DR_WAVE_FORMAT_EXTENSIBLE
drwav_uint32 drwav_uintptr
drwav_uint64 drwav_read_pcm_frames_s16le(drwav *pWav, drwav_uint64 framesToRead, drwav_int16 *pBufferOut)
void drwav_f64_to_s32(drwav_int32 *pOut, const double *pIn, size_t sampleCount)
drwav_int16 * drwav_open_memory_and_read_pcm_frames_s16(const void *data, size_t dataSize, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
void drwav_f64_to_s16(drwav_int16 *pOut, const double *pIn, size_t sampleCount)
#define DRWAV_ALREADY_IN_USE
#define DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED
float * drwav_open_memory_and_read_pcm_frames_f32(const void *data, size_t dataSize, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav *pWav, const wchar_t *filename, const drwav_data_format *pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_write_sequential_w(drwav *pWav, const wchar_t *filename, const drwav_data_format *pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav *pWav, const drwav_data_format *pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void *pUserData, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DR_WAVE_FORMAT_MULAW
drwav_bool32 drwav_fourcc_equal(const drwav_uint8 *a, const char *b)
#define DRWAV_OUT_OF_MEMORY
drwav_uint64(* drwav_chunk_proc)(void *pChunkUserData, drwav_read_proc onRead, drwav_seek_proc onSeek, void *pReadSeekUserData, const drwav_chunk_header *pChunkHeader, drwav_container container, const drwav_fmt *pFMT)
drwav_bool32 drwav_init_ex(drwav *pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_tell_proc onTell, drwav_chunk_proc onChunk, void *pReadSeekTellUserData, void *pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_uint64 drwav_write_pcm_frames_le(drwav *pWav, drwav_uint64 framesToWrite, const void *pData)
size_t drwav_write_raw(drwav *pWav, size_t bytesToWrite, const void *pData)
drwav_result drwav_get_length_in_pcm_frames(drwav *pWav, drwav_uint64 *pLength)
drwav_bool32 drwav_init_file(drwav *pWav, const char *filename, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DRWAV_BAD_MESSAGE
#define DRWAV_PATH_TOO_LONG
drwav_uint64 drwav_read_pcm_frames_s16(drwav *pWav, drwav_uint64 framesToRead, drwav_int16 *pBufferOut)
void drwav_f64_to_f32(float *pOut, const double *pIn, size_t sampleCount)
float drwav_bytes_to_f32(const drwav_uint8 *data)
drwav_bool32 drwav_seek_to_pcm_frame(drwav *pWav, drwav_uint64 targetFrameIndex)
void drwav_s24_to_f32(float *pOut, const drwav_uint8 *pIn, size_t sampleCount)
drwav_uint64 drwav_bytes_to_u64(const drwav_uint8 *data)
drwav_int16 * drwav_open_file_and_read_pcm_frames_s16(const char *filename, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DR_WAVE_FORMAT_PCM
#define DRWAV_NO_DATA_AVAILABLE
drwav_bool32 drwav_init_file_write_w(drwav *pWav, const wchar_t *filename, const drwav_data_format *pFormat, const drwav_allocation_callbacks *pAllocationCallbacks)
unsigned int drwav_uint32
drwav_uint64 drwav_read_pcm_frames_be(drwav *pWav, drwav_uint64 framesToRead, void *pBufferOut)
void drwav_mulaw_to_s32(drwav_int32 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
drwav_bool32 drwav_init_file_w(drwav *pWav, const wchar_t *filename, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_write(drwav *pWav, const char *filename, const drwav_data_format *pFormat, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_int16 * drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t *filename, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_uint32 drwav_bytes_to_u32(const drwav_uint8 *data)
#define DRWAV_INVALID_FILE
drwav_int32 * drwav_open_file_and_read_pcm_frames_s32(const char *filename, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_ex(drwav *pWav, const char *filename, drwav_chunk_proc onChunk, void *pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DRWAV_NOT_CONNECTED
drwav_int32 * drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t *filename, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DRWAV_BAD_PROTOCOL
void drwav_mulaw_to_f32(float *pOut, const drwav_uint8 *pIn, size_t sampleCount)
#define DRWAV_DOES_NOT_EXIST
#define DRWAV_IS_DIRECTORY
#define DRWAV_BAD_ADDRESS
drwav_int32 * drwav_open_memory_and_read_pcm_frames_s32(const void *data, size_t dataSize, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_with_metadata(drwav *pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_tell_proc onTell, void *pUserData, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DRWAV_ALREADY_EXISTS
drwav_bool32 drwav_init(drwav *pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_tell_proc onTell, void *pUserData, const drwav_allocation_callbacks *pAllocationCallbacks)
#define DR_WAVE_FORMAT_ALAW
drwav_result drwav_get_cursor_in_pcm_frames(drwav *pWav, drwav_uint64 *pCursor)
#define DRWAV_VERSION_MAJOR
drwav_int64 drwav_bytes_to_s64(const drwav_uint8 *data)
#define DR_WAVE_FORMAT_ADPCM
#define DRWAV_NOT_IMPLEMENTED
void drwav_s32_to_f32(float *pOut, const drwav_int32 *pIn, size_t sampleCount)
drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav *pWav, const char *filename, const drwav_data_format *pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_int32 * drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_tell_proc onTell, void *pUserData, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
float * drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t *filename, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_metadata * drwav_take_ownership_of_metadata(drwav *pWav)
drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16])
size_t(* drwav_write_proc)(void *pUserData, const void *pData, size_t bytesToWrite)
#define DRWAV_CONNECTION_RESET
#define DRWAV_ALREADY_CONNECTED
drwav_uint16 drwav_bytes_to_u16(const drwav_uint8 *data)
void drwav_u8_to_s32(drwav_int32 *pOut, const drwav_uint8 *pIn, size_t sampleCount)
#define DRWAV_TOO_MANY_OPEN_FILES
#define DRWAV_VERSION_REVISION
signed long long drwav_int64
void drwav_s32_to_s16(drwav_int16 *pOut, const drwav_int32 *pIn, size_t sampleCount)
#define DRWAV_PROTOCOL_NOT_SUPPORTED
drwav_uint64 drwav_read_pcm_frames_f32le(drwav *pWav, drwav_uint64 framesToRead, float *pBufferOut)
drwav_int16 * drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_tell_proc onTell, void *pUserData, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
unsigned long long drwav_uint64
size_t drwav_read_raw(drwav *pWav, size_t bytesToRead, void *pBufferOut)
#define DRWAV_DIRECTORY_NOT_EMPTY
#define DRWAV_CONNECTION_REFUSED
drwav_bool32 drwav_init_memory_write(drwav *pWav, void **ppData, size_t *pDataSize, const drwav_data_format *pFormat, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_uint64 drwav_read_pcm_frames_s32le(drwav *pWav, drwav_uint64 framesToRead, drwav_int32 *pBufferOut)
#define DR_WAVE_FORMAT_IEEE_FLOAT
void drwav_alaw_to_f32(float *pOut, const drwav_uint8 *pIn, size_t sampleCount)
#define DRWAV_WITH_METADATA
unsigned char drwav_uint8
float * drwav_open_file_and_read_pcm_frames_f32(const char *filename, unsigned int *channelsOut, unsigned int *sampleRateOut, drwav_uint64 *totalFrameCountOut, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format *pFormat, drwav_uint64 totalFrameCount, drwav_metadata *pMetadata, drwav_uint32 metadataCount)
void drwav_free(void *p, const drwav_allocation_callbacks *pAllocationCallbacks)
drwav_bool32 drwav_init_file_ex_w(drwav *pWav, const wchar_t *filename, drwav_chunk_proc onChunk, void *pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks *pAllocationCallbacks)
void drwav_s16_to_f32(float *pOut, const drwav_int16 *pIn, size_t sampleCount)
@ drwav_metadata_type_list_all_adtl
@ drwav_metadata_type_list_info_tracknumber
@ drwav_metadata_type_list_all_info_strings
@ drwav_metadata_type_none
@ drwav_metadata_type_list_info_artist
@ drwav_metadata_type_list_info_comment
@ drwav_metadata_type_list_info_date
@ drwav_metadata_type_bext
@ drwav_metadata_type_list_info_genre
@ drwav_metadata_type_list_info_album
@ drwav_metadata_type_list_label
@ drwav_metadata_type_list_info_organization
@ drwav_metadata_type_list_info_description
@ drwav_metadata_type_acid
@ drwav_metadata_type_unknown
@ drwav_metadata_type_list_info_software
@ drwav_metadata_type_cue
@ drwav_metadata_type_list_info_medium
@ drwav_metadata_type_list_labelled_cue_region
@ drwav_metadata_type_list_info_location
@ drwav_metadata_type_smpl
@ drwav_metadata_type_list_info_keywords
@ drwav_metadata_type_list_info_title
@ drwav_metadata_type_list_info_copyright
@ drwav_metadata_type_all_including_unknown
@ drwav_metadata_type_all
@ drwav_metadata_type_inst
@ drwav_metadata_type_list_note
drwav_uint64 drwav_read_pcm_frames_f32(drwav *pWav, drwav_uint64 framesToRead, float *pBufferOut)
drwav_uint64 drwav_read_pcm_frames_s32(drwav *pWav, drwav_uint64 framesToRead, drwav_int32 *pBufferOut)
#define DRWAV_INVALID_OPERATION
size_t(* drwav_read_proc)(void *pUserData, void *pBufferOut, size_t bytesToRead)
drwav_uint64 drwav_write_pcm_frames_be(drwav *pWav, drwav_uint64 framesToWrite, const void *pData)
drwav_result drwav_uninit(drwav *pWav)
unsigned short drwav_uint16
#define DRWAV_IN_PROGRESS
void drwav_version(drwav_uint32 *pMajor, drwav_uint32 *pMinor, drwav_uint32 *pRevision)
@ drwav_acid_flag_acidizer
@ drwav_acid_flag_one_shot
@ drwav_acid_flag_root_note_set
@ drwav_acid_flag_stretch
@ drwav_acid_flag_disk_based
drwav_uint64 drwav_read_pcm_frames_le(drwav *pWav, drwav_uint64 framesToRead, void *pBufferOut)
double sign(const double &v)
Invert a symmetric and positive definite matrix using Cholesky decomposition (defined in Math....
drwav_uint16 midiUnityNote
drwav_uint16 meterNumerator
drwav_uint16 meterDenominator
void *(* onRealloc)(void *p, size_t sz, void *pUserData)
void(* onFree)(void *p, void *pUserData)
void *(* onMalloc)(size_t sz, void *pUserData)
drwav_uint16 maxTruePeakLevel
drwav_uint16 loudnessValue
char pOriginationDate[10]
char * pOriginatorReference
drwav_uint16 maxShortTermLoudness
drwav_uint16 maxMomentaryLoudness
drwav_uint32 codingHistorySize
drwav_uint16 loudnessRange
drwav_uint64 timeReference
drwav_uint32 sampleOffset
drwav_uint8 dataChunkId[4]
drwav_uint32 playOrderPosition
drwav_uint32 cuePointCount
drwav_cue_point * pCuePoints
drwav_uint16 bitsPerSample
drwav_uint32 avgBytesPerSec
drwav_uint8 subFormat[16]
drwav_uint16 validBitsPerSample
drwav_uint16 extendedSize
drwav_uint32 stringLength
drwav_uint32 stringLength
drwav_uint32 stringLength
drwav_uint32 sampleLength
drwav_uint32 sampleFraction
drwav_uint32 firstSampleOffset
drwav_uint32 lastSampleOffset
drwav_uint32 manufacturerId
drwav_uint32 samplePeriodNanoseconds
drwav_uint32 midiPitchFraction
drwav_uint8 * pSamplerSpecificData
drwav_uint32 sampleLoopCount
drwav_uint32 samplerSpecificDataSizeInBytes
drwav_uint32 midiUnityNote
drwav_uint32 metadataCount
struct drwav::@97 msadpcm
drwav_uint64 dataChunkDataSizeTargetWrite
drwav_uint16 predictor[2]
drwav_container container
drwav_int32 prevFrames[2][2]
drwav_uint64 readCursorInPCMFrames
drwav_int32 cachedFrames[4]
drwav__memory_stream memoryStream
drwav_allocation_callbacks allocationCallbacks
drwav__memory_stream_write memoryStreamWrite
drwav_bool32 isSequentialWrite
drwav_uint16 translatedFormatTag
drwav_uint64 dataChunkDataSize
drwav_uint32 bytesRemainingInBlock
drwav_uint16 bitsPerSample
drwav_uint64 dataChunkDataPos
drwav_uint64 totalPCMFrameCount
drwav_metadata * pMetadata
drwav_uint32 cachedFrameCount
drwav_uint64 bytesRemaining
int diff(std::string contextName, folderType fType, bool verbose)