wav_reader.c File Reference

#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include "audio/utils.h"
#include "audio/wav_reader.h"
#include "debug.h"
#include "utils/macros.h"
#include "utils/misc.h"

Include dependency graph for wav_reader.c:

Go to the source code of this file.

Macros
#define	CHECK(cmd, retval)
#define	GUID_PCM   { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 }
#define	MOD_NAME   "[WAV reader] "
#define	READ_N(buf, len)
#define	WAV_MAX_BIT_DEPTH   64
#define	WAV_MAX_CHANNELS   128

Functions
static int	fskip (FILE *f, long off)
const char *	get_wav_error (int errcode)
static _Bool	is_member (const char *needle, const char **haystack)
static _Bool	process_data_chunk (FILE *wav_file, uint32_t chunk_size, struct wav_metadata *metadata, _Bool found_ds64_chunk)
static _Bool	read_ds64 (FILE *wav_file, uint32_t chunk_size, struct wav_metadata *metadata)
static int	read_fmt_chunk (FILE *wav_file, struct wav_metadata *metadata, size_t chunk_size)
int	read_wav_header (FILE *wav_file, struct wav_metadata *metadata)
size_t	wav_read (void *buffer, size_t sample_count, FILE *wav_file, struct wav_metadata *metadata)
int	wav_seek (FILE *wav_file, long offset, int whence, struct wav_metadata *metadata)
	same as fseek but WAV header presence is respected (for SEEK SET)

Detailed Description

Author

Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz

Definition in file wav_reader.c.

Macro Definition Documentation

CHECK

#define CHECK	(		cmd,
			retval )

Value:

if (cmd == -1) return retval;

Definition at line 214 of file wav_reader.c.

Referenced by read_wav_header().

GUID_PCM

#define GUID_PCM   { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 }

Definition at line 65 of file wav_reader.c.

Referenced by read_fmt_chunk().

MOD_NAME

#define MOD_NAME   "[WAV reader] "

Definition at line 55 of file wav_reader.c.

Referenced by get_wav_error(), process_data_chunk(), read_ds64(), read_fmt_chunk(), and read_wav_header().

READ_N

#define READ_N	(		buf,
			len )

