Changeset a95b386


Ignore:
Timestamp:
Nov 17, 2018, 4:38:29 PM (8 months ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/autosink, feature/constantq, feature/pitchshift, feature/timestretch, master
Children:
ab8e838
Parents:
75f9fff (diff), 2eb52bd (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 'master' into feature/pytest

Files:
3 added
21 edited

Legend:

Unmodified
Added
Removed
  • Makefile

    r75f9fff ra95b386  
    232232        uninstall_python \
    233233        check_clean_python
     234
     235coverage_cycle: coverage_zero_counters coverage_report
     236
     237coverage_zero_counters:
     238        lcov --zerocounters --directory .
    234239
    235240coverage: export CFLAGS=--coverage
     
    245250        lcov -a build/coverage_python.info -a build/coverage_lib.info -o build/coverage.info
    246251
     252# make sure we don't build the doc, which builds a temporary python module
     253coverage_report: export WAFOPTS += --disable-docs
    247254coverage_report: coverage
    248255        genhtml build/coverage.info --output-directory lcov_html
  • doc/py_utils.rst

    r75f9fff ra95b386  
    2828
    2929.. autofunction:: miditofreq
     30
     31.. python/ext/py-musicutils.h
     32
     33.. autofunction:: meltohz
     34
     35.. autofunction:: hztomel
    3036
    3137.. python/ext/aubiomodule.c
  • python/ext/aubiomodule.c

    r75f9fff ra95b386  
    373373  {"shift", Py_aubio_shift, METH_VARARGS, Py_aubio_shift_doc},
    374374  {"ishift", Py_aubio_ishift, METH_VARARGS, Py_aubio_ishift_doc},
     375  {"hztomel", Py_aubio_hztomel, METH_VARARGS|METH_KEYWORDS, Py_aubio_hztomel_doc},
     376  {"meltohz", Py_aubio_meltohz, METH_VARARGS|METH_KEYWORDS, Py_aubio_meltohz_doc},
     377  {"hztomel_htk", Py_aubio_hztomel_htk, METH_VARARGS, Py_aubio_hztomel_htk_doc},
     378  {"meltohz_htk", Py_aubio_meltohz_htk, METH_VARARGS, Py_aubio_meltohz_htk_doc},
    375379  {NULL, NULL, 0, NULL} /* Sentinel */
    376380};
  • python/ext/py-filterbank.c

    r75f9fff ra95b386  
    139139      &(self->freqs), samplerate);
    140140  if (err > 0) {
    141     PyErr_SetString (PyExc_ValueError,
    142         "error when running set_triangle_bands");
     141    if (PyErr_Occurred() == NULL) {
     142      PyErr_SetString (PyExc_ValueError, "error running set_triangle_bands");
     143    } else {
     144      // change the RuntimeError into ValueError
     145      PyObject *type, *value, *traceback;
     146      PyErr_Fetch(&type, &value, &traceback);
     147      PyErr_Restore(PyExc_ValueError, value, traceback);
     148    }
    143149    return NULL;
    144150  }
     
    151157  uint_t err = 0;
    152158
    153   uint_t samplerate;
    154   if (!PyArg_ParseTuple (args, "I", &samplerate)) {
     159  smpl_t samplerate;
     160  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR, &samplerate)) {
    155161    return NULL;
    156162  }
     
    158164  err = aubio_filterbank_set_mel_coeffs_slaney (self->o, samplerate);
    159165  if (err > 0) {
    160     PyErr_SetString (PyExc_ValueError,
    161         "error when running set_mel_coeffs_slaney");
     166    if (PyErr_Occurred() == NULL) {
     167      PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs_slaney");
     168    } else {
     169      // change the RuntimeError into ValueError
     170      PyObject *type, *value, *traceback;
     171      PyErr_Fetch(&type, &value, &traceback);
     172      PyErr_Restore(PyExc_ValueError, value, traceback);
     173    }
     174    return NULL;
     175  }
     176  Py_RETURN_NONE;
     177}
     178
     179static PyObject *
     180Py_filterbank_set_mel_coeffs (Py_filterbank * self, PyObject *args)
     181{
     182  uint_t err = 0;
     183
     184  smpl_t samplerate;
     185  smpl_t freq_min;
     186  smpl_t freq_max;
     187  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR
     188        AUBIO_NPY_SMPL_CHR, &samplerate, &freq_min, &freq_max)) {
     189    return NULL;
     190  }
     191
     192  err = aubio_filterbank_set_mel_coeffs (self->o, samplerate,
     193      freq_min, freq_max);
     194  if (err > 0) {
     195    if (PyErr_Occurred() == NULL) {
     196      PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs");
     197    } else {
     198      // change the RuntimeError into ValueError
     199      PyObject *type, *value, *traceback;
     200      PyErr_Fetch(&type, &value, &traceback);
     201      PyErr_Restore(PyExc_ValueError, value, traceback);
     202    }
     203    return NULL;
     204  }
     205  Py_RETURN_NONE;
     206}
     207
     208static PyObject *
     209Py_filterbank_set_mel_coeffs_htk (Py_filterbank * self, PyObject *args)
     210{
     211  uint_t err = 0;
     212
     213  smpl_t samplerate;
     214  smpl_t freq_min;
     215  smpl_t freq_max;
     216  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR
     217        AUBIO_NPY_SMPL_CHR, &samplerate, &freq_min, &freq_max)) {
     218    return NULL;
     219  }
     220
     221  err = aubio_filterbank_set_mel_coeffs_htk (self->o, samplerate,
     222      freq_min, freq_max);
     223  if (err > 0) {
     224    if (PyErr_Occurred() == NULL) {
     225      PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs_htk");
     226    } else {
     227      // change the RuntimeError into ValueError
     228      PyObject *type, *value, *traceback;
     229      PyErr_Fetch(&type, &value, &traceback);
     230      PyErr_Restore(PyExc_ValueError, value, traceback);
     231    }
    162232    return NULL;
    163233  }
     
    194264  return (PyObject *)PyAubio_CFmatToArray(
    195265      aubio_filterbank_get_coeffs (self->o) );
     266}
     267
     268static PyObject *
     269Py_filterbank_set_power(Py_filterbank *self, PyObject *args)
     270{
     271  uint_t power;
     272
     273  if (!PyArg_ParseTuple (args, "I", &power)) {
     274    return NULL;
     275  }
     276  if(aubio_filterbank_set_power (self->o, power)) {
     277    if (PyErr_Occurred() == NULL) {
     278      PyErr_SetString (PyExc_ValueError,
     279          "error running filterbank.set_power");
     280    } else {
     281      // change the RuntimeError into ValueError
     282      PyObject *type, *value, *traceback;
     283      PyErr_Fetch(&type, &value, &traceback);
     284      PyErr_Restore(PyExc_ValueError, value, traceback);
     285    }
     286    return NULL;
     287  }
     288  Py_RETURN_NONE;
     289}
     290
     291static PyObject *
     292Py_filterbank_set_norm(Py_filterbank *self, PyObject *args)
     293{
     294  uint_t playing;
     295
     296  if (!PyArg_ParseTuple (args, "I", &playing)) {
     297    return NULL;
     298  }
     299  if(aubio_filterbank_set_norm (self->o, playing)) {
     300    if (PyErr_Occurred() == NULL) {
     301      PyErr_SetString (PyExc_ValueError,
     302          "error running filterbank.set_power");
     303    } else {
     304      // change the RuntimeError into ValueError
     305      PyObject *type, *value, *traceback;
     306      PyErr_Fetch(&type, &value, &traceback);
     307      PyErr_Restore(PyExc_ValueError, value, traceback);
     308    }
     309    return NULL;
     310  }
     311  Py_RETURN_NONE;
    196312}
    197313
     
    201317  {"set_mel_coeffs_slaney", (PyCFunction) Py_filterbank_set_mel_coeffs_slaney,
    202318    METH_VARARGS, "set coefficients of filterbank as in Auditory Toolbox"},
     319  {"set_mel_coeffs", (PyCFunction) Py_filterbank_set_mel_coeffs,
     320    METH_VARARGS, "set coefficients of filterbank to linearly spaced mel scale"},
     321  {"set_mel_coeffs_htk", (PyCFunction) Py_filterbank_set_mel_coeffs_htk,
     322    METH_VARARGS, "set coefficients of filterbank to linearly spaced mel scale"},
    203323  {"get_coeffs", (PyCFunction) Py_filterbank_get_coeffs,
    204324    METH_NOARGS, "get coefficients of filterbank"},
    205325  {"set_coeffs", (PyCFunction) Py_filterbank_set_coeffs,
    206326    METH_VARARGS, "set coefficients of filterbank"},
     327  {"set_power", (PyCFunction) Py_filterbank_set_power,
     328    METH_VARARGS, "set power applied to filterbank input spectrum"},
     329  {"set_norm", (PyCFunction) Py_filterbank_set_norm,
     330    METH_VARARGS, "set norm applied to filterbank input spectrum"},
    207331  {NULL}
    208332};
  • python/ext/py-musicutils.c

    r75f9fff ra95b386  
    182182  return (PyObject *) PyAubio_CFvecToArray(&vec);
    183183}
     184
     185PyObject*
     186Py_aubio_hztomel(PyObject *self, PyObject *args, PyObject *kwds)
     187{
     188  smpl_t v;
     189  PyObject *htk = NULL;
     190  static char *kwlist[] = {"f", "htk", NULL};
     191  if (!PyArg_ParseTupleAndKeywords(args, kwds, AUBIO_NPY_SMPL_CHR "|O",
     192        kwlist, &v, &htk))
     193  {
     194    return NULL;
     195  }
     196  if (htk != NULL && PyObject_IsTrue(htk) == 1)
     197    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel_htk(v));
     198  else
     199    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel(v));
     200}
     201
     202PyObject*
     203Py_aubio_meltohz(PyObject *self, PyObject *args, PyObject *kwds)
     204{
     205  smpl_t v;
     206  PyObject *htk = NULL;
     207  static char *kwlist[] = {"m", "htk", NULL};
     208  if (!PyArg_ParseTupleAndKeywords(args, kwds, AUBIO_NPY_SMPL_CHR "|O",
     209        kwlist, &v, &htk))
     210  {
     211    return NULL;
     212  }
     213  if (htk != NULL && PyObject_IsTrue(htk) == 1)
     214    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz_htk(v));
     215  else
     216    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz(v));
     217}
     218
     219PyObject*
     220Py_aubio_hztomel_htk(PyObject *self, PyObject *args)
     221{
     222  smpl_t v;
     223  if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {
     224    return NULL;
     225  }
     226  return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel_htk(v));
     227}
     228
     229PyObject*
     230Py_aubio_meltohz_htk(PyObject *self, PyObject *args)
     231{
     232  smpl_t v;
     233  if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {
     234    return NULL;
     235  }
     236  return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz_htk(v));
     237}
  • python/ext/py-musicutils.h

    r75f9fff ra95b386  
    301301PyObject * Py_aubio_ishift(PyObject *self, PyObject *args);
    302302
     303static char Py_aubio_hztomel_doc[] = ""
     304"hztomel(f, htk=False)\n"
     305"\n"
     306"Convert a scalar from frequency to mel scale.\n"
     307"\n"
     308"Parameters\n"
     309"----------\n"
     310"m : float\n"
     311"   input frequency, in Hz\n"
     312"htk : bool\n"
     313"   if `True`, use Htk mel scale instead of Slaney.\n"
     314"\n"
     315"Returns\n"
     316"-------\n"
     317"float\n"
     318"   output mel\n"
     319"\n"
     320"See Also\n"
     321"--------\n"
     322"meltohz\n"
     323"";
     324PyObject * Py_aubio_hztomel(PyObject *self, PyObject *args);
     325
     326static char Py_aubio_meltohz_doc[] = ""
     327"meltohz(m, htk=False)\n"
     328"\n"
     329"Convert a scalar from mel scale to frequency.\n"
     330"\n"
     331"Parameters\n"
     332"----------\n"
     333"m : float\n"
     334"   input mel\n"
     335"htk : bool\n"
     336"   if `True`, use Htk mel scale instead of Slaney.\n"
     337"\n"
     338"Returns\n"
     339"-------\n"
     340"float\n"
     341"   output frequency, in Hz\n"
     342"\n"
     343"See Also\n"
     344"--------\n"
     345"hztomel\n"
     346"";
     347PyObject * Py_aubio_meltohz(PyObject *self, PyObject *args);
     348
     349static char Py_aubio_hztomel_htk_doc[] = ""
     350"hztomel_htk(m)\n"
     351"\n"
     352"Same as `hztomel(m, htk=True)`\n"
     353"\n"
     354"See Also\n"
     355"--------\n"
     356"hztomel\n"
     357"";
     358PyObject * Py_aubio_hztomel_htk(PyObject *self, PyObject *args);
     359
     360static char Py_aubio_meltohz_htk_doc[] = ""
     361"meltohz_htk(m)\n"
     362"\n"
     363"Same as `meltohz(m, htk=True)`\n"
     364"\n"
     365"See Also\n"
     366"--------\n"
     367"meltohz\n"
     368"";
     369PyObject * Py_aubio_meltohz_htk(PyObject *self, PyObject *args);
     370
    303371#endif /* PY_AUBIO_MUSICUTILS_H */
  • python/lib/gen_code.py

    r75f9fff ra95b386  
    463463""".format(**self.__dict__)
    464464        for set_param in self.prototypes['set']:
    465             params = get_params_types_names(set_param)[1]
    466             paramtype = params['type']
     465            params = get_params_types_names(set_param)[1:]
     466            param = self.shortname.split('_set_')[-1]
     467            paramdecls = "".join(["""
     468   {0} {1};""".format(p['type'], p['name']) for p in params])
    467469            method_name = get_name(set_param)
    468470            param = method_name.split('aubio_'+self.shortname+'_set_')[-1]
    469             pyparamtype = pyargparse_chars[paramtype]
     471            refs = ", ".join(["&%s" % p['name'] for p in params])
     472            paramlist = ", ".join(["%s" % p['name'] for p in params])
     473            if len(params):
     474                paramlist = "," + paramlist
     475            pyparamtypes = ''.join([pyargparse_chars[p['type']] for p in params])
    470476            out += """
    471477static PyObject *
     
    473479{{
    474480  uint_t err = 0;
    475   {paramtype} {param};
    476 
    477   if (!PyArg_ParseTuple (args, "{pyparamtype}", &{param})) {{
     481  {paramdecls}
     482""".format(param = param, paramdecls = paramdecls, **self.__dict__)
     483
     484            if len(refs) and len(pyparamtypes):
     485                out += """
     486
     487  if (!PyArg_ParseTuple (args, "{pyparamtypes}", {refs})) {{
    478488    return NULL;
    479489  }}
    480   err = aubio_{shortname}_set_{param} (self->o, {param});
     490""".format(pyparamtypes = pyparamtypes, refs = refs)
     491
     492            out += """
     493  err = aubio_{shortname}_set_{param} (self->o {paramlist});
    481494
    482495  if (err > 0) {{
     
    493506  Py_RETURN_NONE;
    494507}}
    495 """.format(param = param, paramtype = paramtype, pyparamtype = pyparamtype, **self.__dict__)
     508""".format(param = param, refs = refs, paramdecls = paramdecls,
     509        pyparamtypes = pyparamtypes, paramlist = paramlist, **self.__dict__)
    496510        return out
    497511
  • python/tests/test_fft.py

    r75f9fff ra95b386  
    142142        assert_almost_equal ( r[1:], 0)
    143143
     144class aubio_fft_odd_sizes(TestCase):
     145
     146    def test_reconstruct_with_odd_size(self):
     147        win_s = 29
     148        self.recontruct(win_s, 'odd sizes not supported')
     149
     150    def test_reconstruct_with_radix15(self):
     151        win_s = 2 ** 4 * 15
     152        self.recontruct(win_s, 'radix 15 supported')
     153
     154    def test_reconstruct_with_radix5(self):
     155        win_s = 2 ** 4 * 5
     156        self.recontruct(win_s, 'radix 5 supported')
     157
     158    def test_reconstruct_with_radix3(self):
     159        win_s = 2 ** 4 * 3
     160        self.recontruct(win_s, 'radix 3 supported')
     161
     162    def recontruct(self, win_s, skipMessage):
     163        try:
     164            f = fft(win_s)
     165        except RuntimeError:
     166            self.skipTest(skipMessage)
     167        input_signal = fvec(win_s)
     168        input_signal[win_s//2] = 1
     169        c = f(input_signal)
     170        output_signal = f.rdo(c)
     171        assert_almost_equal(input_signal, output_signal)
     172
     173class aubio_fft_wrong_params(TestCase):
     174
    144175    def test_large_input_timegrain(self):
    145176        win_s = 1024
     
    169200        with self.assertRaises(ValueError):
    170201            f.rdo(s)
    171 
    172 class aubio_fft_wrong_params(TestCase):
    173202
    174203    def test_wrong_buf_size(self):
     
    176205        with self.assertRaises(ValueError):
    177206            fft(win_s)
    178 
    179     def test_buf_size_not_power_of_two(self):
    180         # when compiled with fftw3, aubio supports non power of two fft sizes
    181         win_s = 320
    182         try:
    183             with self.assertRaises(RuntimeError):
    184                 fft(win_s)
    185         except AssertionError:
    186             self.skipTest('creating aubio.fft with size %d did not fail' % win_s)
    187207
    188208    def test_buf_size_too_small(self):
  • python/tests/test_filterbank_mel.py

    r75f9fff ra95b386  
    110110
    111111
     112    def test_triangle_freqs_without_norm(self):
     113        """make sure set_triangle_bands works without """
     114        samplerate = 22050
     115        freq_list = fvec([0, 100, 1000, 10000])
     116        f = filterbank(len(freq_list) - 2, 1024)
     117        f.set_norm(0)
     118        f.set_triangle_bands(freq_list, samplerate)
     119        expected = f.get_coeffs()
     120        f.set_norm(1)
     121        f.set_triangle_bands(fvec(freq_list), samplerate)
     122        assert_almost_equal(f.get_coeffs().T,
     123                expected.T * 2. / (freq_list[2:] - freq_list[:-2]))
     124
     125    def test_triangle_freqs_wrong_norm(self):
     126        f = filterbank(10, 1024)
     127        with self.assertRaises(ValueError):
     128            f.set_norm(-1)
     129
     130    def test_triangle_freqs_with_power(self):
     131        f = filterbank(9, 1024)
     132        freqs = fvec([40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000,
     133            24000])
     134        f.set_power(2)
     135        f.set_triangle_bands(freqs, 48000)
     136        spec = cvec(1024)
     137        spec.norm[:] = .1
     138        expected = fvec([0.02070313, 0.02138672, 0.02127604, 0.02135417,
     139            0.02133301, 0.02133301, 0.02133311, 0.02133334, 0.02133345])
     140        expected /= 100.
     141        assert_almost_equal(f(spec), expected)
     142
     143    def test_mel_coeffs(self):
     144        f = filterbank(40, 1024)
     145        f.set_mel_coeffs(44100, 0, 44100 / 2)
     146
     147    def test_zero_fmax(self):
     148        f = filterbank(40, 1024)
     149        f.set_mel_coeffs(44100, 0, 0)
     150
     151    def test_wrong_mel_coeffs(self):
     152        f = filterbank(40, 1024)
     153        with self.assertRaises(ValueError):
     154            f.set_mel_coeffs_slaney(0)
     155        with self.assertRaises(ValueError):
     156            f.set_mel_coeffs(44100, 0, -44100 / 2)
     157        with self.assertRaises(ValueError):
     158            f.set_mel_coeffs(44100, -0.1, 44100 / 2)
     159        with self.assertRaises(ValueError):
     160            f.set_mel_coeffs(-44100, 0.1, 44100 / 2)
     161        with self.assertRaises(ValueError):
     162            f.set_mel_coeffs_htk(-1, 0, 0)
     163
     164    def test_mel_coeffs_htk(self):
     165        f = filterbank(40, 1024)
     166        f.set_mel_coeffs_htk(44100, 0, 44100 / 2)
     167
     168
    112169if __name__ == '__main__':
    113170    from unittest import main
  • src/io/source_avcodec.c

    r75f9fff ra95b386  
    9090  sint_t selected_stream;
    9191  uint_t eof;
    92   uint_t multi;
    9392};
    9493
    9594// create or re-create the context when _do or _do_multi is called
    96 void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
    97     uint_t multi);
     95void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s);
    9896// actually read a frame
    9997void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
     
    285283  s->avFrame = avFrame;
    286284
    287   // default to mono output
    288   aubio_source_avcodec_reset_resampler(s, 0);
     285  aubio_source_avcodec_reset_resampler(s);
    289286
    290287  if (s->avr == NULL) goto beach;
    291288
    292289  s->eof = 0;
    293   s->multi = 0;
    294290
    295291  //av_log_set_level(AV_LOG_QUIET);
     
    304300}
    305301
    306 void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
    307     uint_t multi)
     302void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s)
    308303{
    309304  // create or reset resampler to/from mono/multi-channel
    310   if ( (multi != s->multi) || (s->avr == NULL) ) {
     305  if ( s->avr == NULL ) {
    311306    int err;
    312307    int64_t input_layout = av_get_default_channel_layout(s->input_channels);
    313     uint_t output_channels = multi ? s->input_channels : 1;
    314     int64_t output_layout = av_get_default_channel_layout(output_channels);
     308    int64_t output_layout = av_get_default_channel_layout(s->input_channels);
    315309#ifdef HAVE_AVRESAMPLE
    316310    AVAudioResampleContext *avr = avresample_alloc_context();
    317     AVAudioResampleContext *oldavr = s->avr;
    318311#elif defined(HAVE_SWRESAMPLE)
    319312    SwrContext *avr = swr_alloc();
    320     SwrContext *oldavr = s->avr;
    321313#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
    322314
     
    346338    }
    347339    s->avr = avr;
    348     if (oldavr != NULL) {
    349 #ifdef HAVE_AVRESAMPLE
    350       avresample_close( oldavr );
    351 #elif defined(HAVE_SWRESAMPLE)
    352       swr_close ( oldavr );
    353 #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
    354       av_free ( oldavr );
    355       oldavr = NULL;
    356     }
    357     s->multi = multi;
    358340  }
    359341}
     
    496478void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data,
    497479    uint_t * read) {
    498   uint_t i;
     480  uint_t i, j;
    499481  uint_t end = 0;
    500482  uint_t total_wrote = 0;
    501   // switch from multi
    502   if (s->multi == 1) aubio_source_avcodec_reset_resampler(s, 0);
    503483  while (total_wrote < s->hop_size) {
    504484    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
    505485    for (i = 0; i < end; i++) {
    506       read_data->data[i + total_wrote] = s->output[i + s->read_index];
     486      read_data->data[i + total_wrote] = 0.;
     487      for (j = 0; j < s->input_channels; j++) {
     488        read_data->data[i + total_wrote] +=
     489          s->output[(i + s->read_index) * s->input_channels + j];
     490      }
     491      read_data->data[i + total_wrote] *= 1./s->input_channels;
    507492    }
    508493    total_wrote += end;
     
    532517  uint_t end = 0;
    533518  uint_t total_wrote = 0;
    534   // switch from mono
    535   if (s->multi == 0) aubio_source_avcodec_reset_resampler(s, 1);
    536519  while (total_wrote < s->hop_size) {
    537520    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
  • src/mathutils.c

    r75f9fff ra95b386  
    388388}
    389389
     390void
     391fvec_mul (fvec_t *o, smpl_t val)
     392{
     393  uint_t j;
     394  for (j = 0; j < o->length; j++) {
     395    o->data[j] *= val;
     396  }
     397}
     398
    390399void fvec_adapt_thres(fvec_t * vec, fvec_t * tmp,
    391400    uint_t post, uint_t pre) {
  • src/mathutils.h

    r75f9fff ra95b386  
    193193*/
    194194void fvec_add (fvec_t * v, smpl_t c);
     195
     196/** multiply each elements of a vector by a scalar
     197
     198  \param v vector to add constant to
     199  \param s constant to scale v with
     200
     201*/
     202void fvec_mul (fvec_t * v, smpl_t s);
    195203
    196204/** remove the minimum value of the vector to each elements
  • src/musicutils.h

    r75f9fff ra95b386  
    8787smpl_t aubio_freqtobin (smpl_t freq, smpl_t samplerate, smpl_t fftsize);
    8888
     89/** convert frequency (Hz) to mel
     90
     91  \param freq input frequency, in Hz
     92
     93  \return output mel
     94
     95  Converts a scalar from the frequency domain to the mel scale using Slaney
     96  Auditory Toolbox's implementation:
     97
     98  If \f$ f < 1000 \f$, \f$ m = 3 f / 200 \f$.
     99
     100  If \f$ f >= 1000 \f$, \f$ m = 1000 + 27 \frac{{ln}(f) - ln(1000))}
     101  {{ln}(6400) - ln(1000)}
     102  \f$
     103
     104  See also
     105  --------
     106
     107  aubio_meltohz(), aubio_hztomel_htk().
     108
     109*/
     110smpl_t aubio_hztomel (smpl_t freq);
     111
     112/** convert mel to frequency (Hz)
     113
     114  \param mel input mel
     115
     116  \return output frequency, in Hz
     117
     118  Converts a scalar from the mel scale to the frequency domain using Slaney
     119  Auditory Toolbox's implementation:
     120
     121  If \f$ f < 1000 \f$, \f$ f = 200 m/3 \f$.
     122
     123  If \f$ f \geq 1000 \f$, \f$ f = 1000 + \left(\frac{6400}{1000}\right)
     124  ^{\frac{m - 1000}{27}} \f$
     125
     126  See also
     127  --------
     128
     129  aubio_hztomel(), aubio_meltohz_htk().
     130
     131  References
     132  ----------
     133
     134  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
     135  https://engineering.purdue.edu/~malcolm/interval/1998-010/
     136
     137*/
     138smpl_t aubio_meltohz (smpl_t mel);
     139
     140/** convert frequency (Hz) to mel
     141
     142  \param freq input frequency, in Hz
     143
     144  \return output mel
     145
     146  Converts a scalar from the frequency domain to the mel scale, using the
     147  equation defined by O'Shaughnessy, as implemented in the HTK speech
     148  recognition toolkit:
     149
     150  \f$ m = 1127 + ln(1 + \frac{f}{700}) \f$
     151
     152  See also
     153  --------
     154
     155  aubio_meltohz_htk(), aubio_hztomel().
     156
     157  References
     158  ----------
     159
     160  Douglas O'Shaughnessy (1987). *Speech communication: human and machine*.
     161  Addison-Wesley. p. 150. ISBN 978-0-201-16520-3.
     162
     163  HTK Speech Recognition Toolkit: http://htk.eng.cam.ac.uk/
     164
     165 */
     166smpl_t aubio_hztomel_htk (smpl_t freq);
     167
     168/** convert mel to frequency (Hz)
     169
     170  \param mel input mel
     171
     172  \return output frequency, in Hz
     173
     174  Converts a scalar from the mel scale to the frequency domain, using the
     175  equation defined by O'Shaughnessy, as implemented in the HTK speech
     176  recognition toolkit:
     177
     178  \f$ f = 700 * {e}^\left(\frac{f}{1127} - 1\right) \f$
     179
     180  See also
     181  --------
     182
     183  aubio_hztomel_htk(), aubio_meltohz().
     184
     185*/
     186smpl_t aubio_meltohz_htk (smpl_t mel);
     187
    89188/** convert frequency (Hz) to midi value (0-128) */
    90189smpl_t aubio_freqtomidi (smpl_t freq);
  • src/spectral/fft.c

    r75f9fff ra95b386  
    9090#define aubio_vDSP_vsadd               vDSP_vsadd
    9191#define aubio_vDSP_vsmul               vDSP_vsmul
    92 #define aubio_vDSP_create_fftsetup     vDSP_create_fftsetup
    93 #define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetup
    9492#define aubio_DSPComplex               DSPComplex
    9593#define aubio_DSPSplitComplex          DSPSplitComplex
    96 #define aubio_FFTSetup                 FFTSetup
     94#define aubio_vDSP_DFT_Setup           vDSP_DFT_Setup
     95#define aubio_vDSP_DFT_zrop_CreateSetup vDSP_DFT_zrop_CreateSetup
     96#define aubio_vDSP_DFT_Execute         vDSP_DFT_Execute
     97#define aubio_vDSP_DFT_DestroySetup    vDSP_DFT_DestroySetup
    9798#define aubio_vvsqrt                   vvsqrtf
    9899#else
     
    104105#define aubio_vDSP_vsadd               vDSP_vsaddD
    105106#define aubio_vDSP_vsmul               vDSP_vsmulD
    106 #define aubio_vDSP_create_fftsetup     vDSP_create_fftsetupD
    107 #define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetupD
    108107#define aubio_DSPComplex               DSPDoubleComplex
    109108#define aubio_DSPSplitComplex          DSPDoubleSplitComplex
    110 #define aubio_FFTSetup                 FFTSetupD
     109#define aubio_vDSP_DFT_Setup           vDSP_DFT_SetupD
     110#define aubio_vDSP_DFT_zrop_CreateSetup vDSP_DFT_zrop_CreateSetupD
     111#define aubio_vDSP_DFT_Execute         vDSP_DFT_ExecuteD
     112#define aubio_vDSP_DFT_DestroySetup    vDSP_DFT_DestroySetupD
    111113#define aubio_vvsqrt                   vvsqrt
    112114#endif /* HAVE_AUBIO_DOUBLE */
     
    153155
    154156#elif defined HAVE_ACCELERATE  // using ACCELERATE
    155   int log2fftsize;
    156   aubio_FFTSetup fftSetup;
     157  aubio_vDSP_DFT_Setup fftSetupFwd;
     158  aubio_vDSP_DFT_Setup fftSetupBwd;
    157159  aubio_DSPSplitComplex spec;
    158160  smpl_t *in, *out;
     
    211213
    212214#elif defined HAVE_ACCELERATE  // using ACCELERATE
     215  {
     216    uint_t radix = winsize;
     217    uint_t order = 0;
     218    while ((radix / 2) * 2 == radix) {
     219      radix /= 2;
     220      order++;
     221    }
     222    if (order < 4 || (radix != 1 && radix != 3 && radix != 5 && radix != 15)) {
     223      AUBIO_ERR("fft: vDSP/Accelerate supports FFT with sizes = "
     224          "f * 2 ** n, where n > 4 and f in [1, 3, 5, 15], but requested %d. "
     225          "Use the closest power of two, or try recompiling aubio with "
     226          "--enable-fftw3.\n", winsize);
     227      goto beach;
     228    }
     229  }
    213230  s->winsize = winsize;
    214231  s->fft_size = winsize;
    215232  s->compspec = new_fvec(winsize);
    216   s->log2fftsize = aubio_power_of_two_order(s->fft_size);
    217233  s->in = AUBIO_ARRAY(smpl_t, s->fft_size);
    218234  s->out = AUBIO_ARRAY(smpl_t, s->fft_size);
    219235  s->spec.realp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
    220236  s->spec.imagp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
    221   s->fftSetup = aubio_vDSP_create_fftsetup(s->log2fftsize, FFT_RADIX2);
     237  s->fftSetupFwd = aubio_vDSP_DFT_zrop_CreateSetup(NULL,
     238      s->fft_size, vDSP_DFT_FORWARD);
     239  s->fftSetupBwd = aubio_vDSP_DFT_zrop_CreateSetup(s->fftSetupFwd,
     240      s->fft_size, vDSP_DFT_INVERSE);
    222241
    223242#elif defined HAVE_INTEL_IPP  // using Intel IPP
     
    293312  AUBIO_FREE(s->spec.realp);
    294313  AUBIO_FREE(s->spec.imagp);
    295   aubio_vDSP_destroy_fftsetup(s->fftSetup);
     314  aubio_vDSP_DFT_DestroySetup(s->fftSetupBwd);
     315  aubio_vDSP_DFT_DestroySetup(s->fftSetupFwd);
    296316
    297317#elif defined HAVE_INTEL_IPP  // using Intel IPP
     
    351371  aubio_vDSP_ctoz((aubio_DSPComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
    352372  // compute the FFT
    353   aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_FORWARD);
     373  aubio_vDSP_DFT_Execute(s->fftSetupFwd, s->spec.realp, s->spec.imagp,
     374      s->spec.realp, s->spec.imagp);
    354375  // convert from vDSP complex split to [ r0, r1, ..., rN, iN-1, .., i2, i1]
    355376  compspec->data[0] = s->spec.realp[0];
     
    419440  aubio_vDSP_ctoz((aubio_DSPComplex*)s->out, 2, &s->spec, 1, s->fft_size/2);
    420441  // compute the FFT
    421   aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_INVERSE);
     442  aubio_vDSP_DFT_Execute(s->fftSetupBwd, s->spec.realp, s->spec.imagp,
     443      s->spec.realp, s->spec.imagp);
    422444  // convert result to real output
    423445  aubio_vDSP_ztoc(&s->spec, 1, (aubio_DSPComplex*)output->data, 2, s->fft_size/2);
     
    494516  }
    495517#endif
    496   if (compspec->data[compspec->length/2] < 0) {
    497     spectrum->phas[spectrum->length - 1] = PI;
     518#ifdef HAVE_FFTW3
     519  // for even length only, make sure last element is 0 or PI
     520  if (2 * (compspec->length / 2) == compspec->length) {
     521#endif
     522    if (compspec->data[compspec->length/2] < 0) {
     523      spectrum->phas[spectrum->length - 1] = PI;
     524    } else {
     525      spectrum->phas[spectrum->length - 1] = 0.;
     526    }
     527#ifdef HAVE_FFTW3
    498528  } else {
    499     spectrum->phas[spectrum->length - 1] = 0.;
    500   }
     529    i = spectrum->length - 1;
     530    spectrum->phas[i] = ATAN2(compspec->data[compspec->length-i],
     531        compspec->data[i]);
     532  }
     533#endif
    501534}
    502535
     
    508541        + SQR(compspec->data[compspec->length - i]) );
    509542  }
    510   spectrum->norm[spectrum->length-1] =
    511     ABS(compspec->data[compspec->length/2]);
     543#ifdef HAVE_FFTW3
     544  // for even length, make sure last element is > 0
     545  if (2 * (compspec->length / 2) == compspec->length) {
     546#endif
     547    spectrum->norm[spectrum->length-1] =
     548      ABS(compspec->data[compspec->length/2]);
     549#ifdef HAVE_FFTW3
     550  } else {
     551    i = spectrum->length - 1;
     552    spectrum->norm[i] = SQRT(SQR(compspec->data[i])
     553        + SQR(compspec->data[compspec->length - i]) );
     554  }
     555#endif
    512556}
    513557
  • src/spectral/filterbank.c

    r75f9fff ra95b386  
    2424#include "fmat.h"
    2525#include "cvec.h"
     26#include "vecutils.h"
    2627#include "spectral/filterbank.h"
    2728#include "mathutils.h"
     
    3334  uint_t n_filters;
    3435  fmat_t *filters;
     36  smpl_t norm;
     37  smpl_t power;
    3538};
    3639
     
    4548  /* allocate filter tables, a matrix of length win_s and of height n_filters */
    4649  fb->filters = new_fmat (n_filters, win_s / 2 + 1);
     50
     51  fb->norm = 1;
     52
     53  fb->power = 1;
    4754
    4855  return fb;
     
    6875  tmp.data = in->norm;
    6976
     77  if (f->power != 1.) fvec_pow(&tmp, f->power);
     78
    7079  fmat_vecmul(f->filters, &tmp, out);
    7180
     
    8594  return 0;
    8695}
     96
     97uint_t
     98aubio_filterbank_set_norm (aubio_filterbank_t *f, smpl_t norm)
     99{
     100  if (norm != 0 && norm != 1) return AUBIO_FAIL;
     101  f->norm = norm;
     102  return AUBIO_OK;
     103}
     104
     105smpl_t
     106aubio_filterbank_get_norm (aubio_filterbank_t *f)
     107{
     108  return f->norm;
     109}
     110
     111uint_t
     112aubio_filterbank_set_power (aubio_filterbank_t *f, smpl_t power)
     113{
     114  f->power = power;
     115  return AUBIO_OK;
     116}
     117
     118smpl_t
     119aubio_filterbank_get_power (aubio_filterbank_t *f)
     120{
     121  return f->norm;
     122}
  • src/spectral/filterbank.h

    r75f9fff ra95b386  
    8484uint_t aubio_filterbank_set_coeffs (aubio_filterbank_t * f, const fmat_t * filters);
    8585
     86/** set norm parameter
     87
     88  \param f filterbank object, as returned by new_aubio_filterbank()
     89  \param norm `1` to norm the filters, `0` otherwise.
     90
     91  If set to `0`, the filters will not be normalized. If set to `1`,
     92  each filter will be normalized to one. Defaults to `1`.
     93
     94  This function should be called *before* setting the filters with one of
     95  aubio_filterbank_set_triangle_bands(), aubio_filterbank_set_mel_coeffs(),
     96  aubio_filterbank_set_mel_coeffs_htk(), or
     97  aubio_filterbank_set_mel_coeffs_slaney().
     98
     99 */
     100uint_t aubio_filterbank_set_norm (aubio_filterbank_t *f, smpl_t norm);
     101
     102/** get norm parameter
     103
     104  \param f filterbank object, as returned by new_aubio_filterbank()
     105  \returns `1` if norm is set, `0` otherwise. Defaults to `1`.
     106
     107 */
     108smpl_t aubio_filterbank_get_norm (aubio_filterbank_t *f);
     109
     110/** set power parameter
     111
     112  \param f filterbank object, as returned by new_aubio_filterbank()
     113  \param power Raise norm of the input spectrum norm to this power before
     114  computing filterbank.  Defaults to `1`.
     115
     116 */
     117uint_t aubio_filterbank_set_power (aubio_filterbank_t *f, smpl_t power);
     118
     119/** get power parameter
     120
     121  \param f filterbank object, as returned by new_aubio_filterbank()
     122  \return current power parameter. Defaults to `1`.
     123
     124 */
     125smpl_t aubio_filterbank_get_power (aubio_filterbank_t *f);
     126
    86127#ifdef __cplusplus
    87128}
  • src/spectral/filterbank_mel.c

    r75f9fff ra95b386  
    9191
    9292  /* compute triangle heights so that each triangle has unit area */
    93   for (fn = 0; fn < n_filters; fn++) {
    94     triangle_heights->data[fn] =
    95         2. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
     93  if (aubio_filterbank_get_norm(fb)) {
     94    for (fn = 0; fn < n_filters; fn++) {
     95      triangle_heights->data[fn] =
     96          2. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
     97    }
     98  } else {
     99    fvec_ones (triangle_heights);
    96100  }
    97101
     
    118122
    119123    /* compute positive slope step size */
    120     riseInc =
    121         triangle_heights->data[fn] /
    122         (center_freqs->data[fn] - lower_freqs->data[fn]);
     124    riseInc = triangle_heights->data[fn]
     125      / (center_freqs->data[fn] - lower_freqs->data[fn]);
    123126
    124127    /* compute coefficients in positive slope */
     
    134137
    135138    /* compute negative slope step size */
    136     downInc =
    137         triangle_heights->data[fn] /
    138         (upper_freqs->data[fn] - center_freqs->data[fn]);
     139    downInc = triangle_heights->data[fn]
     140      / (upper_freqs->data[fn] - center_freqs->data[fn]);
    139141
    140142    /* compute coefficents in negative slope */
     
    169171    smpl_t samplerate)
    170172{
    171   uint_t retval;
    172 
    173173  /* Malcolm Slaney parameters */
    174   smpl_t lowestFrequency = 133.3333;
    175   smpl_t linearSpacing = 66.66666666;
    176   smpl_t logSpacing = 1.0711703;
    177 
    178   uint_t linearFilters = 13;
    179   uint_t logFilters = 27;
    180   uint_t n_filters = linearFilters + logFilters;
    181 
    182   uint_t fn;                    /* filter counter */
    183 
     174  const smpl_t lowestFrequency = 133.3333;
     175  const smpl_t linearSpacing = 66.66666666;
     176  const smpl_t logSpacing = 1.0711703;
     177
     178  const uint_t linearFilters = 13;
     179  const uint_t logFilters = 27;
     180  const uint_t n_filters = linearFilters + logFilters;
     181
     182  uint_t fn, retval;
    184183  smpl_t lastlinearCF;
    185184
    186185  /* buffers to compute filter frequencies */
    187   fvec_t *freqs = new_fvec (n_filters + 2);
     186  fvec_t *freqs;
     187
     188  if (samplerate <= 0) {
     189    AUBIO_ERR("filterbank: set_mel_coeffs_slaney samplerate should be > 0\n");
     190    return AUBIO_FAIL;
     191  }
     192
     193  freqs = new_fvec (n_filters + 2);
    188194
    189195  /* first step: fill all the linear filter frequencies */
     
    207213  return retval;
    208214}
     215
     216static uint_t aubio_filterbank_check_freqs (aubio_filterbank_t *fb UNUSED,
     217    smpl_t samplerate, smpl_t *freq_min, smpl_t *freq_max)
     218{
     219  if (samplerate <= 0) {
     220    AUBIO_ERR("filterbank: set_mel_coeffs samplerate should be > 0\n");
     221    return AUBIO_FAIL;
     222  }
     223  if (*freq_max < 0) {
     224    AUBIO_ERR("filterbank: set_mel_coeffs freq_max should be > 0\n");
     225    return AUBIO_FAIL;
     226  } else if (*freq_max == 0) {
     227    *freq_max = samplerate / 2.;
     228  }
     229  if (*freq_min < 0) {
     230    AUBIO_ERR("filterbank: set_mel_coeffs freq_min should be > 0\n");
     231    return AUBIO_FAIL;
     232  }
     233  return AUBIO_OK;
     234}
     235
     236uint_t
     237aubio_filterbank_set_mel_coeffs (aubio_filterbank_t * fb, smpl_t samplerate,
     238    smpl_t freq_min, smpl_t freq_max)
     239{
     240  uint_t m, retval;
     241  smpl_t start = freq_min, end = freq_max, step;
     242  fvec_t *freqs;
     243  fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
     244  uint_t n_bands = coeffs->height;
     245
     246  if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
     247    return AUBIO_FAIL;
     248  }
     249
     250  start = aubio_hztomel(start);
     251  end = aubio_hztomel(end);
     252
     253  freqs = new_fvec(n_bands + 2);
     254  step = (end - start) / (n_bands + 1);
     255
     256  for (m = 0; m < n_bands + 2; m++)
     257  {
     258    freqs->data[m] = MIN(aubio_meltohz(start + step * m), samplerate/2.);
     259  }
     260
     261  retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
     262
     263  /* destroy vector used to store frequency limits */
     264  del_fvec (freqs);
     265  return retval;
     266}
     267
     268uint_t
     269aubio_filterbank_set_mel_coeffs_htk (aubio_filterbank_t * fb, smpl_t samplerate,
     270    smpl_t freq_min, smpl_t freq_max)
     271{
     272  uint_t m, retval;
     273  smpl_t start = freq_min, end = freq_max, step;
     274  fvec_t *freqs;
     275  fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
     276  uint_t n_bands = coeffs->height;
     277
     278  if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
     279    return AUBIO_FAIL;
     280  }
     281
     282  start = aubio_hztomel_htk(start);
     283  end = aubio_hztomel_htk(end);
     284
     285  freqs = new_fvec (n_bands + 2);
     286  step = (end - start) / (n_bands + 1);
     287
     288  for (m = 0; m < n_bands + 2; m++)
     289  {
     290    freqs->data[m] = MIN(aubio_meltohz_htk(start + step * m), samplerate/2.);
     291  }
     292
     293  retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
     294
     295  /* destroy vector used to store frequency limits */
     296  del_fvec (freqs);
     297  return retval;
     298}
  • src/spectral/filterbank_mel.h

    r75f9fff ra95b386  
    5656
    5757  \param fb filterbank object
    58   \param samplerate audio sampling rate
     58  \param samplerate audio sampling rate, in Hz
    5959
    60   The filter coefficients are built according to Malcolm Slaney's Auditory
    61   Toolbox, available online at the following address (see file mfcc.m):
     60  The filter coefficients are built to match exactly Malcolm Slaney's Auditory
     61  Toolbox implementation (see file mfcc.m). The number of filters should be 40.
    6262
     63  References
     64  ----------
     65
     66  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
    6367  https://engineering.purdue.edu/~malcolm/interval/1998-010/
    6468
     
    6771    smpl_t samplerate);
    6872
     73/** Mel filterbank initialization
     74
     75  \param fb filterbank object
     76  \param samplerate audio sampling rate
     77  \param fmin start frequency, in Hz
     78  \param fmax end frequency, in Hz
     79
     80  The filterbank will be initialized with bands linearly spaced in the mel
     81  scale, from `fmin` to `fmax`.
     82
     83  References
     84  ----------
     85
     86  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
     87  https://engineering.purdue.edu/~malcolm/interval/1998-010/
     88
     89*/
     90uint_t aubio_filterbank_set_mel_coeffs(aubio_filterbank_t * fb,
     91    smpl_t samplerate, smpl_t fmin, smpl_t fmax);
     92
     93/** Mel filterbank initialization
     94
     95  \param fb filterbank object
     96  \param samplerate audio sampling rate
     97  \param fmin start frequency, in Hz
     98  \param fmax end frequency, in Hz
     99
     100  The bank of filters will be initalized to to cover linearly spaced bands in
     101  the Htk mel scale, from `fmin` to `fmax`.
     102
     103  References
     104  ----------
     105
     106  Douglas O'Shaughnessy (1987). *Speech communication: human and machine*.
     107  Addison-Wesley. p. 150. ISBN 978-0-201-16520-3.
     108
     109  HTK Speech Recognition Toolkit: http://htk.eng.cam.ac.uk/
     110
     111*/
     112uint_t aubio_filterbank_set_mel_coeffs_htk(aubio_filterbank_t * fb,
     113    smpl_t samplerate, smpl_t fmin, smpl_t fmax);
     114
    69115#ifdef __cplusplus
    70116}
  • src/spectral/mfcc.c

    r75f9fff ra95b386  
    5252  fvec_t *output;
    5353#endif
     54  smpl_t scale;
    5455};
    5556
     
    7576  /* filterbank allocation */
    7677  mfcc->fb = new_aubio_filterbank (n_filters, mfcc->win_s);
    77   aubio_filterbank_set_mel_coeffs_slaney (mfcc->fb, samplerate);
     78  if (n_filters == 40)
     79    aubio_filterbank_set_mel_coeffs_slaney (mfcc->fb, samplerate);
     80  else
     81    aubio_filterbank_set_mel_coeffs(mfcc->fb, samplerate,
     82        0, samplerate/2.);
    7883
    7984  /* allocating buffers */
     
    97102  mfcc->output = new_fvec (n_filters);
    98103#endif
     104
     105  mfcc->scale = 1.;
    99106
    100107  return mfcc;
     
    128135  fvec_t tmp;
    129136#endif
     137
    130138  /* compute filterbank */
    131139  aubio_filterbank_do (mf->fb, in, mf->in_dct);
     
    134142  fvec_log10 (mf->in_dct);
    135143
    136   /* raise power */
    137   //fvec_pow (mf->in_dct, 3.);
     144  if (mf->scale != 1) fvec_mul (mf->in_dct, mf->scale);
    138145
    139146  /* compute mfccs */
     
    151158  return;
    152159}
     160
     161uint_t aubio_mfcc_set_power (aubio_mfcc_t *mf, smpl_t power)
     162{
     163  return aubio_filterbank_set_power(mf->fb, power);
     164}
     165
     166uint_t aubio_mfcc_get_power (aubio_mfcc_t *mf)
     167{
     168  return aubio_filterbank_get_power(mf->fb);
     169}
     170
     171uint_t aubio_mfcc_set_scale (aubio_mfcc_t *mf, smpl_t scale)
     172{
     173  mf->scale = scale;
     174  return AUBIO_OK;
     175}
     176
     177uint_t aubio_mfcc_get_scale (aubio_mfcc_t *mf)
     178{
     179  return mf->scale;
     180}
     181
     182uint_t aubio_mfcc_set_mel_coeffs (aubio_mfcc_t *mf, smpl_t freq_min,
     183    smpl_t freq_max)
     184{
     185  return aubio_filterbank_set_mel_coeffs(mf->fb, mf->samplerate,
     186      freq_min, freq_max);
     187}
     188
     189uint_t aubio_mfcc_set_mel_coeffs_htk (aubio_mfcc_t *mf, smpl_t freq_min,
     190    smpl_t freq_max)
     191{
     192  return aubio_filterbank_set_mel_coeffs_htk(mf->fb, mf->samplerate,
     193      freq_min, freq_max);
     194}
     195
     196uint_t aubio_mfcc_set_mel_coeffs_slaney (aubio_mfcc_t *mf)
     197{
     198  return aubio_filterbank_set_mel_coeffs_slaney (mf->fb, mf->samplerate);
     199}
  • src/spectral/mfcc.h

    r75f9fff ra95b386  
    7474void aubio_mfcc_do (aubio_mfcc_t * mf, const cvec_t * in, fvec_t * out);
    7575
     76/** set power parameter
     77
     78  \param mf mfcc object, as returned by new_aubio_mfcc()
     79  \param power Raise norm of the input spectrum norm to this power before
     80  computing filterbank.  Defaults to `1`.
     81
     82  See aubio_filterbank_set_power().
     83
     84 */
     85uint_t aubio_mfcc_set_power (aubio_mfcc_t *mf, smpl_t power);
     86
     87/** get power parameter
     88
     89  \param mf mfcc object, as returned by new_aubio_mfcc()
     90  \return current power parameter. Defaults to `1`.
     91
     92  See aubio_filterbank_get_power().
     93
     94 */
     95uint_t aubio_mfcc_get_power (aubio_mfcc_t *mf);
     96
     97/** set scaling parameter
     98
     99  \param mf mfcc object, as returned by new_aubio_mfcc()
     100  \param scale Scaling value to apply.
     101
     102  Scales the output of the filterbank after taking its logarithm and before
     103  computing the DCT. Defaults to `1`.
     104
     105*/
     106uint_t aubio_mfcc_set_scale (aubio_mfcc_t *mf, smpl_t scale);
     107
     108/** get scaling parameter
     109
     110  \param mf mfcc object, as returned by new_aubio_mfcc()
     111  \return current scaling parameter. Defaults to `1`.
     112
     113 */
     114uint_t aubio_mfcc_get_scale (aubio_mfcc_t *mf);
     115
     116/** Mel filterbank initialization
     117
     118  \param mf mfcc object
     119  \param fmin start frequency, in Hz
     120  \param fmax end frequency, in Hz
     121
     122  The filterbank will be initialized with bands linearly spaced in the mel
     123  scale, from `fmin` to `fmax`.
     124
     125  See also
     126  --------
     127
     128  aubio_filterbank_set_mel_coeffs()
     129
     130*/
     131uint_t aubio_mfcc_set_mel_coeffs (aubio_mfcc_t *mf,
     132        smpl_t fmin, smpl_t fmax);
     133
     134/** Mel filterbank initialization
     135
     136  \param mf mfcc object
     137  \param fmin start frequency, in Hz
     138  \param fmax end frequency, in Hz
     139
     140  The bank of filters will be initalized to to cover linearly spaced bands in
     141  the Htk mel scale, from `fmin` to `fmax`.
     142
     143  See also
     144  --------
     145
     146  aubio_filterbank_set_mel_coeffs_htk()
     147
     148*/
     149uint_t aubio_mfcc_set_mel_coeffs_htk (aubio_mfcc_t *mf,
     150        smpl_t fmin, smpl_t fmax);
     151
     152/** Mel filterbank initialization (Auditory Toolbox's parameters)
     153
     154  \param mf mfcc object
     155  \param samplerate audio sampling rate, in Hz
     156
     157  The filter coefficients are built to match exactly Malcolm Slaney's Auditory
     158  Toolbox implementation. The number of filters should be 40.
     159
     160  This is the default filterbank when `mf` was created with `n_filters = 40`.
     161
     162  See also
     163  --------
     164
     165  aubio_filterbank_set_mel_coeffs_slaney()
     166
     167*/
     168uint_t aubio_mfcc_set_mel_coeffs_slaney (aubio_mfcc_t *mf);
     169
    76170#ifdef __cplusplus
    77171}
  • tests/src/spectral/test-filterbank.c

    r75f9fff ra95b386  
    1111  // create filterbank object
    1212  aubio_filterbank_t *o = new_aubio_filterbank (n_filters, win_s);
     13
     14  smpl_t power = aubio_filterbank_get_power(o);
     15  smpl_t norm = aubio_filterbank_get_norm(o);
     16  if (aubio_filterbank_set_power(o, power)) {
     17    return 1;
     18  }
     19  if (aubio_filterbank_set_norm(o, norm)) {
     20    return 1;
     21  }
    1322
    1423  // apply filterbank ten times
Note: See TracChangeset for help on using the changeset viewer.