Changeset cb0d7d0 for tests/src


Ignore:
Timestamp:
Dec 19, 2018, 7:31:45 PM (6 years ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/cnn, feature/crepe, feature/timestretch, fix/ffmpeg5, master
Children:
22d7902
Parents:
6e157df (diff), d0f19a7 (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:
tests/src
Files:
2 added
7 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • tests/src/io/test-sink.c

    r6e157df rcb0d7d0  
    22#include "utils_tests.h"
    33
    4 int main (int argc, char **argv)
     4int test_wrong_params(void);
     5
     6int main(int argc, char **argv)
    57{
    6   sint_t err = 0;
    7 
    8   if (argc < 3) {
    9     PRINT_ERR("not enough arguments, running tests\n");
    10     err = run_on_default_source_and_sink(main);
    11     PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [hop_size]\n", argv[0]);
     8  uint_t err = 0;
     9  if (argc < 3 || argc >= 6) {
     10    PRINT_ERR("wrong number of arguments, running tests\n");
     11    err = test_wrong_params();
     12    PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [hop_size]\n",
     13        argv[0]);
    1214    return err;
    1315  }
    … …  
    2022  char_t *sink_path = argv[2];
    2123
     24  aubio_source_t *src = NULL;
     25  aubio_sink_t *snk = NULL;
     26
    2227  if ( argc >= 4 ) samplerate = atoi(argv[3]);
    2328  if ( argc >= 5 ) hop_size = atoi(argv[4]);
    24   if ( argc >= 6 ) {
    25     err = 2;
    26     PRINT_ERR("too many arguments\n");
    27     return err;
    28   }
    2929
    3030  fvec_t *vec = new_fvec(hop_size);
    31   if (!vec) { err = 1; goto beach_fvec; }
     31  if (!vec) { err = 1; goto failure; }
    3232
    33   aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);
    34   if (!i) { err = 1; goto beach_source; }
     33  src = new_aubio_source(source_path, samplerate, hop_size);
     34  if (!src) { err = 1; goto failure; }
     35  if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(src);
    3536
    36   if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);
    37 
    38   aubio_sink_t *o = new_aubio_sink(sink_path, samplerate);
    39   if (!o) { err = 1; goto beach_sink; }
     37  snk = new_aubio_sink(sink_path, samplerate);
     38  if (!snk) { err = 1; goto failure; }
    4039
    4140  do {
    42     aubio_source_do(i, vec, &read);
    43     aubio_sink_do(o, vec, read);
     41    aubio_source_do(src, vec, &read);
     42    aubio_sink_do(snk, vec, read);
    4443    n_frames += read;
    4544  } while ( read == hop_size );
    4645
    47   PRINT_MSG("read %d frames at %dHz (%d blocks) from %s written to %s\n",
     46  PRINT_MSG("%d frames read at %dHz (%d blocks) from %s and written to %s\n",
    4847      n_frames, samplerate, n_frames / hop_size,
    4948      source_path, sink_path);
    5049
    51   del_aubio_sink(o);
    52 beach_sink:
    53   del_aubio_source(i);
    54 beach_source:
    55   del_fvec(vec);
    56 beach_fvec:
     50  // close sink now (optional)
     51  aubio_sink_close(snk);
     52
     53failure:
     54  if (snk)
     55    del_aubio_sink(snk);
     56  if (src)
     57    del_aubio_source(src);
     58  if (vec)
     59    del_fvec(vec);
     60
    5761  return err;
    5862}
     63
     64int test_wrong_params(void)
     65{
     66  fvec_t *vec;
     67  fmat_t *mat;
     68  aubio_sink_t *s;
     69  char_t sink_path[PATH_MAX] = "tmp_aubio_XXXXXX";
     70  uint_t samplerate = 44100;
     71  uint_t hop_size = 256;
     72  uint_t oversized_hop_size = 4097;
     73  uint_t oversized_samplerate = 192000 * 8 + 1;
     74  uint_t channels = 3;
     75  uint_t oversized_channels = 1025;
     76  // create temp file
     77  int fd = create_temp_sink(sink_path);
     78
     79  if (!fd) return 1;
     80
     81  if (new_aubio_sink(   0,   samplerate)) return 1;
     82  if (new_aubio_sink("\0",   samplerate)) return 1;
     83  if (new_aubio_sink(sink_path,      -1)) return 1;
     84
     85  s = new_aubio_sink(sink_path, 0);
     86
     87  // check setting wrong parameters fails
     88  if (!aubio_sink_preset_samplerate(s, oversized_samplerate)) return 1;
     89  if (!aubio_sink_preset_channels(s, oversized_channels)) return 1;
     90  if (!aubio_sink_preset_channels(s, -1)) return 1;
     91
     92  // check setting valid parameters passes
     93  if (aubio_sink_preset_samplerate(s, samplerate)) return 1;
     94  if (aubio_sink_preset_channels(s, 1)) return 1;
     95
     96  // check writing a vector with valid length
     97  vec = new_fvec(hop_size);
     98  aubio_sink_do(s, vec, hop_size);
     99  // check writing more than in the input
     100  aubio_sink_do(s, vec, hop_size+1);
     101  // check write 0 frames
     102  aubio_sink_do(s, vec, 0);
     103  del_fvec(vec);
     104
     105  // check writing an oversized vector
     106  vec = new_fvec(oversized_hop_size);
     107  aubio_sink_do(s, vec, oversized_hop_size);
     108  del_fvec(vec);
     109
     110  // test delete without closing
     111  del_aubio_sink(s);
     112
     113  s = new_aubio_sink(sink_path, 0);
     114
     115  // preset channels first
     116  if (aubio_sink_preset_channels(s, channels)) return 1;
     117  if (aubio_sink_preset_samplerate(s, samplerate)) return 1;
     118
     119  if (aubio_sink_get_samplerate(s) != samplerate) return 1;
     120  if (aubio_sink_get_channels(s) != channels) return 1;
     121
     122  mat = new_fmat(channels, hop_size);
     123  // check writing a vector with valid length
     124  aubio_sink_do_multi(s, mat, hop_size);
     125  // check writing 0 frames
     126  aubio_sink_do_multi(s, mat, 0);
     127  // check writing more than in the input
     128  aubio_sink_do_multi(s, mat, hop_size+1);
     129  del_fmat(mat);
     130
     131  // check writing oversized input
     132  mat = new_fmat(channels, oversized_hop_size);
     133  aubio_sink_do_multi(s, mat, oversized_hop_size);
     134  del_fmat(mat);
     135
     136  // check writing undersized input
     137  mat = new_fmat(channels - 1, hop_size);
     138  aubio_sink_do_multi(s, mat, hop_size);
     139  del_fmat(mat);
     140
     141  aubio_sink_close(s);
     142  // test closing twice
     143  aubio_sink_close(s);
     144
     145  del_aubio_sink(s);
     146
     147  // delete temp file
     148  close_temp_sink(sink_path, fd);
     149
     150  return run_on_default_source_and_sink(main);
     151}

  • tests/src/io/test-sink_apple_audio.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_sink_custom "apple_audio"
     6
     7#ifdef HAVE_SINK_APPLE_AUDIO
     8#define HAVE_AUBIO_SINK_CUSTOM
     9#define aubio_sink_custom_t aubio_sink_apple_audio_t
     10#define new_aubio_sink_custom new_aubio_sink_apple_audio
     11#define del_aubio_sink_custom del_aubio_sink_apple_audio
     12#define aubio_sink_custom_do aubio_sink_apple_audio_do
     13#define aubio_sink_custom_do_multi aubio_sink_apple_audio_do_multi
     14#define aubio_sink_custom_close aubio_sink_apple_audio_close
     15#define aubio_sink_custom_preset_samplerate aubio_sink_apple_audio_preset_samplerate
     16#define aubio_sink_custom_preset_channels aubio_sink_apple_audio_preset_channels
     17#define aubio_sink_custom_get_samplerate aubio_sink_apple_audio_get_samplerate
     18#define aubio_sink_custom_get_channels aubio_sink_apple_audio_get_channels
     19#endif /* HAVE_SINK_APPLE_AUDIO */
     20
     21#include "base-sink_custom.h"
    422
    523// this file uses the unstable aubio api, please use aubio_sink instead
    … …  
    826int main (int argc, char **argv)
    927{
    10   sint_t err = 0;
    11 
    12   if (argc < 3) {
    13     PRINT_ERR("not enough arguments, running tests\n");
    14     err = run_on_default_source_and_sink(main);
    15     PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [hop_size]\n", argv[0]);
    16     return err;
    17   }
    18 
    19 #ifdef HAVE_SINK_APPLE_AUDIO
    20   uint_t samplerate = 0;
    21   uint_t hop_size = 512;
    22   uint_t n_frames = 0, read = 0;
    23 
    24   char_t *source_path = argv[1];
    25   char_t *sink_path = argv[2];
    26 
    27   if ( argc >= 4 ) samplerate = atoi(argv[3]);
    28   if ( argc >= 5 ) hop_size = atoi(argv[4]);
    29   if ( argc >= 6 ) {
    30     err = 2;
    31     PRINT_ERR("too many arguments\n");
    32     return err;
    33   }
    34 
    35   fvec_t *vec = new_fvec(hop_size);
    36   if (!vec) { err = 1; goto beach_fvec; }
    37 
    38   aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);
    39   if (!i) { err = 1; goto beach_source; }
    40 
    41   if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);
    42 
    43   aubio_sink_apple_audio_t *o = new_aubio_sink_apple_audio(sink_path, samplerate);
    44   if (!o) { err = 1; goto beach_sink; }
    45 
    46   do {
    47     aubio_source_do(i, vec, &read);
    48     aubio_sink_apple_audio_do(o, vec, read);
    49     n_frames += read;
    50   } while ( read == hop_size );
    51 
    52   PRINT_MSG("read %d frames at %dHz (%d blocks) from %s written to %s\n",
    53       n_frames, samplerate, n_frames / hop_size,
    54       source_path, sink_path);
    55 
    56   del_aubio_sink_apple_audio(o);
    57 beach_sink:
    58   del_aubio_source(i);
    59 beach_source:
    60   del_fvec(vec);
    61 beach_fvec:
    62 #else /* HAVE_SINK_APPLE_AUDIO */
    63   err = 0;
    64   PRINT_ERR("aubio was not compiled with aubio_source_apple_audio\n");
    65 #endif /* HAVE_SINK_APPLE_AUDIO */
    66   return err;
     28  return base_main(argc, argv);
    6729}

  • tests/src/io/test-sink_sndfile.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_sink_custom "sndfile"
     6
     7#ifdef HAVE_SNDFILE
     8#define HAVE_AUBIO_SINK_CUSTOM
     9#define aubio_sink_custom_t aubio_sink_sndfile_t
     10#define new_aubio_sink_custom new_aubio_sink_sndfile
     11#define del_aubio_sink_custom del_aubio_sink_sndfile
     12#define aubio_sink_custom_do aubio_sink_sndfile_do
     13#define aubio_sink_custom_do_multi aubio_sink_sndfile_do_multi
     14#define aubio_sink_custom_close aubio_sink_sndfile_close
     15#define aubio_sink_custom_preset_samplerate aubio_sink_sndfile_preset_samplerate
     16#define aubio_sink_custom_preset_channels aubio_sink_sndfile_preset_channels
     17#define aubio_sink_custom_get_samplerate aubio_sink_sndfile_get_samplerate
     18#define aubio_sink_custom_get_channels aubio_sink_sndfile_get_channels
     19#endif /* HAVE_SNDFILE */
     20
     21#include "base-sink_custom.h"
    422
    523// this file uses the unstable aubio api, please use aubio_sink instead
    … …  
    826int main (int argc, char **argv)
    927{
    10   sint_t err = 0;
    11 
    12   if (argc < 3) {
    13     PRINT_ERR("not enough arguments, running tests\n");
    14     err = run_on_default_source_and_sink(main);
    15     PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [hop_size]\n", argv[0]);
    16     return err;
    17   }
    18 
    19 #ifdef HAVE_SNDFILE
    20   uint_t samplerate = 0;
    21   uint_t hop_size = 512;
    22   uint_t n_frames = 0, read = 0;
    23 
    24   char_t *source_path = argv[1];
    25   char_t *sink_path = argv[2];
    26 
    27   if ( argc >= 4 ) samplerate = atoi(argv[3]);
    28   if ( argc >= 5 ) hop_size = atoi(argv[4]);
    29   if ( argc >= 6 ) {
    30     err = 2;
    31     PRINT_ERR("too many arguments\n");
    32     return err;
    33   }
    34 
    35   fvec_t *vec = new_fvec(hop_size);
    36   if (!vec) { err = 1; goto beach_fvec; }
    37 
    38   aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);
    39   if (!i) { err = 1; goto beach_source; }
    40 
    41   if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);
    42 
    43   aubio_sink_sndfile_t *o = new_aubio_sink_sndfile(sink_path, samplerate);
    44   if (!o) { err = 1; goto beach_sink; }
    45 
    46   do {
    47     aubio_source_do(i, vec, &read);
    48     aubio_sink_sndfile_do(o, vec, read);
    49     n_frames += read;
    50   } while ( read == hop_size );
    51 
    52   PRINT_MSG("read %d frames at %dHz (%d blocks) from %s written to %s\n",
    53       n_frames, samplerate, n_frames / hop_size,
    54       source_path, sink_path);
    55 
    56   del_aubio_sink_sndfile(o);
    57 beach_sink:
    58   del_aubio_source(i);
    59 beach_source:
    60   del_fvec(vec);
    61 beach_fvec:
    62 #else
    63   err = 0;
    64   PRINT_ERR("aubio was not compiled with aubio_source_sndfile\n");
    65 #endif /* HAVE_SNDFILE */
    66   return err;
     28  return base_main(argc, argv);
    6729}

  • tests/src/io/test-sink_wavwrite.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_sink_custom "wavwrite"
     6
     7#ifdef HAVE_WAVWRITE
     8#define HAVE_AUBIO_SINK_CUSTOM
     9#define aubio_sink_custom_t aubio_sink_wavwrite_t
     10#define new_aubio_sink_custom new_aubio_sink_wavwrite
     11#define del_aubio_sink_custom del_aubio_sink_wavwrite
     12#define aubio_sink_custom_do aubio_sink_wavwrite_do
     13#define aubio_sink_custom_do_multi aubio_sink_wavwrite_do_multi
     14#define aubio_sink_custom_close aubio_sink_wavwrite_close
     15#define aubio_sink_custom_preset_samplerate aubio_sink_wavwrite_preset_samplerate
     16#define aubio_sink_custom_preset_channels aubio_sink_wavwrite_preset_channels
     17#define aubio_sink_custom_get_samplerate aubio_sink_wavwrite_get_samplerate
     18#define aubio_sink_custom_get_channels aubio_sink_wavwrite_get_channels
     19#endif /* HAVE_WAVWRITE */
     20
     21#include "base-sink_custom.h"
    422
    523// this file uses the unstable aubio api, please use aubio_sink instead
    … …  
    826int main (int argc, char **argv)
    927{
    10   sint_t err = 0;
    11 
    12   if (argc < 3) {
    13     PRINT_ERR("not enough arguments, running tests\n");
    14     err = run_on_default_source_and_sink(main);
    15     PRINT_MSG("usage: %s <input_path> <output_path> [samplerate] [hop_size]\n", argv[0]);
    16     return err;
    17   }
    18 
    19 #ifdef HAVE_WAVWRITE
    20   uint_t samplerate = 0;
    21   uint_t hop_size = 512;
    22   uint_t n_frames = 0, read = 0;
    23 
    24   char_t *source_path = argv[1];
    25   char_t *sink_path = argv[2];
    26 
    27   if ( argc >= 4 ) samplerate = atoi(argv[3]);
    28   if ( argc >= 5 ) hop_size = atoi(argv[4]);
    29   if ( argc >= 6 ) {
    30     err = 2;
    31     PRINT_ERR("too many arguments\n");
    32     return err;
    33   }
    34 
    35   fvec_t *vec = new_fvec(hop_size);
    36   if (!vec) { err = 1; goto beach_fvec; }
    37 
    38   aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);
    39   if (!i) { err = 1; goto beach_source; }
    40 
    41   if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);
    42 
    43   aubio_sink_wavwrite_t *o = new_aubio_sink_wavwrite(sink_path, samplerate);
    44   if (!o) { err = 1; goto beach_sink; }
    45 
    46   do {
    47     aubio_source_do(i, vec, &read);
    48     aubio_sink_wavwrite_do(o, vec, read);
    49     n_frames += read;
    50   } while ( read == hop_size );
    51 
    52   PRINT_MSG("read %d frames at %dHz (%d blocks) from %s written to %s\n",
    53       n_frames, samplerate, n_frames / hop_size,
    54       source_path, sink_path);
    55 
    56   del_aubio_sink_wavwrite(o);
    57 beach_sink:
    58   del_aubio_source(i);
    59 beach_source:
    60   del_fvec(vec);
    61 beach_fvec:
    62 #else
    63   err = 0;
    64   PRINT_ERR("aubio was not compiled with aubio_sink_wavwrite\n");
    65 #endif /* HAVE_WAVWRITE */
    66   return err;
     28  return base_main(argc, argv);
    6729}

  • tests/src/io/test-source.c

    r6e157df rcb0d7d0  
    22#include "utils_tests.h"
    33
    4 int main (int argc, char **argv)
     4int test_wrong_params(void);
     5
     6int main(int argc, char **argv)
    57{
    68  uint_t err = 0;
    79  if (argc < 2) {
    810    PRINT_ERR("not enough arguments, running tests\n");
    9     err = run_on_default_source(main);
     11    err = test_wrong_params();
    1012    PRINT_MSG("read a wave file as a mono vector\n");
    1113    PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
    … …  
    2830  char_t *source_path = argv[1];
    2931
    30 
    3132  aubio_source_t* s =
    3233    new_aubio_source(source_path, samplerate, hop_size);
    33   if (!s) { err = 1; goto beach; }
    3434  fvec_t *vec = new_fvec(hop_size);
     35  if (!s || !vec) { err = 1; goto beach; }
    3536
    3637  uint_t n_frames_expected = aubio_source_get_duration(s);
    … …  
    5051  // close the file (optional)
    5152  aubio_source_close(s);
     53
     54beach:
     55  if (vec)
     56    del_fvec(vec);
     57  if (s)
     58    del_aubio_source(s);
     59  return err;
     60}
     61
     62int test_wrong_params(void)
     63{
     64  char_t *uri = DEFINEDSTRING(AUBIO_TESTS_SOURCE);
     65  uint_t samplerate = 44100;
     66  uint_t hop_size = 512;
     67  uint_t channels, read = 0;
     68  fvec_t *vec;
     69  fmat_t *mat;
     70  aubio_source_t *s;
     71
     72  if (new_aubio_source(0,    samplerate, hop_size)) return 1;
     73  if (new_aubio_source("\0", samplerate, hop_size)) return 1;
     74  if (new_aubio_source(uri,          -1, hop_size)) return 1;
     75  if (new_aubio_source(uri,           0,        0)) return 1;
     76
     77  s = new_aubio_source(uri, samplerate, hop_size);
     78  if (!s) return 1;
     79  channels = aubio_source_get_channels(s);
     80
     81  // vector to read downmixed samples
     82  vec = new_fvec(hop_size);
     83  // matrix to read individual channels
     84  mat = new_fmat(channels, hop_size);
     85
     86  if (aubio_source_get_samplerate(s) != samplerate) return 1;
     87
     88  // read first hop_size frames
     89  aubio_source_do(s, vec, &read);
     90  if (read != hop_size) return 1;
     91
     92  // seek to 0
     93  if(aubio_source_seek(s, 0)) return 1;
     94
     95  // read again as multiple channels
     96  aubio_source_do_multi(s, mat, &read);
     97  if (read != hop_size) return 1;
     98
     99  // close the file (optional)
     100  aubio_source_close(s);
    52101  // test closing the file a second time
    53102  aubio_source_close(s);
    54103
    55   del_fvec (vec);
    56   del_aubio_source (s);
    57 beach:
    58   return err;
     104  del_aubio_source(s);
     105  del_fmat(mat);
     106  del_fvec(vec);
     107
     108  return run_on_default_source(main);
    59109}

  • tests/src/io/test-source_apple_audio.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_source_custom "apple_audio"
     6
     7#ifdef HAVE_SOURCE_APPLE_AUDIO
     8#define HAVE_AUBIO_SOURCE_CUSTOM
     9#define aubio_source_custom_t aubio_source_apple_audio_t
     10#define new_aubio_source_custom new_aubio_source_apple_audio
     11#define del_aubio_source_custom del_aubio_source_apple_audio
     12#define aubio_source_custom_get_samplerate aubio_source_apple_audio_get_samplerate
     13#define aubio_source_custom_get_duration aubio_source_apple_audio_get_duration
     14#define aubio_source_custom_do aubio_source_apple_audio_do
     15#define aubio_source_custom_do_multi aubio_source_apple_audio_do_multi
     16#define aubio_source_custom_seek aubio_source_apple_audio_seek
     17#define aubio_source_custom_close aubio_source_apple_audio_close
     18#define aubio_source_custom_get_channels aubio_source_apple_audio_get_channels
     19#define aubio_source_custom_get_samplerate aubio_source_apple_audio_get_samplerate
     20#endif /* HAVE_SOURCE_APPLE_AUDIO */
     21
     22#include "base-source_custom.h"
    423
    524// this file uses the unstable aubio api, please use aubio_source instead
    … …  
    827int main (int argc, char **argv)
    928{
    10   uint_t err = 0;
    11   if (argc < 2) {
    12     PRINT_ERR("not enough arguments, running tests\n");
    13     err = run_on_default_source(main);
    14     PRINT_MSG("read a wave file as a mono vector\n");
    15     PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
    16     PRINT_MSG("examples:\n");
    17     PRINT_MSG(" - read file.wav at original samplerate\n");
    18     PRINT_MSG("       %s file.wav\n", argv[0]);
    19     PRINT_MSG(" - read file.aif at 32000Hz\n");
    20     PRINT_MSG("       %s file.aif 32000\n", argv[0]);
    21     PRINT_MSG(" - read file.mp3 at original samplerate with 4096 blocks\n");
    22     PRINT_MSG("       %s file.mp3 0 4096 \n", argv[0]);
    23     return err;
    24   }
    25 
    26 #if HAVE_SOURCE_APPLE_AUDIO
    27   uint_t samplerate = 0;
    28   uint_t hop_size = 256;
    29   uint_t n_frames = 0, read = 0;
    30   if ( argc >= 3 ) samplerate = atoi(argv[2]);
    31   if ( argc >= 4 ) hop_size = atoi(argv[3]);
    32 
    33   char_t *source_path = argv[1];
    34 
    35 
    36   aubio_source_apple_audio_t * s =
    37     new_aubio_source_apple_audio(source_path, samplerate, hop_size);
    38   if (!s) { err = 1; goto beach; }
    39   fvec_t *vec = new_fvec(hop_size);
    40 
    41   uint_t n_frames_expected = aubio_source_apple_audio_get_duration(s);
    42 
    43   samplerate = aubio_source_apple_audio_get_samplerate(s);
    44 
    45   do {
    46     aubio_source_apple_audio_do(s, vec, &read);
    47     fvec_print (vec);
    48     n_frames += read;
    49   } while ( read == hop_size );
    50 
    51   PRINT_MSG("read %d frames (expected %d) at %dHz (%d blocks) from %s\n",
    52             n_frames, n_frames_expected, samplerate, n_frames / hop_size,
    53             source_path);
    54 
    55   del_fvec (vec);
    56   del_aubio_source_apple_audio (s);
    57 beach:
    58 #else /* HAVE_SOURCE_APPLE_AUDIO */
    59   err = 0;
    60   PRINT_ERR("aubio was not compiled with aubio_source_apple_audio\n");
    61 #endif /* HAVE_SOURCE_APPLE_AUDIO */
    62   return err;
     29  return base_main(argc, argv);
    6330}

  • tests/src/io/test-source_avcodec.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_source_custom "avcodec"
     6
     7#ifdef HAVE_LIBAV
     8#define HAVE_AUBIO_SOURCE_CUSTOM
     9#define aubio_source_custom_t aubio_source_avcodec_t
     10#define new_aubio_source_custom new_aubio_source_avcodec
     11#define del_aubio_source_custom del_aubio_source_avcodec
     12#define aubio_source_custom_get_samplerate aubio_source_avcodec_get_samplerate
     13#define aubio_source_custom_get_duration aubio_source_avcodec_get_duration
     14#define aubio_source_custom_do aubio_source_avcodec_do
     15#define aubio_source_custom_do_multi aubio_source_avcodec_do_multi
     16#define aubio_source_custom_seek aubio_source_avcodec_seek
     17#define aubio_source_custom_close aubio_source_avcodec_close
     18#define aubio_source_custom_get_channels aubio_source_avcodec_get_channels
     19#define aubio_source_custom_get_samplerate aubio_source_avcodec_get_samplerate
     20#endif /* HAVE_LIBAV */
     21
     22#include "base-source_custom.h"
    423
    524// this file uses the unstable aubio api, please use aubio_source instead
    … …  
    827int main (int argc, char **argv)
    928{
    10   uint_t err = 0;
    11   if (argc < 2) {
    12     PRINT_ERR("not enough arguments, running tests\n");
    13     err = run_on_default_source(main);
    14     PRINT_MSG("read a wave file as a mono vector\n");
    15     PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
    16     PRINT_MSG("examples:\n");
    17     PRINT_MSG(" - read file.wav at original samplerate\n");
    18     PRINT_MSG("       %s file.wav\n", argv[0]);
    19     PRINT_MSG(" - read file.wav at 32000Hz\n");
    20     PRINT_MSG("       %s file.aif 32000\n", argv[0]);
    21     PRINT_MSG(" - read file.wav at original samplerate with 4096 blocks\n");
    22     PRINT_MSG("       %s file.wav 0 4096 \n", argv[0]);
    23     return err;
    24   }
    25 
    26 #ifdef HAVE_LIBAV
    27   uint_t samplerate = 0;
    28   uint_t hop_size = 256;
    29   uint_t n_frames = 0, read = 0;
    30   if ( argc >= 3 ) samplerate = atoi(argv[2]);
    31   if ( argc >= 4 ) hop_size = atoi(argv[3]);
    32 
    33   char_t *source_path = argv[1];
    34 
    35 
    36   aubio_source_avcodec_t * s =
    37     new_aubio_source_avcodec(source_path, samplerate, hop_size);
    38   if (!s) { err = 1; goto beach; }
    39   fvec_t *vec = new_fvec(hop_size);
    40 
    41   uint_t n_frames_expected = aubio_source_avcodec_get_duration(s);
    42 
    43   samplerate = aubio_source_avcodec_get_samplerate(s);
    44 
    45   do {
    46     aubio_source_avcodec_do(s, vec, &read);
    47     fvec_print (vec);
    48     n_frames += read;
    49   } while ( read == hop_size );
    50 
    51   PRINT_MSG("read %d frames (expected %d) at %dHz (%d blocks) from %s\n",
    52             n_frames, n_frames_expected, samplerate, n_frames / hop_size,
    53             source_path);
    54 
    55   del_fvec (vec);
    56   del_aubio_source_avcodec (s);
    57 beach:
    58 #else /* HAVE_LIBAV */
    59   err = 0;
    60   PRINT_ERR("aubio was not compiled with aubio_source_avcodec\n");
    61 #endif /* HAVE_LIBAV */
    62   return err;
     29  return base_main(argc, argv);
    6330}

  • tests/src/io/test-source_sndfile.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_source_custom "sndfile"
     6
     7#ifdef HAVE_SNDFILE
     8#define HAVE_AUBIO_SOURCE_CUSTOM
     9#define aubio_source_custom_t aubio_source_sndfile_t
     10#define new_aubio_source_custom new_aubio_source_sndfile
     11#define del_aubio_source_custom del_aubio_source_sndfile
     12#define aubio_source_custom_get_samplerate aubio_source_sndfile_get_samplerate
     13#define aubio_source_custom_get_duration aubio_source_sndfile_get_duration
     14#define aubio_source_custom_do aubio_source_sndfile_do
     15#define aubio_source_custom_do_multi aubio_source_sndfile_do_multi
     16#define aubio_source_custom_seek aubio_source_sndfile_seek
     17#define aubio_source_custom_close aubio_source_sndfile_close
     18#define aubio_source_custom_get_channels aubio_source_sndfile_get_channels
     19#define aubio_source_custom_get_samplerate aubio_source_sndfile_get_samplerate
     20#endif /* HAVE_LIBAV */
     21
     22#include "base-source_custom.h"
    423
    524// this file uses the unstable aubio api, please use aubio_source instead
    … …  
    827int main (int argc, char **argv)
    928{
    10   uint_t err = 0;
    11   if (argc < 2) {
    12     PRINT_ERR("not enough arguments, running tests\n");
    13     err = run_on_default_source(main);
    14     PRINT_MSG("read a wave file as a mono vector\n");
    15     PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
    16     PRINT_MSG("examples:\n");
    17     PRINT_MSG(" - read file.wav at original samplerate\n");
    18     PRINT_MSG("       %s file.wav\n", argv[0]);
    19     PRINT_MSG(" - read file.wav at 32000Hz\n");
    20     PRINT_MSG("       %s file.aif 32000\n", argv[0]);
    21     PRINT_MSG(" - read file.wav at original samplerate with 4096 blocks\n");
    22     PRINT_MSG("       %s file.wav 0 4096 \n", argv[0]);
    23     return err;
    24   }
    25 
    26 #ifdef HAVE_SNDFILE
    27   uint_t samplerate = 0;
    28   uint_t hop_size = 256;
    29   uint_t n_frames = 0, read = 0;
    30   if ( argc >= 3 ) samplerate = atoi(argv[2]);
    31   if ( argc >= 4 ) hop_size = atoi(argv[3]);
    32 
    33   char_t *source_path = argv[1];
    34 
    35 
    36   aubio_source_sndfile_t * s =
    37     new_aubio_source_sndfile(source_path, samplerate, hop_size);
    38   if (!s) { err = 1; goto beach; }
    39   fvec_t *vec = new_fvec(hop_size);
    40 
    41   uint_t n_frames_expected = aubio_source_sndfile_get_duration(s);
    42 
    43   samplerate = aubio_source_sndfile_get_samplerate(s);
    44 
    45   do {
    46     aubio_source_sndfile_do(s, vec, &read);
    47     fvec_print (vec);
    48     n_frames += read;
    49   } while ( read == hop_size );
    50 
    51   PRINT_MSG("read %d frames (expected %d) at %dHz (%d blocks) from %s\n",
    52             n_frames, n_frames_expected, samplerate, n_frames / hop_size,
    53             source_path);
    54 
    55   del_fvec (vec);
    56   del_aubio_source_sndfile (s);
    57 beach:
    58 #else
    59   err = 0;
    60   PRINT_ERR("aubio was not compiled with aubio_source_sndfile\n");
    61 #endif /* HAVE_SNDFILE */
    62   return err;
     29  return base_main(argc, argv);
    6330}

  • tests/src/io/test-source_wavread.c

    r6e157df rcb0d7d0  
    22#include <aubio.h>
    33#include "utils_tests.h"
     4
     5#define aubio_source_custom "wavread"
     6
     7#ifdef HAVE_WAVREAD
     8#define HAVE_AUBIO_SOURCE_CUSTOM
     9#define aubio_source_custom_t aubio_source_wavread_t
     10#define new_aubio_source_custom new_aubio_source_wavread
     11#define del_aubio_source_custom del_aubio_source_wavread
     12#define aubio_source_custom_get_samplerate aubio_source_wavread_get_samplerate
     13#define aubio_source_custom_get_duration aubio_source_wavread_get_duration
     14#define aubio_source_custom_do aubio_source_wavread_do
     15#define aubio_source_custom_do_multi aubio_source_wavread_do_multi
     16#define aubio_source_custom_seek aubio_source_wavread_seek
     17#define aubio_source_custom_close aubio_source_wavread_close
     18#define aubio_source_custom_get_channels aubio_source_wavread_get_channels
     19#define aubio_source_custom_get_samplerate aubio_source_wavread_get_samplerate
     20#endif /* HAVE_WAVREAD */
     21
     22#include "base-source_custom.h"
    423
    524// this file uses the unstable aubio api, please use aubio_source instead
    … …  
    827int main (int argc, char **argv)
    928{
    10   uint_t err = 0;
    11   if (argc < 2) {
    12     PRINT_ERR("not enough arguments, running tests\n");
    13     err = run_on_default_source(main);
    14     PRINT_MSG("read a wave file as a mono vector\n");
    15     PRINT_MSG("usage: %s <source_path> [samplerate] [hop_size]\n", argv[0]);
    16     PRINT_MSG("examples:\n");
    17     PRINT_MSG(" - read file.wav at original samplerate\n");
    18     PRINT_MSG("       %s file.wav\n", argv[0]);
    19     PRINT_MSG(" - read file.wav at 32000Hz\n");
    20     PRINT_MSG("       %s file.aif 32000\n", argv[0]);
    21     PRINT_MSG(" - read file.wav at original samplerate with 4096 blocks\n");
    22     PRINT_MSG("       %s file.wav 0 4096 \n", argv[0]);
    23     return err;
    24   }
    25 
    26 #ifdef HAVE_WAVREAD
    27   uint_t samplerate = 0;
    28   uint_t hop_size = 256;
    29   uint_t n_frames = 0, read = 0;
    30   if ( argc >= 3 ) samplerate = atoi(argv[2]);
    31   if ( argc >= 4 ) hop_size = atoi(argv[3]);
    32 
    33   char_t *source_path = argv[1];
    34 
    35 
    36   aubio_source_wavread_t * s =
    37     new_aubio_source_wavread(source_path, samplerate, hop_size);
    38   if (!s) { err = 1; goto beach; }
    39   fvec_t *vec = new_fvec(hop_size);
    40 
    41   uint_t n_frames_expected = aubio_source_wavread_get_duration(s);
    42 
    43   samplerate = aubio_source_wavread_get_samplerate(s);
    44 
    45   do {
    46     aubio_source_wavread_do(s, vec, &read);
    47     fvec_print (vec);
    48     n_frames += read;
    49   } while ( read == hop_size );
    50 
    51   PRINT_MSG("read %d frames (expected %d) at %dHz (%d blocks) from %s\n",
    52             n_frames, n_frames_expected, samplerate, n_frames / hop_size,
    53             source_path);
    54 
    55   del_fvec (vec);
    56   del_aubio_source_wavread (s);
    57 beach:
    58 #else
    59   err = 0;
    60   PRINT_ERR("aubio was not compiled with aubio_source_wavread\n");
    61 #endif /* HAVE_WAVREAD */
    62   return err;
     29  return base_main(argc, argv);
    6330}

  • tests/src/onset/test-onset.c

    r6e157df rcb0d7d0  
    7070  uint_t samplerate = 44100;
    7171  // hop_size < 1
    72   if (new_aubio_onset("default", 5, 0, samplerate))
    73     return 1;
     72  if (new_aubio_onset("default", 5, 0, samplerate)) return 1;
     73
    7474  // buf_size < 2
    75   if (new_aubio_onset("default", 1, 1, samplerate))
    76     return 1;
     75  if (new_aubio_onset("default", 1, 1, samplerate)) return 1;
     76
    7777  // buf_size < hop_size
    78   if (new_aubio_onset("default", hop_size, win_size, samplerate))
    79     return 1;
     78  if (new_aubio_onset("default", hop_size, win_size, samplerate)) return 1;
     79
    8080  // samplerate < 1
    81   if (new_aubio_onset("default", 1024, 512, 0))
    82     return 1;
     81  if (new_aubio_onset("default", 1024, 512, 0)) return 1;
    8382
    8483  // specdesc creation failed
    85   if (new_aubio_onset("abcd", win_size, win_size/2, samplerate))
    86     return 1;
     84  if (new_aubio_onset("abcd", win_size, win_size/2, samplerate)) return 1;
    8785
    8886  aubio_onset_t *o;
    … …  
    9391
    9492  o = new_aubio_onset("default", win_size, hop_size, samplerate);
    95   if (!aubio_onset_set_default_parameters(o, "wrong_type"))
    96     return 1;
     93  if (!aubio_onset_set_default_parameters(o, "wrong_type")) return 1;
    9794  del_aubio_onset(o);
    9895

  • tests/src/spectral/test-mfcc.c

    r6e157df rcb0d7d0  
    11#include <aubio.h>
     2#include "utils_tests.h"
    23
    3 int main (void)
     4int test_wrong_params(void);
     5
     6int main (int argc, char** argv)
     7{
     8  sint_t err = 0;
     9
     10  if (argc < 2) {
     11    err = 2;
     12    PRINT_WRN("no arguments, running tests\n");
     13    err = test_wrong_params();
     14    PRINT_MSG("usage: %s <input_path> [samplerate] [hop_size]\n", argv[0]);
     15    return err;
     16  }
     17
     18  uint_t win_s; // fft size
     19  uint_t hop_s = 256; // block size
     20  uint_t samplerate = 0; // samplerate
     21  uint_t n_filters = 40; // number of filters
     22  uint_t n_coeffs = 13; // number of coefficients
     23  uint_t read = 0;
     24
     25  char_t *source_path = argv[1];
     26
     27  if ( argc >= 3 ) samplerate = atoi(argv[2]);
     28  if ( argc >= 4 ) hop_s = atoi(argv[3]);
     29
     30  win_s = 2 * hop_s;
     31
     32  aubio_source_t *source = 0;
     33  aubio_pvoc_t *pv = 0;
     34  aubio_mfcc_t *mfcc = 0;
     35
     36  fvec_t *in = new_fvec (win_s); // input buffer
     37  cvec_t *fftgrain = new_cvec (win_s); // input buffer
     38  fvec_t *out = new_fvec (n_coeffs); // output coefficients
     39
     40  if (!in || !fftgrain || !out) { err = 1; goto failure; }
     41
     42  // source
     43  source = new_aubio_source(source_path, samplerate, hop_s);
     44  if (!source) { err = 1; goto failure; }
     45  if (samplerate == 0) samplerate = aubio_source_get_samplerate(source);
     46
     47  // phase vocoder
     48  pv = new_aubio_pvoc(win_s, hop_s);
     49  if (!pv) { err = 1; goto failure; }
     50
     51  // mfcc object
     52  mfcc = new_aubio_mfcc (win_s, n_filters, n_coeffs, samplerate);
     53  if (!mfcc) { err = 1; goto failure; }
     54
     55  // processing loop
     56  do {
     57    aubio_source_do(source, in, &read);
     58    aubio_pvoc_do(pv, in, fftgrain);
     59    aubio_mfcc_do(mfcc, fftgrain, out);
     60    fvec_print(out);
     61  } while (read == hop_s);
     62
     63failure:
     64
     65  if (mfcc)
     66    del_aubio_mfcc(mfcc);
     67  if (pv)
     68    del_aubio_pvoc(pv);
     69  if (source)
     70    del_aubio_source(source);
     71  if (in)
     72    del_fvec(in);
     73  if (fftgrain)
     74    del_cvec(fftgrain);
     75  if (out)
     76    del_fvec(out);
     77  aubio_cleanup();
     78  return err;
     79}
     80
     81int test_wrong_params()
    482{
    583  uint_t win_s = 512; // fft size
    … …  
    785  uint_t n_coeffs = 13; // number of coefficients
    886  smpl_t samplerate = 16000.; // samplerate
    9   cvec_t *in = new_cvec (win_s); // input buffer
    10   fvec_t *out = new_fvec (n_coeffs); // output coefficients
    1187
    1288  if (new_aubio_mfcc(    0, n_filters, n_coeffs, samplerate)) return 1;
    … …  
    1591  if (new_aubio_mfcc(win_s, n_filters, n_coeffs,          0)) return 1;
    1692
    17   // create mfcc object
    18   aubio_mfcc_t *o = new_aubio_mfcc (win_s, n_filters, n_coeffs, samplerate);
    19 
    20   cvec_norm_set_all (in, 1.);
    21   aubio_mfcc_do (o, in, out);
    22   fvec_print (out);
    23 
    24   cvec_norm_set_all (in, .5);
    25   aubio_mfcc_do (o, in, out);
    26   fvec_print (out);
    27 
    28   // clean up
    29   del_aubio_mfcc (o);
    30   del_cvec (in);
    31   del_fvec (out);
    32   aubio_cleanup ();
    33 
    34   return 0;
     93  return run_on_default_source(main);
    3594}

  • tests/src/tempo/test-tempo.c

    r6e157df rcb0d7d0  
    8282
    8383  // test wrong method fails
    84   if (new_aubio_tempo("unexisting_method", win_size, hop_size, samplerate))
    85     return 1;
     84  if (new_aubio_tempo("undefined", win_size, hop_size, samplerate)) return 1;
    8685
    8786  // test hop > win fails
    88   if (new_aubio_tempo("default", hop_size, win_size, samplerate))
    89     return 1;
     87  if (new_aubio_tempo("default", hop_size, win_size, samplerate)) return 1;
    9088
    9189  // test null hop_size fails
    92   if (new_aubio_tempo("default", win_size, 0, samplerate))
    93     return 1;
     90  if (new_aubio_tempo("default", win_size, 0, samplerate)) return 1;
    9491
    9592  // test 1 buf_size fails
    96   if (new_aubio_tempo("default", 1, 1, samplerate))
    97     return 1;
     93  if (new_aubio_tempo("default", 1, 1, samplerate)) return 1;
    9894
    9995  // test null samplerate fails
    100   if (new_aubio_tempo("default", win_size, hop_size, 0))
    101     return 1;
     96  if (new_aubio_tempo("default", win_size, hop_size, 0)) return 1;
    10297
    10398  // test short sizes workaround
    10499  t = new_aubio_tempo("default", 2048, 2048, 500);
    105   if (!t)
    106     return 1;
     100  if (!t) return 1;
    107101
    108102  del_aubio_tempo(t);
    109103
    110104  t = new_aubio_tempo("default", win_size, hop_size, samplerate);
    111   if (!t)
    112     return 1;
     105  if (!t) return 1;
    113106
    114107  in = new_fvec(hop_size);

  • tests/src/temporal/test-filter.c

    r6e157df rcb0d7d0  
    1010  aubio_filter_t *o = new_aubio_filter_c_weighting (44100);
    1111
    12   if (new_aubio_filter(0))
    13     return 1;
     12  if (new_aubio_filter(0)) return 1;
    1413
    15   if (aubio_filter_get_samplerate(o) != 44100)
    16     return 1;
     14  if (aubio_filter_get_samplerate(o) != 44100) return 1;
    1715
    18   if (aubio_filter_set_c_weighting (o, -1) == 0)
    19     return 1;
     16  if (aubio_filter_set_c_weighting (o, -1) == 0) return 1;
    2017
    21   if (aubio_filter_set_c_weighting (0, 32000) == 0)
    22     return 1;
     18  if (aubio_filter_set_c_weighting (0, 32000) == 0) return 1;
    2319
    2420  in->data[impulse_at] = 0.5;
    … …  
    3026  o = new_aubio_filter_a_weighting (32000);
    3127
    32   if (aubio_filter_set_a_weighting (o, -1) == 0)
    33     return 1;
    34   if (aubio_filter_set_a_weighting (0, 32000) == 0)
    35     return 1;
     28  if (aubio_filter_set_a_weighting (o, -1) == 0) return 1;
     29
     30  if (aubio_filter_set_a_weighting (0, 32000) == 0) return 1;
    3631
    3732  in->data[impulse_at] = 0.5;
Note: See TracChangeset for help on using the changeset viewer.