Value:

        if (fread(buf, len, 1, wav_file) != 1) {\
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Read error: %s.\n", ug_strerror(errno));\
                return WAV_HDR_PARSE_READ_ERROR;\
        }

Definition at line 59 of file wav_reader.c.

#define READ_N(buf, len) \
        if (fread(buf, len, 1, wav_file) != 1) {\
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Read error: %s.\n", ug_strerror(errno));\
                return WAV_HDR_PARSE_READ_ERROR;\
        }

Referenced by read_ds64(), read_fmt_chunk(), and read_wav_header().

WAV_MAX_BIT_DEPTH

#define WAV_MAX_BIT_DEPTH   64

Definition at line 56 of file wav_reader.c.

Referenced by read_fmt_chunk().

WAV_MAX_CHANNELS

#define WAV_MAX_CHANNELS   128

Definition at line 57 of file wav_reader.c.

Referenced by read_fmt_chunk().

Function Documentation

fskip()

static int fskip ( FILE * f, long off )

static

Definition at line 147 of file wav_reader.c.

                                    {
        if (_fseeki64(f, off, SEEK_CUR) == 0) {
                return 1;
        }
        while (off-- > 0) {
                if (getc(f) == EOF) {
                        return -1;
                }
        }
        return 1;
}

References _fseeki64.

Referenced by read_ds64(), and read_wav_header().

get_wav_error()

const char * get_wav_error

(

int

errcode

)

Definition at line 300 of file wav_reader.c.

{
        switch(errcode) {
                case WAV_HDR_PARSE_OK:
                        return "Wav header OK";
                case WAV_HDR_PARSE_READ_ERROR:
                        return "Premature end of WAV file";
                case WAV_HDR_PARSE_WRONG_FORMAT:
                        return "Wav header in wrong format";
                case WAV_HDR_PARSE_NOT_PCM:
                        return "Wav not in PCM";
                case WAV_HDR_PARSE_INVALID_PARAM:
                        return "Wrong/unsupported value in header";
                default:
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unknown error code %d passed!\n", errcode);
                        return "Unknown error";
        }
}

References LOG_LEVEL_ERROR, log_msg(), MOD_NAME, WAV_HDR_PARSE_INVALID_PARAM, WAV_HDR_PARSE_NOT_PCM, WAV_HDR_PARSE_OK, WAV_HDR_PARSE_READ_ERROR, and WAV_HDR_PARSE_WRONG_FORMAT.

Referenced by audio_testcard_read_wav(), and init_audio().

Here is the call graph for this function:

is_member()

static _Bool is_member ( const char * needle, const char ** haystack )

static

Definition at line 137 of file wav_reader.c.

                                                                  {
        while (*haystack != NULL) {
                if (strncmp(needle, *haystack, 4) == 0) {
                        return 1;
                }
                haystack++;
        }
        return 0;
}

Referenced by read_wav_header().

process_data_chunk()

static _Bool process_data_chunk ( FILE * wav_file, uint32_t chunk_size, struct wav_metadata * metadata, _Bool found_ds64_chunk )

static

Sets data_offset and data_size to metadata (from file position and actual chunk size) Return 1 (true) also for non-seekable > 4GB streams (caller may read it sequentially).

Definition at line 161 of file wav_reader.c.

                                                                                                                            {
        if (!found_ds64_chunk) { // RF64 has this chunk size always -1, value from ds64 is used instead
                metadata->data_size = chunk_size;
        }
        metadata->data_offset = _ftelli64(wav_file);
        if (metadata->data_size != UINT32_MAX || metadata->data_offset == -1) {
                return 1;
        }
 
        // for UINT32_MAX deduce the length from file length (as FFmpeg does)
        if (_fseeki64(wav_file, 0, SEEK_END) != 0) {
                return 1;
        }
        int64_t data_end = _ftelli64(wav_file);
        if (data_end == -1) {
                ug_perror(MOD_NAME "cannot get length of file");
               return 0;
        }
        if (_fseeki64(wav_file, metadata->data_offset, SEEK_SET) != 0) {
                ug_perror(MOD_NAME "cannot seek back to data chunk");
                return 0;
        }
        metadata->data_size = data_end - metadata->data_offset;
        return 1;
}

References _fseeki64, _ftelli64, wav_metadata::data_offset, wav_metadata::data_size, MOD_NAME, and ug_perror().

Referenced by read_wav_header().

Here is the call graph for this function:

read_ds64()

static _Bool read_ds64 ( FILE * wav_file, uint32_t chunk_size, struct wav_metadata * metadata )

static

Definition at line 187 of file wav_reader.c.

                                                                                           {
        if (chunk_size < 28) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "ds64 chunk size must be at least 28 but %" PRIu32 " was presented!\n", chunk_size);
                return 0;
        }
        uint64_t tmp = 0;
        READ_N(&tmp, 8); // RF64 chunk size - unused
        READ_N(&tmp, 8);
        assert(tmp <= LLONG_MAX);
        metadata->data_size = tmp;
        READ_N(&tmp, 8); // dummy - should be ignored
        uint32_t table_count = 0;
        const size_t table_sz = (sizeof(uint32_t) /*ID*/ + sizeof(uint64_t) /*size*/);
        READ_N(&table_count, 4); // number of table entries for non-'data' chunks
        assert(table_sz * table_count <= MIN(sizeof(uint32_t), sizeof(long))); // check overflows
        if (chunk_size - 28 != table_sz * table_count) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "incorrect table count %" PRIu32 " given, ds64 chunk len %" PRIu32 "\n",
                                table_count, chunk_size);
                return 0;
        }
        if (!fskip(wav_file, (long)(table_count * table_sz))) { // just skip the table contents
                ug_perror(MOD_NAME "ds64 - cannot skip");
                return 0;
        }
        return 1;
}

References wav_metadata::data_size, fskip(), LOG_LEVEL_ERROR, log_msg(), MIN, MOD_NAME, READ_N, and ug_perror().

Referenced by read_wav_header().

Here is the call graph for this function:

read_fmt_chunk()

static int read_fmt_chunk ( FILE * wav_file, struct wav_metadata * metadata, size_t chunk_size )

static

Definition at line 67 of file wav_reader.c.

