Changeset 7a02ce9 for src

Timestamp:

Apr 1, 2019, 1:30:22 AM (6 years ago)

Author:

Paul Brossier <piem@piem.org>

Branches:

feature/cnn, feature/crepe, feature/timestretch, fix/ffmpeg5, master

Children:

65f7886

Parents:

1301f66 (diff), 439ba7b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'feature/pitchshift' into feature/timestretch

Location:

src

Files:

• aubio_priv.h (modified) (4 diffs)
• io/ioutils.c (modified) (2 diffs)
• io/ioutils.h (modified) (2 diffs)
• io/sink.c (modified) (1 diff)
• io/sink_wavwrite.c (modified) (6 diffs)
• io/source.c (modified) (1 diff)
• io/source_apple_audio.c (modified) (4 diffs)
• io/source_avcodec.c (modified) (12 diffs)
• io/source_sndfile.c (modified) (7 diffs)
• io/source_wavread.c (modified) (14 diffs)

src/aubio_priv.h

@@ -63 +63 @@
 #endif
 
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
 #ifdef HAVE_LIMITS_H
 #include <limits.h> // for CHAR_BIT, in C99 standard
@@ -71 +75 @@
 #endif
 
-#if defined(HAVE_ACCELERATE)
-#define HAVE_ATLAS 1
-#define HAVE_BLAS 1
-#include <Accelerate/Accelerate.h>
-#elif defined(HAVE_ATLAS_CBLAS_H)
-#elif defined(HAVE_BLAS)
+#if defined(HAVE_BLAS) // --enable-blas=true
+// check which cblas header we found
 #if defined(HAVE_ATLAS_CBLAS_H)
 #define HAVE_ATLAS 1
@@ -84 +84 @@
 #elif defined(HAVE_CBLAS_H)
 #include <cblas.h>
-#endif
-#endif
-
-#ifdef HAVE_ACCELERATE
+#elif !defined(HAVE_ACCELERATE)
+#error "HAVE_BLAS was defined, but no blas header was found"
+#endif /* end of cblas includes */
+#endif
+
+#if defined(HAVE_ACCELERATE)
+// include accelerate framework after blas
+#define HAVE_ATLAS 1
+#define HAVE_BLAS 1
 #include <Accelerate/Accelerate.h>
+
 #ifndef HAVE_AUBIO_DOUBLE
 #define aubio_vDSP_mmov       vDSP_mmov
@@ -325 +331 @@
 #endif
 
+#if !defined(_MSC_VER)
+#define AUBIO_STRERROR(errno,buf,len) strerror_r(errno, buf, len)
+#else
+#define AUBIO_STRERROR(errno,buf,len) strerror_s(buf, len, errno)
+#endif
+
+#ifdef HAVE_C99_VARARGS_MACROS
+#define AUBIO_STRERR(...)            \
+    char errorstr[256]; \
+    AUBIO_STRERROR(errno, errorstr, sizeof(errorstr)); \
+    AUBIO_ERR(__VA_ARGS__)
+#else
+#define AUBIO_STRERR(format, args...)   \
+    char errorstr[256]; \
+    AUBIO_STRERROR(errno, errorstr, sizeof(errorstr)); \
+    AUBIO_ERR(format, ##args)
+#endif
+
 /* handy shortcuts */
 #define DB2LIN(g) (POW(10.0,(g)*0.05f))

src/io/ioutils.c

@@ -20 +20 @@
 
 #include "aubio_priv.h"
+#include "fmat.h"
 
 uint_t
@@ -51 +52 @@
   }
   return AUBIO_OK;
