source: python/ext/py-filterbank.c @ a380b73

feature/autosinkfeature/constantqfeature/pitchshiftfeature/pydocstringsfeature/timestretch
Last change on this file since a380b73 was a380b73, checked in by Paul Brossier <piem@piem.org>, 14 months ago

[py] filterbank.set_mel_coeffs_slaney accepts float

  • Property mode set to 100644
File size: 9.1 KB
Line 
1#include "aubio-types.h"
2
3static char Py_filterbank_doc[] = "filterbank object";
4
5typedef struct
6{
7  PyObject_HEAD
8  aubio_filterbank_t * o;
9  uint_t n_filters;
10  uint_t win_s;
11  cvec_t vec;
12  fvec_t freqs;
13  fmat_t coeffs;
14  PyObject *out;
15  fvec_t c_out;
16} Py_filterbank;
17
18static PyObject *
19Py_filterbank_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
20{
21  int win_s = 0, n_filters = 0;
22  Py_filterbank *self;
23  static char *kwlist[] = { "n_filters", "win_s", NULL };
24
25  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
26          &n_filters, &win_s)) {
27    return NULL;
28  }
29
30  self = (Py_filterbank *) type->tp_alloc (type, 0);
31
32  if (self == NULL) {
33    return NULL;
34  }
35
36  self->win_s = Py_default_vector_length;
37  if (win_s > 0) {
38    self->win_s = win_s;
39  } else if (win_s < 0) {
40    PyErr_SetString (PyExc_ValueError,
41        "can not use negative window size");
42    return NULL;
43  }
44
45  self->n_filters = 40;
46  if (n_filters > 0) {
47    self->n_filters = n_filters;
48  } else if (n_filters < 0) {
49    PyErr_SetString (PyExc_ValueError,
50        "can not use negative number of filters");
51    return NULL;
52  }
53
54  return (PyObject *) self;
55}
56
57static int
58Py_filterbank_init (Py_filterbank * self, PyObject * args, PyObject * kwds)
59{
60  self->o = new_aubio_filterbank (self->n_filters, self->win_s);
61  if (self->o == NULL) {
62    PyErr_Format(PyExc_RuntimeError, "error creating filterbank with"
63        " n_filters=%d, win_s=%d", self->n_filters, self->win_s);
64    return -1;
65  }
66  self->out = new_py_fvec(self->n_filters);
67
68  return 0;
69}
70
71static void
72Py_filterbank_del (Py_filterbank *self, PyObject *unused)
73{
74  if (self->o) {
75    free(self->coeffs.data);
76    del_aubio_filterbank(self->o);
77  }
78  Py_XDECREF(self->out);
79  Py_TYPE(self)->tp_free((PyObject *) self);
80}
81
82static PyObject *
83Py_filterbank_do(Py_filterbank * self, PyObject * args)
84{
85  PyObject *input;
86
87  if (!PyArg_ParseTuple (args, "O", &input)) {
88    return NULL;
89  }
90
91  if (!PyAubio_PyCvecToCCvec(input, &(self->vec) )) {
92    return NULL;
93  }
94
95  if (self->vec.length != self->win_s / 2 + 1) {
96    PyErr_Format(PyExc_ValueError,
97                 "input cvec has length %d, but filterbank expects length %d",
98                 self->vec.length, self->win_s / 2 + 1);
99    return NULL;
100  }
101
102  Py_INCREF(self->out);
103  if (!PyAubio_ArrayToCFvec(self->out, &(self->c_out))) {
104    return NULL;
105  }
106  // compute the function
107  aubio_filterbank_do (self->o, &(self->vec), &(self->c_out));
108  return self->out;
109}
110
111static PyMemberDef Py_filterbank_members[] = {
112  {"win_s", T_INT, offsetof (Py_filterbank, win_s), READONLY,
113    "size of the window"},
114  {"n_filters", T_INT, offsetof (Py_filterbank, n_filters), READONLY,
115    "number of filters"},
116  {NULL} /* sentinel */
117};
118
119static PyObject *
120Py_filterbank_set_triangle_bands (Py_filterbank * self, PyObject *args)
121{
122  uint_t err = 0;
123
124  PyObject *input;
125  uint_t samplerate;
126  if (!PyArg_ParseTuple (args, "OI", &input, &samplerate)) {
127    return NULL;
128  }
129
130  if (input == NULL) {
131    return NULL;
132  }
133
134  if (!PyAubio_ArrayToCFvec(input, &(self->freqs) )) {
135    return NULL;
136  }
137
138  err = aubio_filterbank_set_triangle_bands (self->o,
139      &(self->freqs), samplerate);
140  if (err > 0) {
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    }
149    return NULL;
150  }
151  Py_RETURN_NONE;
152}
153
154static PyObject *
155Py_filterbank_set_mel_coeffs_slaney (Py_filterbank * self, PyObject *args)
156{
157  uint_t err = 0;
158
159  smpl_t samplerate;
160  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR, &samplerate)) {
161    return NULL;
162  }
163
164  err = aubio_filterbank_set_mel_coeffs_slaney (self->o, samplerate);
165  if (err > 0) {
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    }
232    return NULL;
233  }
234  Py_RETURN_NONE;
235}
236
237static PyObject *
238Py_filterbank_set_coeffs (Py_filterbank * self, PyObject *args)
239{
240  uint_t err = 0;
241
242  PyObject *input;
243  if (!PyArg_ParseTuple (args, "O", &input)) {
244    return NULL;
245  }
246
247  if (!PyAubio_ArrayToCFmat(input, &(self->coeffs))) {
248    return NULL;
249  }
250
251  err = aubio_filterbank_set_coeffs (self->o, &(self->coeffs));
252
253  if (err > 0) {
254    PyErr_SetString (PyExc_ValueError,
255        "error when setting filter coefficients");
256    return NULL;
257  }
258  Py_RETURN_NONE;
259}
260
261static PyObject *
262Py_filterbank_get_coeffs (Py_filterbank * self, PyObject *unused)
263{
264  return (PyObject *)PyAubio_CFmatToArray(
265      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;
312}
313
314static PyMethodDef Py_filterbank_methods[] = {
315  {"set_triangle_bands", (PyCFunction) Py_filterbank_set_triangle_bands,
316    METH_VARARGS, "set coefficients of filterbanks"},
317  {"set_mel_coeffs_slaney", (PyCFunction) Py_filterbank_set_mel_coeffs_slaney,
318    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"},
323  {"get_coeffs", (PyCFunction) Py_filterbank_get_coeffs,
324    METH_NOARGS, "get coefficients of filterbank"},
325  {"set_coeffs", (PyCFunction) Py_filterbank_set_coeffs,
326    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"},
331  {NULL}
332};
333
334PyTypeObject Py_filterbankType = {
335  PyVarObject_HEAD_INIT (NULL, 0)
336  "aubio.filterbank",
337  sizeof (Py_filterbank),
338  0,
339  (destructor) Py_filterbank_del,
340  0,
341  0,
342  0,
343  0,
344  0,
345  0,
346  0,
347  0,
348  0,
349  (ternaryfunc)Py_filterbank_do,
350  0,
351  0,
352  0,
353  0,
354  Py_TPFLAGS_DEFAULT,
355  Py_filterbank_doc,
356  0,
357  0,
358  0,
359  0,
360  0,
361  0,
362  Py_filterbank_methods,
363  Py_filterbank_members,
364  0,
365  0,
366  0,
367  0,
368  0,
369  0,
370  (initproc) Py_filterbank_init,
371  0,
372  Py_filterbank_new,
373  0,
374  0,
375  0,
376  0,
377  0,
378  0,
379  0,
380  0,
381  0,
382};
Note: See TracBrowser for help on using the repository browser.