{
        if (chunk_size != 16 && chunk_size != 18 && chunk_size != 40) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Expected fmt chunk size 16, 18 or 40, %zd given.\n", chunk_size);
                return WAV_HDR_PARSE_WRONG_FORMAT;
        }
 
        uint16_t format;
        READ_N(&format, 2);
        if (format != 0x0001 && format != 0xFFFE) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Expected format 0x0001, 0x%04d given.\n", format);
                return WAV_HDR_PARSE_NOT_PCM;
        }
 
        uint16_t ch_count;
        READ_N(&ch_count, 2);
        if (ch_count == 0 || ch_count > WAV_MAX_CHANNELS) {
                return WAV_HDR_PARSE_INVALID_PARAM;
        }
        metadata->ch_count = ch_count;
 
        uint32_t sample_rate;
        READ_N(&sample_rate, sizeof(sample_rate));
        if (sample_rate > 192000) {
                return WAV_HDR_PARSE_INVALID_PARAM;
        }
        metadata->sample_rate = sample_rate;
 
        uint32_t avg_bytes_per_sec;
        READ_N(&avg_bytes_per_sec, sizeof(avg_bytes_per_sec));
 
        uint16_t block_align_offset;
        READ_N(&block_align_offset, sizeof(block_align_offset));
 
        uint16_t bits_per_sample;
        READ_N(&bits_per_sample, sizeof(bits_per_sample));
        if (bits_per_sample == 0 || bits_per_sample > WAV_MAX_BIT_DEPTH) {
                return WAV_HDR_PARSE_INVALID_PARAM;
        }
        metadata->bits_per_sample = bits_per_sample;
 
        if (chunk_size >= 18) {
                uint16_t ext_size;
                READ_N(&ext_size, 2);
                if (ext_size != chunk_size - 18) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unexpected ext size %" PRIu16 ", remaining chunk size %zu.\n", ext_size, chunk_size - 18);
                        return WAV_HDR_PARSE_READ_ERROR;
                }
                if (ext_size == 22) {
                        READ_N(&metadata->valid_bits, sizeof metadata->valid_bits);
                        READ_N(&metadata->channel_mask, sizeof metadata->channel_mask);
                        char buffer[16];
                        READ_N(buffer, 16);
                        const char guid[] = GUID_PCM;
                        if (memcmp(guid, buffer, 16) != 0) {
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "GUID is not PCM!\n");
                                return WAV_HDR_PARSE_NOT_PCM;
                        }
                        format = 0x0001;
                }
        }
 
        if (format == 0xFFFE) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Subtype GUID not found!\n");
                return WAV_HDR_PARSE_READ_ERROR;
        }
 
        return WAV_HDR_PARSE_OK;
}

References wav_metadata::bits_per_sample, wav_metadata::ch_count, wav_metadata::channel_mask, GUID_PCM, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, READ_N, sample_rate, wav_metadata::sample_rate, wav_metadata::valid_bits, WAV_HDR_PARSE_INVALID_PARAM, WAV_HDR_PARSE_NOT_PCM, WAV_HDR_PARSE_OK, WAV_HDR_PARSE_READ_ERROR, WAV_HDR_PARSE_WRONG_FORMAT, WAV_MAX_BIT_DEPTH, and WAV_MAX_CHANNELS.

Referenced by read_wav_header().

Here is the call graph for this function:

read_wav_header()

int read_wav_header	(	FILE *	wav_file,
		struct wav_metadata *	metadata )

This function reads wav header

If read successfully, it leaves read file position at the beginning of data. Currently, only interleaved PCM is supported.

Return values

WAV_HDR_PARSE_OK	if ok
WAV_HDR_PARSE_READ_ERROR	in case of file read error
WAV_HDR_PARSE_WRONG_FORMAT	if unsupported wav format
WAV_HDR_PARSE_NOT_PCM	non-PCM WAV detected

< RF64 or BW64

Definition at line 215 of file wav_reader.c.