+}
+
+uint_t
+aubio_source_validate_input_length(const char_t *kind, const char_t *path,
+    uint_t hop_size, uint_t read_data_length)
+{
+  uint_t length = hop_size;
+  if (hop_size < read_data_length) {
+    AUBIO_WRN("%s: partial read from %s, trying to read %d frames, but"
+        " hop_size is %d\n", kind, path, read_data_length, hop_size);
+  } else if (hop_size > read_data_length) {
+    AUBIO_WRN("%s: partial read from %s, trying to read %d frames into"
+        " a buffer of length %d\n", kind, path, hop_size, read_data_length);
+    length = read_data_length;
+  }
+  return length;
+}
+
+uint_t
+aubio_source_validate_input_channels(const char_t *kind, const char_t *path,
+    uint_t source_channels, uint_t read_data_height)
+{
+  uint_t channels = source_channels;
+  if (read_data_height < source_channels) {
+    AUBIO_WRN("%s: partial read from %s, trying to read %d channels,"
+        " but found output of height %d\n", kind, path, source_channels,
+        read_data_height);
+    channels = read_data_height;
+  } else if (read_data_height > source_channels) {
+    // do not show a warning when trying to read into more channels than
+    // the input source.
+#if 0
+    AUBIO_WRN("%s: partial read from %s, trying to read %d channels,"
+        " but found output of height %d\n", kind, path, source_channels,
+        read_data_height);
+#endif
+    channels = source_channels;
+  }
+  return channels;
+}
+
+void
+aubio_source_pad_output (fvec_t *read_data, uint_t source_read)
+{
+  if (source_read < read_data->length) {
+    AUBIO_MEMSET(read_data->data + source_read, 0,
+        (read_data->length - source_read) * sizeof(smpl_t));
+  }
+}
+
+void
+aubio_source_pad_multi_output (fmat_t *read_data,
+    uint_t source_channels, uint_t source_read) {
+  uint_t i;
+  if (source_read < read_data->length) {
+    for (i = 0; i < read_data->height; i++) {
+      AUBIO_MEMSET(read_data->data[i] + source_read, 0,
+          (read_data->length - source_read) * sizeof(smpl_t));
+    }
+  }
+
+  // destination matrix has more channels than the file
+  // copy channels from the source to extra output channels
+  if (read_data->height > source_channels) {
+    for (i = source_channels; i < read_data->height; i++) {
+      AUBIO_MEMCPY(read_data->data[i], read_data->data[i % source_channels],
+          sizeof(smpl_t) * read_data->length);
+    }
+  }
 }
 

src/io/ioutils.h

@@ -54 +54 @@
     uint_t channels);
 
