From: Paul Brossier <piem@piem.org>
Date: Sun, 23 Feb 2014 15:58:25 +0000 (-0300)
Subject: src/io/sink_wavwrite.h: add do_multi, preset_samplerate, preset_channels, get_sampler... 
X-Git-Tag: 0.4.1~35
X-Git-Url: https://git.aubio.org/?p=aubio.git;a=commitdiff_plain;h=870ad7018d0370e0a040a5cafdc42c2b8f320d68

src/io/sink_wavwrite.h: add do_multi, preset_samplerate, preset_channels, get_samplerate, and get_channels
---

diff --git a/src/io/sink_wavwrite.c b/src/io/sink_wavwrite.c
index 908f660f..4062a943 100644
--- a/src/io/sink_wavwrite.c
+++ b/src/io/sink_wavwrite.c
@@ -24,8 +24,9 @@
 #ifdef HAVE_WAVWRITE
 
 #include "aubio_priv.h"
-#include "sink_wavwrite.h"
 #include "fvec.h"
+#include "fmat.h"
+#include "io/sink_wavwrite.h"
 
 #include <errno.h>
 
@@ -46,6 +47,8 @@
 #define HTOLES(x) SWAPS(htons(x))
 #endif
 
+uint_t aubio_sink_wavwrite_open(aubio_sink_wavwrite_t *s);
+
 struct _aubio_sink_wavwrite_t {
   char_t *path;
   uint_t samplerate;
@@ -72,8 +75,6 @@ unsigned char *write_little_endian (unsigned int s, unsigned char *str, unsigned
 
 aubio_sink_wavwrite_t * new_aubio_sink_wavwrite(char_t * path, uint_t samplerate) {
   aubio_sink_wavwrite_t * s = AUBIO_NEW(aubio_sink_wavwrite_t);
-  unsigned char buf[5];
-  uint_t byterate, blockalign;
 
   if (path == NULL) {
     AUBIO_ERR("sink_wavwrite: Aborted opening null path\n");
@@ -85,14 +86,72 @@ aubio_sink_wavwrite_t * new_aubio_sink_wavwrite(char_t * path, uint_t samplerate
   }
 
   s->path = path;
-  s->samplerate = samplerate;
   s->max_size = MAX_SIZE;
-  s->channels = 1;
   s->bitspersample = 16;
   s->total_frames_written = 0;
 
-  /* set output format */
-  s->fid = fopen((const char *)path, "wb");
+  s->samplerate = 0;
+  s->channels = 0;
+
+  // negative samplerate given, abort
+  if ((sint_t)samplerate < 0) goto beach;
+  // zero samplerate given. do not open yet
+  if ((sint_t)samplerate == 0) return s;
+
+  s->samplerate = samplerate;
+  s->channels = 1;
+
+  if (aubio_sink_wavwrite_open(s) != AUBIO_OK) {
+    // open failed, abort
+    goto beach;
+  }
+
+  return s;
+beach:
+  //AUBIO_ERR("sink_wavwrite: failed creating %s with samplerate %dHz\n",
+  //    s->path, s->samplerate);
+  del_aubio_sink_wavwrite(s);
+  return NULL;
+}
+
+uint_t aubio_sink_wavwrite_preset_samplerate(aubio_sink_wavwrite_t *s, uint_t samplerate)
+{
+  if ((sint_t)(samplerate) <= 0) return AUBIO_FAIL;
+  s->samplerate = samplerate;
+  // automatically open when both samplerate and channels have been set
+  if (s->samplerate != 0 && s->channels != 0) {
+    return aubio_sink_wavwrite_open(s);
+  }
+  return AUBIO_OK;
+}
+
+uint_t aubio_sink_wavwrite_preset_channels(aubio_sink_wavwrite_t *s, uint_t channels)
+{
+  if ((sint_t)(channels) <= 0) return AUBIO_FAIL;
+  s->channels = channels;
+  // automatically open when both samplerate and channels have been set
+  if (s->samplerate != 0 && s->channels != 0) {
+    return aubio_sink_wavwrite_open(s);
+  }
+  return AUBIO_OK;
+}
+
+uint_t aubio_sink_wavwrite_get_samplerate(aubio_sink_wavwrite_t *s)
+{
+  return s->samplerate;
+}
+
+uint_t aubio_sink_wavwrite_get_channels(aubio_sink_wavwrite_t *s)
+{
+  return s->channels;
+}
+
+uint_t aubio_sink_wavwrite_open(aubio_sink_wavwrite_t *s) {
+  unsigned char buf[5];
+  uint_t byterate, blockalign;
+
+  /* open output file */
+  s->fid = fopen((const char *)s->path, "wb");
   if (!s->fid) {
     AUBIO_ERR("sink_wavwrite: could not open %s (%s)\n", s->path, strerror(errno));
     goto beach;
@@ -142,20 +201,16 @@ aubio_sink_wavwrite_t * new_aubio_sink_wavwrite(char_t * path, uint_t samplerate
   s->scratch_size = s->max_size * s->channels;
   /* allocate data for de/interleaving reallocated when needed. */
   if (s->scratch_size >= MAX_SIZE * MAX_CHANNELS) {
-    AUBIO_ERR("sink_wavwrite: %d x %d exceeds maximum buffer size %d\n",
-        s->max_size, s->channels, MAX_CHANNELS * MAX_CHANNELS);
-    AUBIO_FREE(s);
-    return NULL;
+    AUBIO_ERR("sink_wavwrite: %d x %d exceeds SIZE maximum buffer size %d\n",
+        s->max_size, s->channels, MAX_SIZE * MAX_CHANNELS);
+    goto beach;
   }
   s->scratch_data = AUBIO_ARRAY(unsigned short,s->scratch_size);
 
-  return s;
+  return AUBIO_OK;
 
 beach:
-  //AUBIO_ERR("sink_wavwrite: failed creating %s with samplerate %dHz\n",
-  //    s->path, s->samplerate);
-  del_aubio_sink_wavwrite(s);
-  return NULL;
+  return AUBIO_FAIL;
 }
 
 
@@ -181,6 +236,30 @@ void aubio_sink_wavwrite_do(aubio_sink_wavwrite_t *s, fvec_t * write_data, uint_
   return;
 }
 
+void aubio_sink_wavwrite_do_multi(aubio_sink_wavwrite_t *s, fmat_t * write_data, uint_t write){
+  uint_t c = 0, i = 0, written_frames = 0;
+
+  if (write > s->max_size) {
+    AUBIO_WRN("sink_wavwrite: trying to write %d frames to %s, "
+        "but only %d can be written at a time\n", write, s->path, s->max_size);
+    write = s->max_size;
+  }
+
+  for (c = 0; c < s->channels; c++) {
+    for (i = 0; i < write; i++) {
+      s->scratch_data[i * s->channels + c] = HTOLES(FLOAT_TO_SHORT(write_data->data[c][i]));
+    }
+  }
+  written_frames = fwrite(s->scratch_data, 2, write * s->channels, s->fid);
+
+  if (written_frames != write * s->channels) {
+    AUBIO_WRN("sink_wavwrite: trying to write %d frames to %s, "
+        "but only %d could be written\n", write, s->path, written_frames / s->channels);
+  }
+  s->total_frames_written += written_frames;
+  return;
+}
+
 uint_t aubio_sink_wavwrite_close(aubio_sink_wavwrite_t * s) {
   uint_t data_size = s->total_frames_written * s->bitspersample * s->channels / 8;
   unsigned char buf[5];
diff --git a/src/io/sink_wavwrite.h b/src/io/sink_wavwrite.h
index 01008cd3..86b5819b 100644
--- a/src/io/sink_wavwrite.h
+++ b/src/io/sink_wavwrite.h
@@ -23,7 +23,7 @@
 
 /** \file
 
-  Write to file using [libsndfile](http://www.mega-nerd.com/libsndfile/)
+  Write to file using native file writer.
 
   Avoid including this file directly! Prefer using ::aubio_sink_t instead to
   make your code portable.
@@ -38,6 +38,7 @@
 extern "C" {
 #endif
 
+/** sink_wavwrite object */
 typedef struct _aubio_sink_wavwrite_t aubio_sink_wavwrite_t;
 
 /**
@@ -51,11 +52,69 @@ typedef struct _aubio_sink_wavwrite_t aubio_sink_wavwrite_t;
 
   Creates a new sink object.
 
+  If samplerate is set to 0, the creation of the file will be delayed until
+  both ::aubio_sink_preset_samplerate and ::aubio_sink_preset_channels have
+  been called.
+
 */
 aubio_sink_wavwrite_t * new_aubio_sink_wavwrite(char_t * uri, uint_t samplerate);
 
 /**
 
+  preset sink samplerate
+
+  \param s sink, created with ::new_aubio_sink_wavwrite
+  \param samplerate samplerate to preset the sink to, in Hz
+
+  \return 0 on success, 1 on error
+
+  Preset the samplerate of the sink. The file should have been created using a
+  samplerate of 0.
+
+  The file will be opened only when both samplerate and channels have been set.
+
+*/
+uint_t aubio_sink_wavwrite_preset_samplerate(aubio_sink_wavwrite_t *s, uint_t samplerate);
+
+/**
+
+  preset sink channels
+
+  \param s sink, created with ::new_aubio_sink_wavwrite
+  \param channels number of channels to preset the sink to
+
+  \return 0 on success, 1 on error
+
+  Preset the samplerate of the sink. The file should have been created using a
+  samplerate of 0.
+
+  The file will be opened only when both samplerate and channels have been set.
+
+*/
+uint_t aubio_sink_wavwrite_preset_channels(aubio_sink_wavwrite_t *s, uint_t channels);
+
+/**
+
+  get samplerate of sink object
+
+  \param s sink object, created with ::new_aubio_sink_wavwrite
+  \return samplerate, in Hz
+
+*/
+uint_t aubio_sink_wavwrite_get_samplerate(aubio_sink_wavwrite_t *s);
+
+/**
+
+  get channels of sink object
+
+  \param s sink object, created with ::new_aubio_sink_wavwrite
+  \return number of channels
+
+*/
+uint_t aubio_sink_wavwrite_get_channels(aubio_sink_wavwrite_t *s);
+
+/**
+
   write monophonic vector of length hop_size to sink
 
   \param s sink, created with ::new_aubio_sink_wavwrite
@@ -67,6 +126,17 @@ void aubio_sink_wavwrite_do(aubio_sink_wavwrite_t * s, fvec_t * write_data, uint
 
 /**
 
+  write polyphonic vector of length hop_size to sink
+
+  \param s sink, created with ::new_aubio_sink_wavwrite
+  \param write_data ::fmat_t samples to write to sink
+  \param write number of frames to write
+
+*/
+void aubio_sink_wavwrite_do_multi(aubio_sink_wavwrite_t * s, fmat_t * write_data, uint_t write);
+
+/**
+
   close sink
 
   \param s sink_wavwrite object, create with ::new_aubio_sink_wavwrite
diff --git a/tests/src/io/test-sink_wavwrite-multi.c b/tests/src/io/test-sink_wavwrite-multi.c
new file mode 100644
index 00000000..d6770564
--- /dev/null
+++ b/tests/src/io/test-sink_wavwrite-multi.c
@@ -0,0 +1,78 @@
+#define AUBIO_UNSTABLE 1
+#include <aubio.h>
+#include "utils_tests.h"
+
+// this file uses the unstable aubio api, please use aubio_sink instead
+// see src/io/sink.h and tests/src/sink/test-sink.c
+
+int main (int argc, char **argv)
+{
+  sint_t err = 0;
+
+  if (argc < 3) {
+    err = 2;
+    PRINT_ERR("not enough arguments\n");
+    PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [channels] [hop_size]\n", argv[0]);
+    return err;
+  }
+
+#ifdef __APPLE__
+  uint_t samplerate = 0;
+  uint_t channels = 0;
+  uint_t hop_size = 512;
+  uint_t n_frames = 0, read = 0;
+
+  char_t *source_path = argv[1];
+  char_t *sink_path = argv[2];
+
+  if ( argc >= 4 ) samplerate = atoi(argv[3]);
+  if ( argc >= 5 ) channels = atoi(argv[4]);
+  if ( argc >= 6 ) hop_size = atoi(argv[5]);
+  if ( argc >= 7 ) {
+    err = 2;
+    PRINT_ERR("too many arguments\n");
+    return err;
+  }
+
+  aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);
+  if (!i) { err = 1; goto beach_source; }
+
+  if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);
+  if (channels == 0 ) channels = aubio_source_get_channels(i);
+
+  fmat_t *mat = new_fmat(channels, hop_size);
+  if (!mat) { err = 1; goto beach_fmat; }
+
+  aubio_sink_wavwrite_t *o = new_aubio_sink_wavwrite(sink_path, 0);
+  if (!o) { err = 1; goto beach_sink; }
+  err = aubio_sink_wavwrite_preset_samplerate(o, samplerate);
+  if (err) { goto beach; }
+  err = aubio_sink_wavwrite_preset_channels(o, channels);
+  if (err) { goto beach; }
+
+  do {
+    aubio_source_do_multi(i, mat, &read);
+    aubio_sink_wavwrite_do_multi(o, mat, read);
+    n_frames += read;
+  } while ( read == hop_size );
+
+  PRINT_MSG("read %d frames at %dHz in %d channels (%d blocks) from %s written to %s\n",
+      n_frames, samplerate, channels, n_frames / hop_size,
+      source_path, sink_path);
+  PRINT_MSG("wrote %s with %dHz in %d channels\n", sink_path,
+      aubio_sink_wavwrite_get_samplerate(o),
+      aubio_sink_wavwrite_get_channels(o) );
+
+beach:
+  del_aubio_sink_wavwrite(o);
+beach_sink:
+  del_fmat(mat);
+beach_fmat:
+  del_aubio_source(i);
+beach_source:
+#else
+  err = 3;
+  PRINT_ERR("aubio was not compiled with aubio_sink_wavwrite\n");
+#endif /* __APPLE__ */
+  return err;
+}