src/output/wav.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2014 Bert Vermeulen <bert@biot.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <string.h>
  21 #include "libsigrok.h"
  22 #include "libsigrok-internal.h"
  23
  24 #define LOG_PREFIX "output/wav"
  25
  26 /* Minimum/maximum number of samples per channel to put in a data chunk */
  27 #define MIN_DATA_CHUNK_SAMPLES 10
  28
  29 struct out_context {
  30         double scale;
  31         gboolean header_done;
  32         uint64_t samplerate;
  33         int num_channels;
  34         GSList *channels;
  35         int chanbuf_size;
  36         int *chanbuf_used;
  37         uint8_t **chanbuf;
  38 };
  39
  40 static int realloc_chanbufs(const struct sr_output *o, int size)
  41 {
  42         struct out_context *outc;
  43         int i;
  44
  45         outc = o->priv;
  46         for (i = 0; i < outc->num_channels; i++) {
  47                 if (!(outc->chanbuf[i] = g_try_realloc(outc->chanbuf[i], sizeof(float) * size))) {
  48                         sr_err("Unable to allocate enough output buffer memory.");
  49                         return SR_ERR;
  50                 }
  51                 outc->chanbuf_used[i] = 0;
  52         }
  53         outc->chanbuf_size = size;
  54
  55         return SR_OK;
  56 }
  57
  58 static int flush_chanbufs(const struct sr_output *o, GString *out)
  59 {
  60         struct out_context *outc;
  61         int num_samples, i, j;
  62         char *buf, *bufp;
  63
  64         outc = o->priv;
  65
  66         /* Any one of them will do. */
  67         num_samples = outc->chanbuf_used[0];
  68         if (!(buf = g_try_malloc(4 * num_samples * outc->num_channels))) {
  69                 sr_err("Unable to allocate enough interleaved output buffer memory.");
  70                 return SR_ERR;
  71         }
  72
  73         bufp = buf;
  74         for (i = 0; i < num_samples; i++) {
  75                 for (j = 0; j < outc->num_channels; j++) {
  76                         memcpy(bufp, outc->chanbuf[j] + i * 4, 4);
  77                         bufp += 4;
  78                 }
  79         }
  80         g_string_append_len(out, buf, 4 * num_samples * outc->num_channels);
  81         g_free(buf);
  82
  83         for (i = 0; i < outc->num_channels; i++)
  84                 outc->chanbuf_used[i] = 0;
  85
  86         return SR_OK;
  87 }
  88
  89 static int init(struct sr_output *o, GHashTable *options)
  90 {
  91         struct out_context *outc;
  92         struct sr_channel *ch;
  93         GSList *l;
  94
  95         outc = g_malloc0(sizeof(struct out_context));
  96         o->priv = outc;
  97         outc->scale = g_variant_get_double(g_hash_table_lookup(options, "scale"));
  98
  99         for (l = o->sdi->channels; l; l = l->next) {
 100                 ch = l->data;
 101                 if (ch->type != SR_CHANNEL_ANALOG)
 102                         continue;
 103                 if (!ch->enabled)
 104                         continue;
 105                 outc->channels = g_slist_append(outc->channels, ch);
 106                 outc->num_channels++;
 107         }
 108
 109         outc->chanbuf = g_malloc0(sizeof(float *) * outc->num_channels);
 110         outc->chanbuf_used = g_malloc0(sizeof(int) * outc->num_channels);
 111
 112         /* Start off the interleaved buffer with 100 samples/channel. */
 113         realloc_chanbufs(o, 100);
 114
 115         return SR_OK;
 116 }
 117
 118 static void add_data_chunk(const struct sr_output *o, GString *gs)
 119 {
 120         struct out_context *outc;
 121         char tmp[4];
 122
 123         outc = o->priv;
 124         g_string_append(gs, "fmt ");
 125         /* Remaining chunk size */
 126         WL32(tmp, 0x12);
 127         g_string_append_len(gs, tmp, 4);
 128         /* Format code 3 = IEEE float */
 129         WL16(tmp, 0x0003);
 130         g_string_append_len(gs, tmp, 2);
 131         /* Number of channels */
 132         WL16(tmp, outc->num_channels);
 133         g_string_append_len(gs, tmp, 2);
 134         /* Samplerate */
 135         WL32(tmp, outc->samplerate);
 136         g_string_append_len(gs, tmp, 4);
 137         /* Byterate, using 32-bit floats. */
 138         WL32(tmp, outc->samplerate * outc->num_channels * 4);
 139         g_string_append_len(gs, tmp, 4);
 140         /* Blockalign */
 141         WL16(tmp, outc->num_channels * 4);
 142         g_string_append_len(gs, tmp, 2);
 143         /* Bits per sample */
 144         WL16(tmp, 32);
 145         g_string_append_len(gs, tmp, 2);
 146         WL16(tmp, 0);
 147         g_string_append_len(gs, tmp, 2);
 148
 149         g_string_append(gs, "data");
 150         /* Data chunk size, max it out. */
 151         WL32(tmp, 0xffffffff);
 152         g_string_append_len(gs, tmp, 4);
 153 }
 154
 155 static GString *gen_header(const struct sr_output *o)
 156 {
 157         struct out_context *outc;
 158         GVariant *gvar;
 159         GString *header;
 160         char tmp[4];
 161
 162         outc = o->priv;
 163         if (outc->samplerate == 0) {
 164                 if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
 165                                 &gvar) == SR_OK) {
 166                         outc->samplerate = g_variant_get_uint64(gvar);
 167                         g_variant_unref(gvar);
 168                 }
 169         }
 170
 171         header = g_string_sized_new(512);
 172         g_string_append(header, "RIFF");
 173         /* Total size. Max out the field. */
 174         WL32(tmp, 0xffffffff);
 175         g_string_append_len(header, tmp, 4);
 176         g_string_append(header, "WAVE");
 177         add_data_chunk(o, header);
 178
 179         return header;
 180 }
 181
 182 /*
 183  * Stores the float in little-endian BINARY32 IEEE-754 2008 format.
 184  */
 185 static void float_to_le(uint8_t *buf, float value)
 186 {
 187         char *old;
 188
 189         old = (char *)&value;
 190 #ifdef WORDS_BIGENDIAN
 191         buf[0] = old[3];
 192         buf[1] = old[2];
 193         buf[2] = old[1];
 194         buf[3] = old[0];
 195 #else
 196         buf[0] = old[0];
 197         buf[1] = old[1];
 198         buf[2] = old[2];
 199         buf[3] = old[3];
 200 #endif
 201 }
 202
 203 /*
 204  * Returns the number of samples used in the current channel buffers,
 205  * or -1 if they're not all the same.
 206  */
 207 static int check_chanbuf_size(const struct sr_output *o)
 208 {
 209         struct out_context *outc;
 210         int size, i;
 211
 212         outc = o->priv;
 213         size = 0;
 214         for (i = 0; i < outc->num_channels; i++) {
 215                 if (size == 0) {
 216                         if (outc->chanbuf_used[i] == 0) {
 217                                 /* Nothing in all the buffers yet. */
 218                                 size = -1;
 219                                 break;
 220                         } else
 221                                 /* New high water mark. */
 222                                 size = outc->chanbuf_used[i];
 223                 } else if (outc->chanbuf_used[i] != size) {
 224                         /* All channel buffers are not equally full yet. */
 225                         size = -1;
 226                         break;
 227                 }
 228         }
 229
 230         return size;
 231 }
 232 static int receive(const struct sr_output *o, const struct sr_datafeed_packet *packet,
 233                 GString **out)
 234 {
 235         struct out_context *outc;
 236         const struct sr_datafeed_meta *meta;
 237         const struct sr_datafeed_analog *analog;
 238         const struct sr_config *src;
 239         struct sr_channel *ch;
 240         GSList *l;
 241         float f;
 242         int num_channels, size, *chan_idx, idx, i, j;
 243         uint8_t *buf;
 244
 245         *out = NULL;
 246         if (!o || !o->sdi || !(outc = o->priv))
 247                 return SR_ERR_ARG;
 248
 249         switch (packet->type) {
 250         case SR_DF_META:
 251                 meta = packet->payload;
 252                 for (l = meta->config; l; l = l->next) {
 253                         src = l->data;
 254                         if (src->key != SR_CONF_SAMPLERATE)
 255                                 continue;
 256                         outc->samplerate = g_variant_get_uint64(src->data);
 257                 }
 258                 break;
 259         case SR_DF_ANALOG:
 260                 if (!outc->header_done) {
 261                         *out = gen_header(o);
 262                         outc->header_done = TRUE;
 263                 } else
 264                         *out = g_string_sized_new(512);
 265
 266                 analog = packet->payload;
 267                 if (analog->num_samples == 0)
 268                         return SR_OK;
 269
 270                 num_channels = g_slist_length(analog->channels);
 271                 if (num_channels > outc->num_channels) {
 272                         sr_err("Packet has %d channels, but only %d were enabled.",
 273                                         num_channels, outc->num_channels);
 274                         return SR_ERR;
 275                 }
 276
 277                 if (analog->num_samples > outc->chanbuf_size) {
 278                         if (realloc_chanbufs(o, analog->num_samples) != SR_OK)
 279                                 return SR_ERR_MALLOC;
 280                 }
 281
 282                 /* Index the channels in this packet, so we can interleave quicker. */
 283                 chan_idx = g_malloc(sizeof(int) * outc->num_channels);
 284                 for (i = 0; i < num_channels; i++) {
 285                         ch = g_slist_nth_data(analog->channels, i);
 286                         chan_idx[i] = g_slist_index(outc->channels, ch);
 287                 }
 288
 289                 for (i = 0; i < analog->num_samples; i++) {
 290                         for (j = 0; j < num_channels; j++) {
 291                                 idx = chan_idx[j];
 292                                 buf = outc->chanbuf[idx] + outc->chanbuf_used[idx]++ * 4;
 293                                 f = analog->data[i * num_channels + j];
 294                                 if (outc->scale != 0.0)
 295                                         f /= outc->scale;
 296                                 float_to_le(buf, f);
 297                         }
 298                 }
 299                 g_free(chan_idx);
 300
 301                 size = check_chanbuf_size(o);
 302                 if (size > MIN_DATA_CHUNK_SAMPLES)
 303                         if (flush_chanbufs(o, *out) != SR_OK)
 304                                 return SR_ERR;
 305                 break;
 306         case SR_DF_END:
 307                 size = check_chanbuf_size(o);
 308                 if (size > 0) {
 309                         *out = g_string_sized_new(4 * size * outc->num_channels);
 310                         if (flush_chanbufs(o, *out) != SR_OK)
 311                                 return SR_ERR;
 312                 }
 313                 break;
 314         }
 315
 316         return SR_OK;
 317 }
 318
 319 static int cleanup(struct sr_output *o)
 320 {
 321         struct out_context *outc;
 322         int i;
 323
 324         outc = o->priv;
 325         g_slist_free(outc->channels);
 326         for (i = 0; i < outc->num_channels; i++)
 327                 g_free(outc->chanbuf[i]);
 328         g_free(outc->chanbuf_used);
 329         g_free(outc->chanbuf);
 330         g_free(outc);
 331         o->priv = NULL;
 332
 333         return SR_OK;
 334 }
 335
 336 static struct sr_option options[] = {
 337         { "scale", "Scale", "Scale values by factor", NULL, NULL },
 338         { 0 }
 339 };
 340
 341 static struct sr_option *get_options(void)
 342 {
 343         if (!options[0].def) {
 344                 options[0].def = g_variant_new_double(0.0);
 345                 g_variant_ref_sink(options[0].def);
 346         }
 347
 348         return options;
 349 }
 350
 351 SR_PRIV struct sr_output_module output_wav = {
 352         .id = "wav",
 353         .name = "WAV",
 354         .desc = "WAVE file format",
 355         .options = get_options,
 356         .init = init,
 357         .receive = receive,
 358         .cleanup = cleanup,
 359 };
 360