{
        char buffer[16];
        uint32_t chunk_size;
        rewind(wav_file);
 
        _Bool rf64 = 0; 
        READ_N(buffer, 4);
        if (strncmp(buffer, "RF64", 4) == 0 || strncmp(buffer, "BW64", 4) == 0) {
                log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Using %4.4s WAV file.\n", buffer);
                rf64 = 1;
        } else if (strncmp(buffer, "RIFF", 4) != 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Expected RIFF or RF64/BW64 chunk, %.4s given.\n", buffer);
                return WAV_HDR_PARSE_WRONG_FORMAT;
        }
 
        // this is the length of the rest of the file, we may ignore
        READ_N(&chunk_size, 4);
 
        READ_N(buffer, 4);
        if (strncmp(buffer, "WAVE", 4) != 0) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Expected WAVE chunk, %.4s given.\n", buffer);
                return WAV_HDR_PARSE_WRONG_FORMAT;
        }
 
        bool found_data_chunk = false;
        bool found_ds64_chunk = false;
        bool found_fmt_chunk = false;
        while (fread(buffer, 4, 1, wav_file) == 1) {
                READ_N(&chunk_size, 4);
                if (strncmp(buffer, "data", 4) == 0) {
                        if (!process_data_chunk(wav_file, chunk_size, metadata, found_ds64_chunk)) {
                                return WAV_HDR_PARSE_READ_ERROR;
                        }
                        found_data_chunk = true;
                        break;
                }
                if (strncmp(buffer, "ds64", 4) == 0) {
                        if (!read_ds64(wav_file, chunk_size, metadata)) {
                                return WAV_HDR_PARSE_WRONG_FORMAT;
                        }
                        found_ds64_chunk = true;
                } else if (strncmp(buffer, "fmt ", 4) == 0) {
                        found_fmt_chunk = true;
                        int rc = read_fmt_chunk(wav_file, metadata, chunk_size);
                        if (rc != WAV_HDR_PARSE_OK) {
                                return rc;
                        }
                } else { // other tags
                        const char *known_tags[] = { "JUNK", "LIST", "id3 ", NULL }; // "olym" ?
                        int level = is_member(buffer, known_tags) ? LOG_LEVEL_VERBOSE : LOG_LEVEL_WARNING;
                        log_msg(level, MOD_NAME "Skipping chunk \"%4.4s\" sized %" PRIu32 " B!\n", buffer, chunk_size);
                        CHECK(fskip(wav_file, chunk_size), WAV_HDR_PARSE_READ_ERROR);
                }
        }
 
        if (!found_data_chunk) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Data chunk not found!\n");
                return WAV_HDR_PARSE_READ_ERROR;
        }
 
        if (!found_fmt_chunk) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Fmt chunk not found!\n");
                return WAV_HDR_PARSE_READ_ERROR;
        }
 
        if (rf64 && !found_ds64_chunk) { // buggy, but we may try to continue witn implicit data size
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Broken WAV - a RF64 file detected but no ds64 chunk found!\n");
        }
 
        log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "File parsed correctly - length %lld bytes, data offset %lld.\n",
                        metadata->data_size, metadata->data_offset);
 
        return WAV_HDR_PARSE_OK;
}

References CHECK, wav_metadata::data_offset, wav_metadata::data_size, fskip(), is_member(), LOG_LEVEL_ERROR, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, process_data_chunk(), read_ds64(), read_fmt_chunk(), READ_N, WAV_HDR_PARSE_OK, WAV_HDR_PARSE_READ_ERROR, and WAV_HDR_PARSE_WRONG_FORMAT.

Referenced by audio_testcard_read_wav(), and init_audio().

Here is the call graph for this function:

wav_read()

size_t wav_read	(	void *	buffer,
		size_t	sample_count,
		FILE *	wav_file,
		struct wav_metadata *	metadata )

Reads sample_count samples from wav_file according to metadata.

Note

conversion to signed is performed if wav sample type is u8

Definition at line 291 of file wav_reader.c.

{
        size_t samples = fread(buffer, metadata->ch_count * metadata->bits_per_sample / 8, sample_count, wav_file);
        if (metadata->bits_per_sample == 8) {
                signed2unsigned(buffer, buffer, samples * metadata->ch_count * metadata->bits_per_sample / 8);
        }
        return samples;
}

References wav_metadata::bits_per_sample, wav_metadata::ch_count, and signed2unsigned().

Referenced by audio_reading_thread(), and audio_testcard_read_wav().

Here is the call graph for this function:

wav_seek()

int wav_seek	(	FILE *	wav_file,
		long	offset,
		int	whence,
		struct wav_metadata *	metadata )

same as fseek but WAV header presence is respected (for SEEK SET)

Definition at line 319 of file wav_reader.c.

{
        if (whence == SEEK_CUR || whence == SEEK_END) {
                return fseek(wav_file, offset, whence);
        }
        assert(whence == SEEK_SET);
        return fseek(wav_file, metadata->data_offset + offset, SEEK_SET);
}

References wav_metadata::data_offset, and offset.

Referenced by audio_reading_thread(), and reset_import().