-/** validate length of input
+/** validate length of source output
+
+  \param kind       the object kind to report on
+  \param path       the path to report on
+  \param hop_size   number of frames to be read
+  \param read_data_length actual length of input
+
+  \return hop_size or the maximum number of frames that can be written
+*/
+uint_t
+aubio_source_validate_input_length(const char_t *kind, const char_t *path,
+    uint_t hop_size, uint_t read_data_length);
+
+/** validate height of source output
+
+  \param kind       the object kind to report on
+  \param path       the path to report on
+  \param source_channels maximum number of channels that can be written
+  \param read_data_height actual height of input
+
+  \return write_data_height or the maximum number of channels
+*/
+uint_t
+aubio_source_validate_input_channels(const char_t *kind, const char_t *path,
+    uint_t source_channels, uint_t read_data_height);
+
+/** pad end of source output vector with zeroes
+
+  \param read_data   output vector to pad
+  \param source_read number of frames read
+
+*/
+void
+aubio_source_pad_output (fvec_t *read_data, uint_t source_read);
+
+/** pad end of source output matrix with zeroes
+
+  \param read_data   output matrix to pad
+  \param source_channels number of channels in the source
+  \param source_read number of frames read
+
+*/
+void
+aubio_source_pad_multi_output (fmat_t *read_data, uint_t source_channels,
+        uint_t source_read);
+
+/** validate length of sink input
 
   \param kind       the object kind to report on
   \param path       the path to report on
   \param max_size   maximum number of frames that can be written
-  \param write_data_length actual length of input vector/matrix
+  \param write_data_length actual length of input
   \param write number of samples asked
 
@@ -68 +114 @@
     uint_t max_size, uint_t write_data_length, uint_t write);
 
-/** validate height of input
+/** validate height of sink input
 
   \param kind       the object kind to report on
   \param path       the path to report on
-  \param max_size   maximum number of channels that can be written
+  \param sink_channels maximum number of channels that can be written
   \param write_data_height actual height of input matrix
 

src/io/sink.c

@@ -136 +136 @@
 
 void del_aubio_sink(aubio_sink_t * s) {
-  AUBIO_ASSERT(s);
-  if (s->s_del && s->sink)
+  //AUBIO_ASSERT(s);
+  if (s && s->s_del && s->sink)
     s->s_del((void *)s->sink);
   AUBIO_FREE(s);

src/io/sink_wavwrite.c

@@ -28 +28 @@
 #include "io/sink_wavwrite.h"
 #include "io/ioutils.h"
-
-#include <errno.h>
 
 #define MAX_SIZE 4096
@@ -163 +161 @@
   unsigned char buf[5];
   uint_t byterate, blockalign;
+  size_t written = 0;
 
   /* 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));
+    AUBIO_STRERR("sink_wavwrite: could not open %s (%s)\n", s->path, errorstr);
     goto beach;
   }
 
   // ChunkID
-  fwrite("RIFF", 4, 1, s->fid);
+  written += fwrite("RIFF", 4, 1, s->fid);
 
   // ChunkSize (0 for now, actual size will be written in _close)
-  fwrite(write_little_endian(0, buf, 4), 4, 1, s->fid);
+  written += fwrite(write_little_endian(0, buf, 4), 4, 1, s->fid);
 
   // Format
-  fwrite("WAVE", 4, 1, s->fid);
+  written += fwrite("WAVE", 4, 1, s->fid);
 
   // Subchunk1ID
-  fwrite("fmt ", 4, 1, s->fid);
+  written += fwrite("fmt ", 4, 1, s->fid);
 
   // Subchunk1Size
-  fwrite(write_little_endian(16, buf, 4), 4, 1, s->fid);
+  written += fwrite(write_little_endian(16, buf, 4), 4, 1, s->fid);
 
   // AudioFormat
-  fwrite(write_little_endian(1, buf, 2), 2, 1, s->fid);
+  written += fwrite(write_little_endian(1, buf, 2), 2, 1, s->fid);
 
   // NumChannels
-  fwrite(write_little_endian(s->channels, buf, 2), 2, 1, s->fid);
+  written += fwrite(write_little_endian(s->channels, buf, 2), 2, 1, s->fid);
 
   // SampleRate
-  fwrite(write_little_endian(s->samplerate, buf, 4), 4, 1, s->fid);
+  written += fwrite(write_little_endian(s->samplerate, buf, 4), 4, 1, s->fid);
 
   // ByteRate
   byterate = s->samplerate * s->channels * s->bitspersample / 8;
-  fwrite(write_little_endian(byterate, buf, 4), 4, 1, s->fid);
+  written += fwrite(write_little_endian(byterate, buf, 4), 4, 1, s->fid);
 
   // BlockAlign
   blockalign = s->channels * s->bitspersample / 8;
-  fwrite(write_little_endian(blockalign, buf, 2), 2, 1, s->fid);
+  written += fwrite(write_little_endian(blockalign, buf, 2), 2, 1, s->fid);
 
   // BitsPerSample
-  fwrite(write_little_endian(s->bitspersample, buf, 2), 2, 1, s->fid);
+  written += fwrite(write_little_endian(s->bitspersample, buf, 2), 2, 1, s->fid);
 
   // Subchunk2ID
-  fwrite("data", 4, 1, s->fid);
+  written += fwrite("data", 4, 1, s->fid);
 
   // Subchunk1Size (0 for now, actual size will be written in _close)
-  fwrite(write_little_endian(0, buf, 4), 4, 1, s->fid);
+  written += fwrite(write_little_endian(0, buf, 4), 4, 1, s->fid);
+
+  // fwrite(*, *, 1, s->fid) was called 13 times, check success
+  if (written != 13 || fflush(s->fid)) {
+    AUBIO_STRERR("sink_wavwrite: writing header to %s failed"
+        " (wrote %d/%d, %s)\n", s->path, written, 13, errorstr);
+    fclose(s->fid);
+    s->fid = NULL;
+    return AUBIO_FAIL;
+  }
 
   s->scratch_size = s->max_size * s->channels;
@@ -227 +235 @@
 }
 
+static
+void aubio_sink_wavwrite_write_frames(aubio_sink_wavwrite_t *s, uint_t write)
+{
+  uint_t written_frames = 0;
+
+  written_frames = fwrite(s->scratch_data, 2 * s->channels, write, s->fid);
+
+  if (written_frames != write) {
+    AUBIO_STRERR("sink_wavwrite: trying to write %d frames to %s, but only %d"
+        " could be written (%s)\n", write, s->path, written_frames, errorstr);
+  }
+  s->total_frames_written += written_frames;
+}
 
 void aubio_sink_wavwrite_do(aubio_sink_wavwrite_t *s, fvec_t * write_data, uint_t write){
-  uint_t c = 0, i = 0, written_frames = 0;
+  uint_t c = 0, i = 0;
   uint_t length = aubio_sink_validate_input_length("sink_wavwrite", s->path,
       s->max_size, write_data->length, write);
@@ -238 +259 @@
     }
   }
-  written_frames = fwrite(s->scratch_data, 2, length * s->channels, s->fid);
-
-  if (written_frames != write) {
-    AUBIO_WRN("sink_wavwrite: trying to write %d frames to %s, "
-        "but only %d could be written\n", write, s->path, written_frames);
-  }
-  s->total_frames_written += written_frames;
-  return;
+
+  aubio_sink_wavwrite_write_frames(s, length);
 }
 
 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;
+  uint_t c = 0, i = 0;
 
   uint_t channels = aubio_sink_validate_input_channels("sink_wavwrite", s->path,
@@ -261 +276 @@
     }
   }
-  written_frames = fwrite(s->scratch_data, 2, length * 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;
+
+  aubio_sink_wavwrite_write_frames(s, length);
 }
 
@@ -274 +283 @@
   uint_t data_size = s->total_frames_written * s->bitspersample * s->channels / 8;
   unsigned char buf[5];
+  size_t written = 0, err = 0;
   if (!s->fid) return AUBIO_FAIL;
   // ChunkSize
-  fseek(s->fid, 4, SEEK_SET);
-  fwrite(write_little_endian(data_size + 36, buf, 4), 4, 1, s->fid);
+  err += fseek(s->fid, 4, SEEK_SET);
+  written += fwrite(write_little_endian(data_size + 36, buf, 4), 4, 1, s->fid);
   // Subchunk2Size
-  fseek(s->fid, 40, SEEK_SET);
-  fwrite(write_little_endian(data_size, buf, 4), 4, 1, s->fid);
+  err += fseek(s->fid, 40, SEEK_SET);
+  written += fwrite(write_little_endian(data_size, buf, 4), 4, 1, s->fid);
+  if (written != 2 || err != 0) {
+    AUBIO_STRERR("sink_wavwrite: updating header of %s failed, expected %d"
+        " write but got only %d (%s)\n", s->path, 2, written, errorstr);
+  }
   // close file
   if (fclose(s->fid)) {
-    AUBIO_ERR("sink_wavwrite: Error closing file %s (%s)\n", s->path, strerror(errno));
+    AUBIO_STRERR("sink_wavwrite: Error closing file %s (%s)\n", s->path, errorstr);
   }
   s->fid = NULL;

src/io/source.c

@@ -139 +139 @@
 
 void del_aubio_source(aubio_source_t * s) {
-  AUBIO_ASSERT(s);
-  if (s->s_del && s->source)
+  //AUBIO_ASSERT(s);
+  if (s && s->s_del && s->source)
     s->s_del((void *)s->source);
   AUBIO_FREE(s);

src/io/source_apple_audio.c

@@ -25 +25 @@
 #include "fvec.h"
 #include "fmat.h"
+#include "ioutils.h"
 #include "io/source_apple_audio.h"
 
@@ -210 +211 @@
   uint_t c, v;
   UInt32 loadedPackets = aubio_source_apple_audio_read_frame(s);
+  uint_t length = aubio_source_validate_input_length("source_apple_audio",
+      s->path, s->block_size, read_to->length);
   smpl_t *data = (smpl_t*)s->bufferList.mBuffers[0].mData;
 
-  for (v = 0; v < loadedPackets; v++) {
+  length = MIN(loadedPackets, length);
+
+  for (v = 0; v < length; v++) {
     read_to->data[v] = 0.;
     for (c = 0; c < s->channels; c++) {
@@ -220 +225 @@
   }
   // short read, fill with zeros
-  if (loadedPackets < s->block_size) {
-    for (v = loadedPackets; v < s->block_size; v++) {
-      read_to->data[v] = 0.;
-    }
-  }
-
-  *read = (uint_t)loadedPackets;
-  return;
+  aubio_source_pad_output(read_to, length);
+
+  *read = (uint_t)length;
 }
 
 void aubio_source_apple_audio_do_multi(aubio_source_apple_audio_t *s, fmat_t * read_to, uint_t * read) {
   uint_t c, v;
+  uint_t length = aubio_source_validate_input_length("source_apple_audio",
+      s->path, s->block_size, read_to->length);
+  uint_t channels = aubio_source_validate_input_channels("source_apple_audio",
+      s->path, s->channels, read_to->height);
   UInt32 loadedPackets = aubio_source_apple_audio_read_frame(s);
   smpl_t *data = (smpl_t*)s->bufferList.mBuffers[0].mData;
 
-  for (v = 0; v < loadedPackets; v++) {
-    for (c = 0; c < read_to->height; c++) {
+  length = MIN(loadedPackets, length);
+
+  for (v = 0; v < length; v++) {
+    for (c = 0; c < channels; c++) {
       read_to->data[c][v] = data[ v * s->channels + c];
     }
   }
-  // if read_data has more channels than the file
-  if (read_to->height > s->channels) {
-    // copy last channel to all additional channels
-    for (v = 0; v < loadedPackets; v++) {
-      for (c = s->channels; c < read_to->height; c++) {
-        read_to->data[c][v] = data[ v * s->channels + (s->channels - 1)];
-      }
-    }
-  }
-  // short read, fill with zeros
-  if (loadedPackets < s->block_size) {
-    for (v = loadedPackets; v < s->block_size; v++) {
-      for (c = 0; c < read_to->height; c++) {
-        read_to->data[c][v] = 0.;
-      }
-    }
-  }
-
-  *read = (uint_t)loadedPackets;
-  return;
+
+  aubio_source_pad_multi_output(read_to, s->channels, (uint_t)length);
+
+  *read = (uint_t)length;
 }
 
@@ -355 +345 @@
         "error in ExtAudioFileGetProperty (%s)\n", s->path,
         getPrintableOSStatusError(errorstr, err));
-    return err;
+    return 0;
   }
   return (uint_t)fileLengthFrames;

src/io/source_avcodec.c

@@ -31 +31 @@
 #endif
 #include <libavutil/opt.h>
-#include <stdlib.h>
 
 // determine whether we use libavformat from ffmpeg or from libav
@@ -61 +60 @@
 #include "fvec.h"
 #include "fmat.h"
+#include "ioutils.h"
 #include "source_avcodec.h"
 
@@ -120 +120 @@
     uint_t samplerate, uint_t hop_size) {
   aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t);
-  AVFormatContext *avFormatCtx = s->avFormatCtx;
-  AVCodecContext *avCodecCtx = s->avCodecCtx;
-  AVFrame *avFrame = s->avFrame;
+  AVFormatContext *avFormatCtx = NULL;
+  AVCodecContext *avCodecCtx = NULL;
+  AVFrame *avFrame = NULL;
   sint_t selected_stream = -1;
 #if FF_API_LAVF_AVCTX
@@ -464 +464 @@
       (const uint8_t **)avFrame->data, in_samples);
 #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
-  if (out_samples <= 0) {
-    AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n",
-        s->path);
+  if (out_samples < 0) {
+    AUBIO_WRN("source_avcodec: error while resampling %s (%d)\n",
+        s->path, out_samples);
     goto beach;
   }
@@ -473 +473 @@
 
 beach:
-  s->avFormatCtx = avFormatCtx;
-  s->avCodecCtx = avCodecCtx;
-  s->avFrame = avFrame;
-#if defined(HAVE_AVRESAMPLE) || defined(HAVE_SWRESAMPLE)
-  s->avr = avr;
-#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
-  s->output = output;
-
   av_packet_unref(&avPacket);
 }
@@ -489 +481 @@
   uint_t end = 0;
   uint_t total_wrote = 0;
-  while (total_wrote < s->hop_size) {
-    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
+  uint_t length = aubio_source_validate_input_length("source_avcodec", s->path,
+      s->hop_size, read_data->length);
+  if (!s->avr || !s->avFormatCtx || !s->avCodecCtx) {
+    AUBIO_ERR("source_avcodec: could not read from %s (file was closed)\n",
+        s->path);
+    *read= 0;
+    return;
+  }
+  while (total_wrote < length) {
+    end = MIN(s->read_samples - s->read_index, length - total_wrote);
     for (i = 0; i < end; i++) {
       read_data->data[i + total_wrote] = 0.;
@@ -500 +500 @@
     }
     total_wrote += end;
-    if (total_wrote < s->hop_size) {
+    if (total_wrote < length) {
       uint_t avcodec_read = 0;
       aubio_source_avcodec_readframe(s, &avcodec_read);
@@ -512 +512 @@
     }
   }
-  if (total_wrote < s->hop_size) {
-    for (i = total_wrote; i < s->hop_size; i++) {
-      read_data->data[i] = 0.;
-    }
-  }
+
+  aubio_source_pad_output(read_data, total_wrote);
+
   *read = total_wrote;
 }
@@ -525 +523 @@
   uint_t end = 0;
   uint_t total_wrote = 0;
-  while (total_wrote < s->hop_size) {
-    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
-    for (j = 0; j < read_data->height; j++) {
+  uint_t length = aubio_source_validate_input_length("source_avcodec", s->path,
+      s->hop_size, read_data->length);
+  uint_t channels = aubio_source_validate_input_channels("source_avcodec",
+      s->path, s->input_channels, read_data->height);
+  if (!s->avr || !s->avFormatCtx || !s->avCodecCtx) {
+    AUBIO_ERR("source_avcodec: could not read from %s (file was closed)\n",
+        s->path);
+    *read= 0;
+    return;
+  }
+  while (total_wrote < length) {
+    end = MIN(s->read_samples - s->read_index, length - total_wrote);
+    for (j = 0; j < channels; j++) {
       for (i = 0; i < end; i++) {
         read_data->data[j][i + total_wrote] =
@@ -534 +542 @@
     }
     total_wrote += end;
-    if (total_wrote < s->hop_size) {
+    if (total_wrote < length) {
       uint_t avcodec_read = 0;
       aubio_source_avcodec_readframe(s, &avcodec_read);
@@ -546 +554 @@
     }
   }
-  if (total_wrote < s->hop_size) {
-    for (j = 0; j < read_data->height; j++) {
-      for (i = total_wrote; i < s->hop_size; i++) {
-        read_data->data[j][i] = 0.;
-      }
-    }
-  }
+
+  aubio_source_pad_multi_output(read_data, s->input_channels, total_wrote);
+
   *read = total_wrote;
 }
@@ -616 +620 @@
 #ifdef HAVE_AVRESAMPLE
     avresample_close( s->avr );
+    av_free ( s->avr );
 #elif defined(HAVE_SWRESAMPLE)
     swr_close ( s->avr );
-#endif
-    av_free ( s->avr );
+    swr_free ( &s->avr );
+#endif
   }
   s->avr = NULL;

src/io/source_sndfile.c

@@ -27 +27 @@
 #include "fvec.h"
 #include "fmat.h"
+#include "ioutils.h"
 #include "source_sndfile.h"
 
@@ -170 +171 @@
   uint_t i,j, input_channels = s->input_channels;
   /* read from file into scratch_data */
