Changes in / [4cb2d54:00c9444]


Ignore:
Files:
1 deleted
22 edited

Legend:

Unmodified
Added
Removed
  • .travis.yml

    r4cb2d54 r00c9444  
    33matrix:
    44  include:
    5     - python: 3.6
     5    - python: 3.5
    66      os: linux
    77      compiler: gcc
    8     - python: 3.5
     8    - python: 3.4
    99      os: linux
    1010      compiler: gcc
     
    1212      os: linux
    1313      compiler: gcc
    14     - python: "pypy3.5"
     14    - python: "pypy"
    1515      os: linux
    1616      compiler: gcc
    1717      env: CFLAGS="-Os" WAFOPTS="--disable-avcodec"
    18     - python: 3.6
     18    - python: 3.5
    1919      os: linux
    2020      compiler: gcc
    2121      env: CFLAGS="-Os" WAFOPTS="--disable-samplerate"
    22     - python: 3.5
     22    - python: 3.4
    2323      os: linux
    2424      compiler: gcc
  • examples/utils.c

    r4cb2d54 r00c9444  
    185185
    186186    del_aubio_source (this_source);
    187     if (this_sink)
    188       del_aubio_sink   (this_sink);
     187    del_aubio_sink   (this_sink);
    189188
    190189  }
  • python/ext/py-filter.c

    r4cb2d54 r00c9444  
    110110{
    111111  Py_XDECREF(self->out);
    112   if (self->o)
    113     del_aubio_filter (self->o);
     112  del_aubio_filter (self->o);
    114113  Py_TYPE(self)->tp_free ((PyObject *) self);
    115114}
  • python/ext/py-sink.c

    r4cb2d54 r00c9444  
    151151Py_sink_del (Py_sink *self, PyObject *unused)
    152152{
    153   if (self->o) {
    154     del_aubio_sink(self->o);
    155     free(self->mwrite_data.data);
    156   }
     153  del_aubio_sink(self->o);
     154  free(self->mwrite_data.data);
    157155  if (self->uri) {
    158156    free(self->uri);
  • python/ext/py-source.c

    r4cb2d54 r00c9444  
    437437  aubio_source_do (self->o, &(self->c_read_to), &read);
    438438
    439   if (PyErr_Occurred() != NULL) {
    440     return NULL;
    441   }
    442 
    443439  outputs = PyTuple_New(2);
    444440  PyTuple_SetItem( outputs, 0, self->read_to );
     
    461457  /* compute _do function */
    462458  aubio_source_do_multi (self->o, &(self->c_mread_to), &read);
    463 
    464   if (PyErr_Occurred() != NULL) {
    465     return NULL;
    466   }
    467459
    468460  outputs = PyTuple_New(2);
     
    582574    } else if (PyLong_AsLong(size) > 0) {
    583575      // short read, return a shorter array
    584       PyArrayObject *shortread = (PyArrayObject*)PyTuple_GetItem(done, 0);
     576      PyArrayObject *shortread = (PyArrayObject*)
     577        PyArray_FROM_OTF(PyTuple_GetItem(done, 0), NPY_NOTYPE,
     578            NPY_ARRAY_ENSURECOPY);
    585579      PyArray_Dims newdims;
    586580      PyObject *reshaped;
  • python/tests/test_source.py

    r4cb2d54 r00c9444  
    2424_debug = False
    2525
    26 class Test_aubio_source_test_case(TestCase):
     26class Test_aubio_source_test_case(object):
    2727
    28     def setUp(self):
    29         if not default_test_sound:
    30             skipTest(no_sounds_msg)
    31 
    32     def test_close_file(self):
     28    @parametrize('filename', list_of_sounds)
     29    def test_close_file(self, filename):
    3330        samplerate = 0 # use native samplerate
    3431        hop_size = 256
    35         f = source(default_test_sound, samplerate, hop_size)
     32        f = source(filename, samplerate, hop_size)
    3633        f.close()
    3734
    38     def test_close_file_twice(self):
     35    @parametrize('filename', list_of_sounds)
     36    def test_close_file_twice(self, filename):
    3937        samplerate = 0 # use native samplerate
    4038        hop_size = 256
    41         f = source(default_test_sound, samplerate, hop_size)
     39        f = source(filename, samplerate, hop_size)
    4240        f.close()
    4341        f.close()
    44 
    45     def test_read_after_close(self):
    46         samplerate = 0 # use native samplerate
    47         hop_size = 256
    48         f = source(default_test_sound, samplerate, hop_size)
    49         read, frames = f()
    50         f.close()
    51         with assert_raises(RuntimeError):
    52             read, frames = f()
    53         with assert_raises(RuntimeError):
    54             read, frames = f.do_multi()
    55 
    5642
    5743class Test_aubio_source_read(object):
  • scripts/build_apple_frameworks

    r4cb2d54 r00c9444  
    1414#VERSION+=+$(git log --pretty=format:"%h" -1)
    1515
    16 CFLAGS="-Werror -Os"
     16CFLAGS="-Werror -Ofast"
    1717WAFCONF="--disable-sndfile --disable-avcodec --disable-samplerate --enable-fat" # --disable-memcpy --disable-accelerate"
    1818
  • src/io/sink.c

    r4cb2d54 r00c9444  
    217217void del_aubio_sink(aubio_sink_t * s) {
    218218  AUBIO_ASSERT(s);
    219   if (s && s->s_del && s->sink)
     219  if (s->s_del && s->sink)
    220220    s->s_del((void *)s->sink);
    221221  AUBIO_FREE(s);
  • src/io/source.c

    r4cb2d54 r00c9444  
    140140void del_aubio_source(aubio_source_t * s) {
    141141  AUBIO_ASSERT(s);
    142   if (s && s->s_del && s->source)
     142  if (s->s_del && s->source)
    143143    s->s_del((void *)s->source);
    144144  AUBIO_FREE(s);
  • src/io/source_apple_audio.c

    r4cb2d54 r00c9444  
    345345        "error in ExtAudioFileGetProperty (%s)\n", s->path,
    346346        getPrintableOSStatusError(errorstr, err));
    347     return 0;
     347    return err;
    348348  }
    349349  return (uint_t)fileLengthFrames;
  • src/io/source_avcodec.c

    r4cb2d54 r00c9444  
    492492  uint_t length = aubio_source_validate_input_length("source_avcodec", s->path,
    493493      s->hop_size, read_data->length);
    494   if (!s->avr || !s->avFormatCtx || !s->avCodecCtx) {
    495     AUBIO_ERR("source_avcodec: could not read from %s (file was closed)\n",
    496         s->path);
    497     *read= 0;
    498     return;
    499   }
    500494  while (total_wrote < length) {
    501495    end = MIN(s->read_samples - s->read_index, length - total_wrote);
     
    536530  uint_t channels = aubio_source_validate_input_channels("source_avcodec",
    537531      s->path, s->input_channels, read_data->height);
    538   if (!s->avr || !s->avFormatCtx || !s->avCodecCtx) {
    539     AUBIO_ERR("source_avcodec: could not read from %s (file was closed)\n",
    540         s->path);
    541     *read= 0;
    542     return;
    543   }
    544532  while (total_wrote < length) {
    545533    end = MIN(s->read_samples - s->read_index, length - total_wrote);
  • src/io/source_sndfile.c

    r4cb2d54 r00c9444  
    175175  sf_count_t read_samples = aubio_sf_read_smpl (s->handle, s->scratch_data,
    176176      s->scratch_size);
    177   if (!s->handle) {
    178     AUBIO_ERR("source_sndfile: could not read from %s (file was closed)\n",
    179         s->path);
    180     *read = 0;
    181     return;
    182   }
    183177
    184178  uint_t read_length = read_samples / s->input_channels;
     
    226220  sf_count_t read_samples = aubio_sf_read_smpl (s->handle, s->scratch_data,
    227221      s->scratch_size);
    228   if (!s->handle) {
    229     AUBIO_ERR("source_sndfile: could not read from %s (file was closed)\n",
    230         s->path);
    231     *read = 0;
    232     return;
    233   }
    234222
    235223  uint_t read_length = read_samples / s->input_channels;
  • tests/src/io/base-sink_custom.h

    r4cb2d54 r00c9444  
    152152  close_temp_sink(sink_path, fd);
    153153
    154   // shouldn't crash on null (bypassed, only check del_aubio_sink)
    155   // del_aubio_sink_custom(NULL);
    156 
    157154  return run_on_default_source_and_sink(base_main);
    158155}
  • tests/src/io/base-source_custom.h

    r4cb2d54 r00c9444  
    142142  aubio_source_custom_close(s);
    143143
    144   // reading after close fails
    145   del_fvec(vec);
    146   vec = new_fvec(hop_size);
    147   aubio_source_custom_do(s, vec, &read);
    148   del_fmat(mat);
    149   mat = new_fmat(channels, hop_size);
    150   aubio_source_custom_do_multi(s, mat, &read);
    151 
    152144  del_aubio_source_custom(s);
    153145  del_fmat(mat);
    154146  del_fvec(vec);
    155 
    156   // shouldn't crash on null (bypassed, only check del_aubio_source)
    157   // del_aubio_source_custom(NULL);
    158147
    159148  return run_on_default_source(base_main);
  • tests/src/io/test-sink.c

    r4cb2d54 r00c9444  
    148148  close_temp_sink(sink_path, fd);
    149149
    150   // shouldn't crash on null
    151   del_aubio_sink(NULL);
    152 
    153150  return run_on_default_source_and_sink(main);
    154151}
  • tests/src/io/test-source.c

    r4cb2d54 r00c9444  
    138138  aubio_source_close(s);
    139139
    140   // reading after close fails
    141   del_fvec(vec);
    142   vec = new_fvec(hop_size);
    143   aubio_source_do(s, vec, &read);
    144   del_fmat(mat);
    145   mat = new_fmat(channels, hop_size);
    146   aubio_source_do_multi(s, mat, &read);
    147 
    148140  del_aubio_source(s);
    149141  del_fmat(mat);
    150142  del_fvec(vec);
    151143
    152   // shouldn't crash on null
    153   del_aubio_source(NULL);
    154 
    155144  return run_on_default_source(main);
    156145}
  • tests/src/test-cvec.c

    r4cb2d54 r00c9444  
    44int main (void)
    55{
    6   uint_t i, window_size = 16;
    7   cvec_t * complex_vector = new_cvec(window_size);
    8   cvec_t * other_cvector = new_cvec(window_size);
     6  uint_t i, window_size = 16; // window size
     7  cvec_t * complex_vector = new_cvec (window_size); // input buffer
     8  uint_t rand_times = 4;
    99
    10   assert(cvec_norm_get_data(complex_vector) == complex_vector->norm);
    11   assert(cvec_phas_get_data(complex_vector) == complex_vector->phas);
    12   assert(complex_vector->length == window_size / 2 + 1);
     10  utils_init_random();
    1311
    14   // all elements are initialized to 0
     12  while (rand_times -- ) {
     13    // fill with random phas and norm
     14    for ( i = 0; i < complex_vector->length; i++ ) {
     15      complex_vector->norm[i] = ( 2. / RAND_MAX * random() - 1. );
     16      complex_vector->phas[i] = ( 2. / RAND_MAX * random() - 1. ) * M_PI;
     17    }
     18    // print the vector
     19    cvec_print(complex_vector);
     20  }
     21
     22  // set all vector elements to `0`
     23  cvec_norm_zeros(complex_vector);
    1524  for ( i = 0; i < complex_vector->length; i++ ) {
    1625    assert( complex_vector->norm[i] == 0. );
    17     assert( complex_vector->phas[i] == 0. );
     26    // assert( complex_vector->phas[i] == 0 );
    1827  }
    19 
    20   cvec_norm_set_sample(complex_vector, 2., 1);
    21   assert(cvec_norm_get_sample(complex_vector, 1));
    22 
    23   cvec_phas_set_sample(complex_vector, 2., 1);
    24   assert(cvec_phas_get_sample(complex_vector, 1));
    25 
    2628  cvec_print(complex_vector);
    2729
    28   // set all norm and phas elements to 0
    29   cvec_zeros(complex_vector);
    30   for ( i = 0; i < complex_vector->length; i++ ) {
    31     assert( complex_vector->norm[i] == 0. );
    32     assert( complex_vector->phas[i] == 0. );
    33   }
    34 
    35   // set all norm elements to 1
     30  // set all vector elements to `1`
    3631  cvec_norm_ones(complex_vector);
    3732  for ( i = 0; i < complex_vector->length; i++ ) {
    3833    assert( complex_vector->norm[i] == 1. );
     34    // assert( complex_vector->phas[i] == 0 );
    3935  }
     36  cvec_print(complex_vector);
    4037
    41   // set all norm elements to 0
     38  cvec_zeros(complex_vector);
     39  cvec_phas_zeros(complex_vector);
    4240  cvec_norm_zeros(complex_vector);
    43   for ( i = 0; i < complex_vector->length; i++ ) {
    44     assert( complex_vector->norm[i] == 0. );
    45   }
     41  cvec_norm_ones(complex_vector);
     42  cvec_phas_ones(complex_vector);
     43  cvec_copy(complex_vector, complex_vector);
    4644
    47   // set all phas elements to 1
    48   cvec_phas_ones(complex_vector);
    49   for ( i = 0; i < complex_vector->length; i++ ) {
    50     assert( complex_vector->phas[i] == 1. );
    51   }
    52 
    53   // set all phas elements to 0
    54   cvec_phas_zeros(complex_vector);
    55   for ( i = 0; i < complex_vector->length; i++ ) {
    56     assert( complex_vector->phas[i] == 0. );
    57   }
    58 
    59   cvec_copy(complex_vector, other_cvector);
    60   // copy to self
    61   cvec_copy(complex_vector, complex_vector);
    62   // copy to a different size fails
    63   del_cvec(other_cvector);
    64   other_cvector = new_cvec(window_size + 2);
    65   cvec_copy(complex_vector, other_cvector);
    66 
    67   if (complex_vector)
    68     del_cvec(complex_vector);
    69   if (other_cvector)
    70     del_cvec(other_cvector);
    71 
    72   // wrong parameters
    73   assert(new_cvec(-1) == NULL);
    74   assert(new_cvec(0) == NULL);
    75 
     45  // destroy it
     46  del_cvec(complex_vector);
    7647  return 0;
    7748}
  • tests/src/test-fmat.c

    r4cb2d54 r00c9444  
    55// and j the column.
    66
    7 void assert_fmat_all_equal(fmat_t *mat, smpl_t scalar)
     7int main (void)
    88{
    9   uint_t i, j;
     9  uint_t height = 3, length = 9, i, j;
     10  // create fmat_t object
     11  fmat_t * mat = new_fmat (height, length);
    1012  for ( i = 0; i < mat->height; i++ ) {
    1113    for ( j = 0; j < mat->length; j++ ) {
    12       assert(mat->data[i][j] == scalar);
    13     }
    14   }
    15 }
    16 
    17 int main (void)
    18 {
    19   uint_t i, j;
    20   uint_t height = 3, length = 9;
    21 
    22   // create fmat_t object
    23   fmat_t * mat = new_fmat(height, length);
    24   fmat_t * other_mat = new_fmat(height, length);
    25 
    26   assert(mat);
    27   assert(other_mat);
    28 
    29   assert(mat->length == length);
    30   assert(mat->height == height);
    31 
    32   for (i = 0; i < mat->height; i++) {
    33     for (j = 0; j < mat->length; j++) {
    3414      // all elements are already initialized to 0.
    3515      assert(mat->data[i][j] == 0);
    3616      // setting element of row i, column j
    37       mat->data[i][j] = i * 10. + j;
     17      mat->data[i][j] = i * 1. + j *.1;
    3818    }
    3919  }
    40 
    41   // print out matrix
    42   fmat_print(mat);
    43 
    44   // helpers
    45   fmat_rev(mat);
    46   fmat_print(mat);
    47   for (i = 0; i < mat->height; i++) {
    48     for (j = 0; j < mat->length; j++) {
    49       assert(mat->data[i][j] == i * 10. + mat->length - 1. - j);
    50     }
    51   }
    52 
    53   fmat_set_sample(mat, 3, 1, 1);
    54   assert(fmat_get_sample(mat, 1, 1) == 3.);
    55 
    56   fmat_ones(mat);
    57   assert_fmat_all_equal(mat, 1.);
    58 
    59   fmat_set(other_mat, .5);
    60   assert_fmat_all_equal(other_mat, .5);
    61 
    62   fmat_weight(mat, other_mat);
    63   assert_fmat_all_equal(mat, .5);
    64 
    6520  fvec_t channel_onstack;
    6621  fvec_t *channel = &channel_onstack;
    6722  fmat_get_channel(mat, 1, channel);
    68   assert(channel->data == mat->data[1]);
    69 
    70   // copy of the same size
    71   fmat_copy(mat, other_mat);
    72   del_fmat(other_mat);
    73 
    74   // copy to undersized
    75   other_mat = new_fmat(height - 1, length);
    76   fmat_copy(mat, other_mat);
    77   del_fmat(other_mat);
    78 
    79   // copy from undersized
    80   other_mat = new_fmat(height, length + 1);
    81   fmat_copy(mat, other_mat);
    82 
    83   // wrong parameters
    84   assert(new_fmat(-1, length) == NULL);
    85   assert(new_fmat(height, -1) == NULL);
    86 
    87   // methods for wrappers with opaque structure
    88   assert (fmat_get_channel_data(mat, 0) == mat->data[0]);
    89   assert (fmat_get_data(mat) == mat->data);
    90 
    91   if (mat)
    92     del_fmat(mat);
    93   if (other_mat)
    94     del_fmat(other_mat);
     23  fvec_print (channel);
     24  // print out matrix
     25  fmat_print(mat);
     26  // destroy it
     27  del_fmat(mat);
    9528  return 0;
    9629}
     30
  • tests/src/test-fvec.c

    r4cb2d54 r00c9444  
    22#include "utils_tests.h"
    33
    4 void assert_fvec_all_equal(fvec_t *vec, smpl_t scalar)
    5 {
    6   uint_t i;
    7   for (i = 0; i < vec->length; i++) {
    8     assert(vec->data[i] == scalar);
    9   }
    10 }
    11 
    124int main (void)
    135{
    14   uint_t length = 10;
    15   uint_t i;
    16 
    17   fvec_t * vec = new_fvec (length);
    18   fvec_t * other_vec = new_fvec (length);
    19 
    20   assert (vec);
    21   assert (other_vec);
     6  uint_t vec_size = 10, i;
     7  fvec_t * vec = new_fvec (vec_size);
    228
    239  // vec->length matches requested size
    24   assert(vec->length == length);
     10  assert(vec->length == vec_size);
    2511
    2612  // all elements are initialized to `0.`
     
    2915  }
    3016
     17  // all elements can be set to `0.`
     18  fvec_zeros(vec);
     19  for ( i = 0; i < vec->length; i++ ) {
     20    assert(vec->data[i] == 0.);
     21  }
     22  fvec_print(vec);
     23
    3124  // all elements can be set to `1.`
    3225  fvec_ones(vec);
    33   assert_fvec_all_equal(vec, 1.);
    34 
    35   // all elements can be set to `0.`
    36   fvec_zeros(vec);
    37   assert_fvec_all_equal(vec, 0.);
     26  for ( i = 0; i < vec->length; i++ ) {
     27    assert(vec->data[i] == 1.);
     28  }
     29  fvec_print(vec);
    3830
    3931  // each element can be accessed directly
     
    4436  fvec_print(vec);
    4537
    46   fvec_set_sample(vec, 3, 2);
    47   assert(fvec_get_sample(vec, 2) == 3);
     38  // now destroys the vector
     39  del_fvec(vec);
    4840
    49   assert(fvec_get_data(vec) == vec->data);
    50 
    51   // wrong parameters
    52   assert(new_fvec(-1) == NULL);
    53 
    54   // copy to an identical size works
    55   fvec_copy(vec, other_vec);
    56   del_fvec(other_vec);
    57 
    58   // copy to a different size fail
    59   other_vec = new_fvec(length + 1);
    60   fvec_copy(vec, other_vec);
    61   del_fvec(other_vec);
    62 
    63   // copy to a different size fail
    64   other_vec = new_fvec(length - 1);
    65   fvec_copy(vec, other_vec);
    66 
    67   // now destroys the vector
    68   if (vec)
    69     del_fvec(vec);
    70   if (other_vec)
    71     del_fvec(other_vec);
    7241  return 0;
    7342}
     43
  • tests/src/test-lvec.c

    r4cb2d54 r00c9444  
    22#include "utils_tests.h"
    33
    4 void assert_lvec_all_equal(lvec_t *vec, lsmp_t scalar)
     4int main (void)
    55{
    6   uint_t i;
    7   for (i = 0; i < vec->length; i++) {
    8     assert(vec->data[i] == scalar);
    9   }
     6  uint_t win_s = 32; // window size
     7  lvec_t * sp = new_lvec (win_s); // input buffer
     8  lvec_set_sample (sp, 2./3., 0);
     9  PRINT_MSG(AUBIO_LSMP_FMT "\n", lvec_get_sample (sp, 0));
     10  lvec_print (sp);
     11  lvec_ones (sp);
     12  lvec_print (sp);
     13  lvec_set_all (sp, 3./5.);
     14  lvec_print (sp);
     15  del_lvec(sp);
     16  return 0;
    1017}
    1118
    12 int main (void)
    13 {
    14   uint_t length = 32; // window size
    15 
    16   lvec_t * vec = new_lvec (length); // input buffer
    17 
    18   assert(vec);
    19 
    20   assert(vec->length == length);
    21 
    22   lvec_set_sample (vec, 3., 0);
    23   assert(lvec_get_sample(vec, 0) == 3.);
    24 
    25   assert(lvec_get_data(vec) == vec->data);
    26 
    27   lvec_print (vec);
    28   // note AUBIO_LSMP_FMT can be used to print lsmp_t
    29   PRINT_MSG(AUBIO_LSMP_FMT "\n", lvec_get_sample (vec, 0));
    30 
    31   lvec_set_all (vec, 2.);
    32   assert_lvec_all_equal(vec, 2.);
    33 
    34   lvec_ones (vec);
    35   assert_lvec_all_equal(vec, 1.);
    36 
    37   lvec_zeros (vec);
    38   assert_lvec_all_equal(vec, 0.);
    39 
    40   del_lvec(vec);
    41 
    42   // wrong parameters
    43   assert(new_lvec(0) == NULL);
    44   assert(new_lvec(-1) == NULL);
    45 
    46   return 0;
    47 }
  • tests/src/test-mathutils-window.c

    r4cb2d54 r00c9444  
    88  uint_t lengths[4] = { 8, 10, 15, 16 };
    99  char *method = "default";
    10   char *window_types[11] = { "default",
    11     "ones", "rectangle", "hamming", "hanning", "hanningz",
     10  char *window_types[10] = { "default",
     11    "rectangle", "hamming", "hanning", "hanningz",
    1212    "blackman", "blackman_harris", "gaussian", "welch", "parzen"};
    1313
     
    2727    }
    2828  }
    29 
    30   assert (new_aubio_window("parzen", -1) == NULL);
    31   assert (new_aubio_window(NULL, length) == NULL);
    32   assert (new_aubio_window("\0", length) == NULL);
    3329  return 0;
    3430}
  • wscript

    r4cb2d54 r00c9444  
    438438    # check for vorbisenc
    439439    if (ctx.options.enable_vorbis != False):
    440         ctx.check_cfg(package = 'vorbisenc vorbis ogg',
     440        ctx.check_cfg(package = 'vorbisenc',
    441441                args = '--cflags --libs',
    442442                uselib_store = 'VORBISENC',
Note: See TracChangeset for help on using the changeset viewer.