#define _FILE_OFFSET_BITS 64 #define _POSIX_C_SOURCE 200809L #include #include #include #include #include #include #include #include #include #include "audio.h" #include "audio_internal.h" #define DRWAV_MAX_SAMPLE_RATE 1000000U #define DR_WAV_IMPLEMENTATION #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-function" #pragma GCC diagnostic ignored "-Wpedantic" #pragma GCC diagnostic ignored "-Wsign-compare" #pragma GCC diagnostic ignored "-Wmissing-field-initializers" #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wfloat-equal" #pragma GCC diagnostic ignored "-Wcast-qual" #pragma GCC diagnostic ignored "-Wcast-align" #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" #pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wformat" #endif #include "dr_wav.h" #if defined(__GNUC__) || defined(__clang__) #pragma GCC diagnostic pop #endif #define WAV_SCRATCH_FRAMES 4096U static const uint8_t GUID_TAIL[12] = { 0x00U, 0x00U, 0x10U, 0x00U, 0x80U, 0x00U, 0x00U, 0xAAU, 0x00U, 0x38U, 0x9BU, 0x71U }; typedef struct { FILE *file; drwav decoder; bool decoder_initialized; float scratch[WAV_SCRATCH_FRAMES * 2U]; } WavSource; static size_t wav_read_proc(void *user_data, void *buffer, size_t bytes) { FILE *file = user_data; return fread(buffer, 1U, bytes, file); } static drwav_bool32 wav_seek_proc(void *user_data, int offset, drwav_seek_origin origin) { FILE *file = user_data; int whence; switch (origin) { case DRWAV_SEEK_SET: whence = SEEK_SET; break; case DRWAV_SEEK_CUR: whence = SEEK_CUR; break; case DRWAV_SEEK_END: whence = SEEK_END; break; default: return DRWAV_FALSE; } return fseeko(file, (off_t)offset, whence) == 0 ? DRWAV_TRUE : DRWAV_FALSE; } static bool wav_scan(FILE *file, uint64_t file_size, uint64_t *data_offset, uint64_t *data_size, char *message, size_t message_size) { uint8_t header[12]; uint64_t riff_end; uint64_t position = 12U; uint64_t found_data_offset = 0U; uint64_t found_data_size = 0U; bool found_format = false; bool found_data = false; if (!seek_stream(file, 0U, message, message_size, "WAV header") || !read_exactly(file, header, sizeof(header), message, message_size, "WAV header")) { return false; } if (memcmp(header, "RIFF", 4U) != 0) { if (memcmp(header, "RF64", 4U) == 0) { return set_message(message, message_size, "RF64 input is not supported"); } if (memcmp(header, "RIFX", 4U) == 0) { return set_message(message, message_size, "big-endian RIFX input is not supported"); } return set_message(message, message_size, "input is not a RIFF WAV file"); } if (memcmp(header + 8U, "WAVE", 4U) != 0) { return set_message(message, message_size, "RIFF file is not a WAVE file"); } riff_end = 8U + (uint64_t)read_u32_le(header + 4U); if (riff_end < 12U || riff_end > file_size) { return set_message(message, message_size, "WAV RIFF size extends beyond the physical file"); } while (position + 8U <= riff_end) { uint8_t chunk_header[8]; uint32_t chunk_size; uint64_t payload; uint64_t next; if (!seek_stream(file, position, message, message_size, "WAV chunk header") || !read_exactly(file, chunk_header, sizeof(chunk_header), message, message_size, "WAV chunk header")) { return false; } chunk_size = read_u32_le(chunk_header + 4U); if (!checked_add_u64(position, 8U, &payload) || !checked_add_u64(payload, chunk_size, &next) || !checked_add_u64(next, chunk_size & 1U, &next) || next > riff_end) { return set_message(message, message_size, "WAV chunk extends beyond the RIFF boundary"); } if (memcmp(chunk_header, "fmt ", 4U) == 0) { if (found_format) { return set_message(message, message_size, "WAV contains multiple fmt chunks"); } if (chunk_size < 16U) { return set_message(message, message_size, "WAV fmt chunk is smaller than 16 bytes"); } found_format = true; } else if (memcmp(chunk_header, "data", 4U) == 0) { if (found_data) { return set_message(message, message_size, "WAV contains multiple data chunks"); } found_data_offset = payload; found_data_size = chunk_size; found_data = true; } position = next; } if (position != riff_end) { return set_message(message, message_size, "WAV ends with an incomplete chunk header"); } if (!found_format) { return set_message(message, message_size, "WAV has no fmt chunk"); } if (!found_data) { return set_message(message, message_size, "WAV has no data chunk"); } if (found_data_size == 0U) { return set_message(message, message_size, "WAV data chunk is empty"); } *data_offset = found_data_offset; *data_size = found_data_size; return true; } static bool wav_configure(AudioSource *source, WavSource *wav, uint64_t data_offset, uint64_t data_size, char *message, size_t message_size) { drwav *decoder = &wav->decoder; uint16_t channels = decoder->channels; uint32_t sample_rate = decoder->sampleRate; uint16_t bits = decoder->bitsPerSample; uint16_t valid_bits = decoder->fmt.validBitsPerSample; uint16_t block_align = decoder->fmt.blockAlign; uint32_t channel_mask = decoder->fmt.channelMask; if (decoder->container != drwav_container_riff) { return set_message(message, message_size, "unsupported WAV container: expected RIFF"); } if (channels != 1U && channels != 2U) { return set_message(message, message_size, "WAV must contain one or two channels (found %u)", (unsigned)channels); } if (sample_rate < 8000U || sample_rate > 768000U) { return set_message(message, message_size, "unsupported WAV sample rate: %" PRIu32, sample_rate); } if (bits == 0U || (bits % 8U) != 0U) { return set_message(message, message_size, "unsupported WAV container bit depth: %u", (unsigned)bits); } if (decoder->fmt.formatTag != DR_WAVE_FORMAT_EXTENSIBLE) { valid_bits = bits; } if (valid_bits == 0U || valid_bits > bits) { return set_message(message, message_size, "invalid WAV valid bit depth: %u in a %u-bit container", (unsigned)valid_bits, (unsigned)bits); } if (block_align != (uint16_t)(channels * (bits / 8U)) || block_align == 0U) { return set_message(message, message_size, "invalid WAV block alignment"); } if (decoder->fmt.formatTag == DR_WAVE_FORMAT_EXTENSIBLE) { uint32_t subtype = read_u32_le(decoder->fmt.subFormat); if ((subtype != 1U && subtype != 3U) || memcmp(decoder->fmt.subFormat + 4U, GUID_TAIL, sizeof(GUID_TAIL)) != 0) { return set_message(message, message_size, "unsupported WAVE_FORMAT_EXTENSIBLE subtype"); } } if (decoder->translatedFormatTag == 1U) { if (bits != 8U && bits != 16U && bits != 24U && bits != 32U) { return set_message(message, message_size, "unsupported PCM WAV bit depth: %u", (unsigned)bits); } } else if (decoder->translatedFormatTag == 3U) { if (bits != 32U || valid_bits != 32U) { return set_message(message, message_size, "IEEE-float WAV must use 32-bit samples"); } } else { return set_message(message, message_size, "unsupported compressed WAV format tag: 0x%04x", (unsigned)decoder->fmt.formatTag); } if (decoder->fmt.avgBytesPerSec != sample_rate * (uint32_t)block_align) { fprintf(stderr, "warning: WAV byte rate is inconsistent; decoding by block alignment\n"); } if (channel_mask != 0U) { unsigned set_bits = 0U; uint32_t mask = channel_mask; while (mask != 0U) { set_bits += mask & 1U; mask >>= 1U; } if (set_bits != channels) { return set_message(message, message_size, "WAV channel mask does not match its channel count"); } if (channels == 2U && channel_mask != UINT32_C(0x00000003)) { return set_message(message, message_size, "unsupported stereo WAV channel mask: expected " "front-left/front-right"); } } if ((data_size % block_align) != 0U) { return set_message(message, message_size, "WAV data chunk ends with a partial audio frame"); } if (decoder->dataChunkDataPos != data_offset || decoder->dataChunkDataSize != data_size) { return set_message(message, message_size, "WAV data chunk is inconsistent with its header"); } if (decoder->totalPCMFrameCount != data_size / block_align) { return set_message(message, message_size, "WAV frame count is inconsistent with its data size"); } source->channels = channels; source->sample_rate = sample_rate; source->total_frames = decoder->totalPCMFrameCount; source->frames_read = 0U; return true; } static bool wav_open(AudioSource *source, WavSource *wav, const char *path, char *message, size_t message_size) { uint64_t file_size; uint64_t data_offset = 0U; uint64_t data_size = 0U; wav->file = fopen(path, "rb"); if (wav->file == NULL) { return set_message(message, message_size, "cannot open input WAV '%s': %s", path, strerror(errno)); } if (fseeko(wav->file, 0, SEEK_END) != 0) { return set_message(message, message_size, "cannot inspect input WAV '%s': %s", path, strerror(errno)); } { off_t end = ftello(wav->file); if (end < 0) { return set_message(message, message_size, "cannot determine input WAV size: %s", strerror(errno)); } file_size = (uint64_t)end; } if (!wav_scan(wav->file, file_size, &data_offset, &data_size, message, message_size)) { return false; } if (!seek_stream(wav->file, 0U, message, message_size, "WAV header")) { return false; } if (!drwav_init(&wav->decoder, wav_read_proc, wav_seek_proc, NULL, wav->file, NULL)) { return set_message(message, message_size, "cannot decode WAV '%s': invalid or unsupported stream", path); } wav->decoder_initialized = true; return wav_configure(source, wav, data_offset, data_size, message, message_size); } static bool wav_read_frames(AudioSource *source, float *stereo, size_t requested, size_t *frames_read, char *message, size_t message_size) { WavSource *wav = source->impl; uint64_t remaining = source->total_frames - source->frames_read; size_t count = requested; size_t produced = 0U; *frames_read = 0U; if ((uint64_t)count > remaining) { count = (size_t)remaining; } while (produced < count) { size_t want = count - produced; drwav_uint64 got; size_t frame; if (want > WAV_SCRATCH_FRAMES) { want = WAV_SCRATCH_FRAMES; } got = drwav_read_pcm_frames_f32(&wav->decoder, (drwav_uint64)want, wav->scratch); if (got == 0U) { return set_message(message, message_size, "unexpected end of WAV audio data"); } for (frame = 0U; frame < (size_t)got; ++frame) { float left = wav->scratch[frame * source->channels]; float right = source->channels == 2U ? wav->scratch[frame * 2U + 1U] : left; if (!isfinite(left) || !isfinite(right)) { return set_message(message, message_size, "WAV contains a NaN or infinite float sample"); } stereo[(produced + frame) * 2U] = left; stereo[(produced + frame) * 2U + 1U] = right; } produced += (size_t)got; if ((size_t)got < want) { return set_message(message, message_size, "unexpected end of WAV audio data"); } } source->frames_read += produced; *frames_read = produced; return true; } static void wav_close(AudioSource *source) { WavSource *wav = source->impl; if (wav != NULL) { if (wav->decoder_initialized) { (void)drwav_uninit(&wav->decoder); wav->decoder_initialized = false; } if (wav->file != NULL) { (void)fclose(wav->file); wav->file = NULL; } free(wav); source->impl = NULL; } } static const AudioSourceOps WAV_OPS = { wav_read_frames, wav_close }; bool wav_source_open(AudioSource *source, const char *path, char *message, size_t message_size) { WavSource *wav = calloc(1U, sizeof(*wav)); if (wav == NULL) { return set_message(message, message_size, "cannot allocate the WAV reader: %s", strerror(errno)); } if (!wav_open(source, wav, path, message, message_size)) { if (wav->decoder_initialized) { (void)drwav_uninit(&wav->decoder); } if (wav->file != NULL) { (void)fclose(wav->file); } free(wav); return false; } source->format_name = "WAV"; source->ops = &WAV_OPS; source->impl = wav; return true; }