-  sf_count_t read_samples = aubio_sf_read_smpl (s->handle, s->scratch_data, s->scratch_size);
+  uint_t length = aubio_source_validate_input_length("source_sndfile", s->path,
+      s->hop_size, read_data->length);
+  sf_count_t read_samples = aubio_sf_read_smpl (s->handle, s->scratch_data,
+      s->scratch_size);
+  uint_t read_length = read_samples / s->input_channels;
 
   /* where to store de-interleaved data */
   smpl_t *ptr_data;
+
+  if (!s->handle) {
+    AUBIO_ERR("source_sndfile: could not read from %s (file was closed)\n",
+        s->path);
+    *read = 0;
+    return;
+  }
+
 #ifdef HAVE_SAMPLERATE
   if (s->ratio != 1) {
@@ -180 +193 @@
 #endif /* HAVE_SAMPLERATE */
   {
+    read_length = MIN(length, read_length);
     ptr_data = read_data->data;
   }
 
   /* de-interleaving and down-mixing data  */
-  for (j = 0; j < read_samples / input_channels; j++) {
+  for (j = 0; j < read_length; j++) {
     ptr_data[j] = 0;
     for (i = 0; i < input_channels; i++) {
@@ -198 +212 @@
 #endif /* HAVE_SAMPLERATE */
 
-  *read = (int)FLOOR(s->ratio * read_samples / input_channels + .5);
-
-  if (*read < s->hop_size) {
-    for (j = *read; j < s->hop_size; j++) {
-      read_data->data[j] = 0;
-    }
-  }
+  *read = MIN(length, (uint_t)FLOOR(s->ratio * read_length + .5));
+
+  aubio_source_pad_output (read_data, *read);
 
 }
@@ -211 +221 @@
   uint_t i,j, input_channels = s->input_channels;
   /* do actual reading */
-  sf_count_t read_samples = aubio_sf_read_smpl (s->handle, s->scratch_data, s->scratch_size);
+  uint_t length = aubio_source_validate_input_length("source_sndfile", s->path,
+      s->hop_size, read_data->length);
+  uint_t channels = aubio_source_validate_input_channels("source_sndfile",
+      s->path, s->input_channels, read_data->height);
+  sf_count_t read_samples = aubio_sf_read_smpl (s->handle, s->scratch_data,
+      s->scratch_size);
+  uint_t read_length = read_samples / s->input_channels;
 
   /* where to store de-interleaved data */
   smpl_t **ptr_data;
+
+  if (!s->handle) {
+    AUBIO_ERR("source_sndfile: could not read from %s (file was closed)\n",
+        s->path);
+    *read = 0;
+    return;
+  }
+
 #ifdef HAVE_SAMPLERATE
   if (s->ratio != 1) {
@@ -221 +245 @@
 #endif /* HAVE_SAMPLERATE */
   {
+    read_length = MIN(read_length, length);
     ptr_data = read_data->data;
   }
 
-  if (read_data->height < input_channels) {
-    // destination matrix has less channels than the file; copy only first
-    // channels of the file, de-interleaving data
-    for (j = 0; j < read_samples / input_channels; j++) {
-      for (i = 0; i < read_data->height; i++) {
-        ptr_data[i][j] = s->scratch_data[j * input_channels + i];
-      }
-    }
-  } else {
-    // destination matrix has as many or more channels than the file; copy each
-    // channel from the file to the destination matrix, de-interleaving data
-    for (j = 0; j < read_samples / input_channels; j++) {
-      for (i = 0; i < input_channels; i++) {
-        ptr_data[i][j] = s->scratch_data[j * input_channels + i];
-      }
-    }
-  }
-
-  if (read_data->height > input_channels) {
-    // destination matrix has more channels than the file; copy last channel
-    // of the file to each additional channels, de-interleaving data
-    for (j = 0; j < read_samples / input_channels; j++) {
-      for (i = input_channels; i < read_data->height; i++) {
-        ptr_data[i][j] = s->scratch_data[j * input_channels + (input_channels - 1)];
-      }
+  for (j = 0; j < read_length; j++) {
+    for (i = 0; i < channels; i++) {
+      ptr_data[i][j] = s->scratch_data[j * input_channels + i];
     }
   }
@@ -265 +268 @@
 #endif /* HAVE_SAMPLERATE */
 
-  *read = (int)FLOOR(s->ratio * read_samples / input_channels + .5);
-
-  if (*read < s->hop_size) {
-    for (i = 0; i < read_data->height; i++) {
-      for (j = *read; j < s->hop_size; j++) {
-        read_data->data[i][j] = 0.;
-      }
-    }
-  }
-
+  *read = MIN(length, (uint_t)FLOOR(s->ratio * read_length + .5));
+
+  aubio_source_pad_multi_output(read_data, input_channels, *read);
 }
 

src/io/source_wavread.c

@@ -25 +25 @@
 #include "fvec.h"
 #include "fmat.h"
+#include "ioutils.h"
 #include "source_wavread.h"
 
-#include <errno.h>
-
 #define AUBIO_WAVREAD_BUFSIZE 1024
 
-#define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05)
+//#define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05)
 
 struct _aubio_source_wavread_t {
@@ -100 +99 @@
   s->fid = fopen((const char *)path, "rb");
   if (!s->fid) {
-    AUBIO_ERR("source_wavread: Failed opening %s (System error: %s)\n", s->path, strerror(errno));
+    AUBIO_STRERR("source_wavread: Failed opening %s (%s)\n", s->path, errorstr);
     goto beach;
   }
@@ -133 +132 @@
     bytes_junk += read_little_endian(buf, 4);
     if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
-      AUBIO_ERR("source_wavread: Failed opening %s (could not seek past JUNK Chunk: %s)\n",
-          s->path, strerror(errno));
+      AUBIO_STRERR("source_wavread: Failed opening %s (could not seek past JUNK Chunk: %s)\n",
+          s->path, errorstr);
       goto beach;
     }
@@ -261 +260 @@
     bytes_junk += read_little_endian(buf, 4);
     if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
-      AUBIO_ERR("source_wavread: could not seek past unknown chunk in %s (%s)\n",
-          s->path, strerror(errno));
+      AUBIO_STRERR("source_wavread: could not seek past unknown chunk in %s (%s)\n",
+          s->path, errorstr);
       goto beach;
     }
@@ -348 +347 @@
   uint_t end = 0;
   uint_t total_wrote = 0;
+  uint_t length = aubio_source_validate_input_length("source_wavread", s->path,
+      s->hop_size, read_data->length);
   if (s->fid == NULL) {
     AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
@@ -353 +354 @@
     return;
   }
-  while (total_wrote < s->hop_size) {
-    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
+  while (total_wrote < length) {
+    end = MIN(s->read_samples - s->read_index, length - total_wrote);
     for (i = 0; i < end; i++) {
       read_data->data[i + total_wrote] = 0;
@@ -363 +364 @@
     }
     total_wrote += end;
-    if (total_wrote < s->hop_size) {
+    if (total_wrote < length) {
       uint_t wavread_read = 0;
       aubio_source_wavread_readframe(s, &wavread_read);
@@ -375 +376 @@
     }
   }
-  if (total_wrote < s->hop_size) {
-    for (i = end; i < s->hop_size; i++) {
-      read_data->data[i] = 0.;
-    }
-  }
+
+  aubio_source_pad_output (read_data, total_wrote);
+
   *read = total_wrote;
 }
@@ -387 +386 @@
   uint_t end = 0;
   uint_t total_wrote = 0;
+  uint_t length = aubio_source_validate_input_length("source_wavread", s->path,
+      s->hop_size, read_data->length);
+  uint_t channels = aubio_source_validate_input_channels("source_wavread",
+      s->path, s->input_channels, read_data->height);
   if (s->fid == NULL) {
     AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
@@ -392 +395 @@
     return;
   }
-  while (total_wrote < s->hop_size) {
-    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
-    for (j = 0; j < read_data->height; j++) {
+  while (total_wrote < length) {
+    end = MIN(s->read_samples - s->read_index, length - total_wrote);
+    for (j = 0; j < channels; j++) {
       for (i = 0; i < end; i++) {
         read_data->data[j][i + total_wrote] = s->output->data[j][i];
@@ -400 +403 @@
     }
     total_wrote += end;
-    if (total_wrote < s->hop_size) {
+    if (total_wrote < length) {
       uint_t wavread_read = 0;
       aubio_source_wavread_readframe(s, &wavread_read);
@@ -412 +415 @@
     }
   }
-  if (total_wrote < s->hop_size) {
-    for (j = 0; j < read_data->height; j++) {
-      for (i = end; i < s->hop_size; i++) {
-        read_data->data[j][i] = 0.;
-      }
-    }
-  }
+
+  aubio_source_pad_multi_output(read_data, s->input_channels, total_wrote);
+
   *read = total_wrote;
 }
@@ -442 +441 @@
   ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
   if (ret != 0) {
-    AUBIO_ERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, strerror(errno));
+    AUBIO_STRERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, errorstr);
     return AUBIO_FAIL;
   }
@@ -463 +462 @@
   }
   if (fclose(s->fid)) {
-    AUBIO_ERR("source_wavread: could not close %s (%s)\n", s->path, strerror(errno));
+    AUBIO_STRERR("source_wavread: could not close %s (%s)\n", s->path, errorstr);
     return AUBIO_FAIL;
   }