Removal of sdi->index, step 4: fix trivial sr_dev_inst_new() calls

[libsigrok.git] / src / input / wav.c

diff --git a/src/input/wav.c b/src/input/wav.c
index fabe92c7a5fbfbd50c8c6e7096903ac871168502..528209569a71824de3245ecea2abe1c891b3659f 100644 (file)
--- a/src/input/wav.c
+++ b/src/input/wav.c
@@ -23,6 +23,7 @@
 #include <fcntl.h>
 #include <ctype.h>
 #include <string.h>
+#include <stdint.h>
 #include "libsigrok.h"
 #include "libsigrok-internal.h"
 
@@ -37,8 +38,9 @@
 /* Expect to find the "data" chunk within this offset from the start. */
 #define MAX_DATA_CHUNK_OFFSET    256
 
-#define WAVE_FORMAT_PCM          1
-#define WAVE_FORMAT_IEEE_FLOAT   3
+#define WAVE_FORMAT_PCM          0x0001
+#define WAVE_FORMAT_IEEE_FLOAT   0x0003
+#define WAVE_FORMAT_EXTENSIBLE   0xfffe
 
 struct context {
        int fmt_code;
@@ -52,32 +54,61 @@ struct context {
 static int parse_wav_header(GString *buf, struct context *inc)
 {
        uint64_t samplerate;
-       int fmt_code, samplesize, num_channels, unitsize;
+       unsigned int fmt_code, samplesize, num_channels, unitsize;
 
-       if (buf->len < MIN_DATA_CHUNK_OFFSET) {
+       if (buf->len < MIN_DATA_CHUNK_OFFSET)
+               return SR_OK_CONTINUE;
+
+       fmt_code = RL16(buf->str + 20);
+       samplerate = RL32(buf->str + 24);
+
+       samplesize = RL16(buf->str + 32);
+       num_channels = RL16(buf->str + 22);
+       if (num_channels == 0)
                return SR_ERR;
+       unitsize = samplesize / num_channels;
+       if (unitsize != 1 && unitsize != 2 && unitsize != 4) {
+               sr_err("Only 8, 16 or 32 bits per sample supported.");
+               return SR_ERR_DATA;
        }
 
-       fmt_code = GUINT16_FROM_LE(*(uint16_t *)(buf->str + 20));
-       samplerate = GUINT32_FROM_LE(*(uint32_t *)(buf->str + 24));
-       samplesize = GUINT16_FROM_LE(*(uint16_t *)(buf->str + 32));
-       num_channels = GUINT16_FROM_LE(*(uint16_t *)(buf->str + 22));
-       /* TODO div0 */
-       unitsize = samplesize / num_channels;
 
        if (fmt_code == WAVE_FORMAT_PCM) {
-               if (samplesize != 1 && samplesize != 2 && samplesize != 4) {
-                       sr_err("only 8, 16 or 32 bits per sample supported.");
-                       return SR_ERR;
-               }
        } else if (fmt_code == WAVE_FORMAT_IEEE_FLOAT) {
                if (unitsize != 4) {
                        sr_err("only 32-bit floats supported.");
+                       return SR_ERR_DATA;
+               }
+       } else if (fmt_code == WAVE_FORMAT_EXTENSIBLE) {
+               if (buf->len < 70)
+                       /* Not enough for extensible header and next chunk. */
+                       return SR_OK_CONTINUE;
+
+               if (RL16(buf->str + 16) != 40) {
+                       sr_err("WAV extensible format chunk must be 40 bytes.");
+                       return SR_ERR;
+               }
+               if (RL16(buf->str + 36) != 22) {
+                       sr_err("WAV extension must be 22 bytes.");
                        return SR_ERR;
                }
+               if (RL16(buf->str + 34) != RL16(buf->str + 38)) {
+                       sr_err("Reduced valid bits per sample not supported.");
+                       return SR_ERR_DATA;
+               }
+               /* Real format code is the first two bytes of the GUID. */
+               fmt_code = RL16(buf->str + 44);
+               if (fmt_code != WAVE_FORMAT_PCM && fmt_code != WAVE_FORMAT_IEEE_FLOAT) {
+                       sr_err("Only PCM and floating point samples are supported.");
+                       return SR_ERR_DATA;
+               }
+               if (fmt_code == WAVE_FORMAT_IEEE_FLOAT && unitsize != 4) {
+                       sr_err("only 32-bit floats supported.");
+                       return SR_ERR_DATA;
+               }
        } else {
                sr_err("Only PCM and floating point samples are supported.");
-               return SR_ERR;
+               return SR_ERR_DATA;
        }
 
        if (inc) {
@@ -95,29 +126,30 @@ static int parse_wav_header(GString *buf, struct context *inc)
 static int format_match(GHashTable *metadata)
 {
        GString *buf;
+       int ret;
 
        buf = g_hash_table_lookup(metadata, GINT_TO_POINTER(SR_INPUT_META_HEADER));
        if (strncmp(buf->str, "RIFF", 4))
-               return FALSE;
+               return SR_ERR;
        if (strncmp(buf->str + 8, "WAVE", 4))
-               return FALSE;
+               return SR_ERR;
        if (strncmp(buf->str + 12, "fmt ", 4))
-               return FALSE;
+               return SR_ERR;
        /*
         * Only gets called when we already know this is a WAV file, so
         * this parser can log error messages.
         */
-       if (parse_wav_header(buf, NULL) != SR_OK)
-               return FALSE;
+       if ((ret = parse_wav_header(buf, NULL)) != SR_OK)
+               return ret;
 
-       return TRUE;
+       return SR_OK;
 }
 
 static int init(struct sr_input *in, GHashTable *options)
 {
        (void)options;
 
-       in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
+       in->sdi = sr_dev_inst_new(SR_ST_ACTIVE, NULL, NULL, NULL);
 
        return SR_OK;
 }
@@ -139,7 +171,7 @@ static int find_data_chunk(GString *buf, int initial_offset)
                                return -1;
                }
                /* Skip past this chunk. */
-               offset += 8 + GUINT32_FROM_LE(*(uint32_t *)(buf->str + offset + 4));
+               offset += 8 + RL32(buf->str + offset + 4);
        }
 
        return offset;
@@ -152,7 +184,7 @@ static int initial_receive(struct sr_input *in)
        struct sr_channel *ch;
        struct sr_config *src;
        struct context *inc;
-       int i;
+       int ret, i;
        char channelname[8];
 
        if (!in->buf)
@@ -160,8 +192,8 @@ static int initial_receive(struct sr_input *in)
                return SR_ERR;
 
        inc = in->priv = g_malloc(sizeof(struct context));
-       if (parse_wav_header(in->buf, inc) != SR_OK)
-               return SR_ERR;
+       if ((ret = parse_wav_header(in->buf, inc)) != SR_OK)
+               return ret;
 
        for (i = 0; i < inc->num_channels; i++) {
                snprintf(channelname, 8, "CH%d", i + 1);
@@ -204,20 +236,21 @@ static void send_chunk(const struct sr_input *in, int offset, int num_samples)
                        switch (inc->samplesize) {
                        case 1:
                                /* 8-bit PCM samples are unsigned. */
-                               fdata[samplenum] = (uint8_t)sample / 255.0;
+                               fdata[samplenum] = (uint8_t)sample / (float)255;
                                break;
                        case 2:
-                               fdata[samplenum] = GINT16_FROM_LE(sample) / 32767.0;
+                               fdata[samplenum] = RL16S(&sample) / (float)INT16_MAX;
                                break;
                        case 4:
-                               fdata[samplenum] = GINT32_FROM_LE(sample) / 65535.0;
+                               fdata[samplenum] = RL32S(&sample) / (float)INT32_MAX;
                                break;
                        }
                } else {
                        /* BINARY32 float */
 #ifdef WORDS_BIGENDIAN
+                       int i;
                        for (i = 0; i < inc->unitsize; i++)
-                               d[i] = s[inc->unitsize - i];
+                               d[i] = s[inc->unitsize - 1 - i];
 #else
                        memcpy(d, s, inc->unitsize);
 #endif
@@ -258,7 +291,7 @@ static int receive(const struct sr_input *in, GString *buf)
 
        if (!inc->found_data) {
                /* Skip past size of 'fmt ' chunk. */
-               i = 20 + GUINT32_FROM_LE(*(uint32_t *)(in->buf->str + 16));
+               i = 20 + RL32(in->buf->str + 16);
                offset = find_data_chunk(in->buf, i);
                if (offset < 0) {
                        if (in->buf->len > MAX_DATA_CHUNK_OFFSET) {