1 | #include "aubio-types.h" |
---|
2 | |
---|
3 | static char Py_filterbank_doc[] = "" |
---|
4 | "filterbank(n_filters=40, win_s=1024)\n" |
---|
5 | "\n" |
---|
6 | "Create a bank of spectral filters. Each instance is a callable\n" |
---|
7 | "that holds a matrix of coefficients.\n" |
---|
8 | "\n" |
---|
9 | "See also :meth:`set_mel_coeffs`, :meth:`set_mel_coeffs_htk`,\n" |
---|
10 | ":meth:`set_mel_coeffs_slaney`, :meth:`set_triangle_bands`, and\n" |
---|
11 | ":meth:`set_coeffs`.\n" |
---|
12 | "\n" |
---|
13 | "Parameters\n" |
---|
14 | "----------\n" |
---|
15 | "n_filters : int\n" |
---|
16 | " Number of filters to create.\n" |
---|
17 | "win_s : int\n" |
---|
18 | " Size of the input spectrum to process.\n" |
---|
19 | "\n" |
---|
20 | "Examples\n" |
---|
21 | "--------\n" |
---|
22 | ">>> f = aubio.filterbank(128, 1024)\n" |
---|
23 | ">>> f.set_mel_coeffs(44100, 0, 10000)\n" |
---|
24 | ">>> c = aubio.cvec(1024)\n" |
---|
25 | ">>> f(c).shape\n" |
---|
26 | "(128, )\n" |
---|
27 | ""; |
---|
28 | |
---|
29 | static char Py_filterbank_set_triangle_bands_doc[] ="" |
---|
30 | "set_triangle_bands(freqs, samplerate)\n" |
---|
31 | "\n" |
---|
32 | "Set triangular bands. The coefficients will be set to triangular\n" |
---|
33 | "overlapping windows using the boundaries specified by `freqs`.\n" |
---|
34 | "\n" |
---|
35 | "`freqs` should contain `n_filters + 2` frequencies in Hz, ordered\n" |
---|
36 | "by value, from smallest to largest. The first element should be greater\n" |
---|
37 | "or equal to zero; the last element should be smaller or equal to\n" |
---|
38 | "`samplerate / 2`.\n" |
---|
39 | "\n" |
---|
40 | "Parameters\n" |
---|
41 | "----------\n" |
---|
42 | "freqs: fvec\n" |
---|
43 | " List of frequencies, in Hz.\n" |
---|
44 | "samplerate : float\n" |
---|
45 | " Sampling-rate of the expected input.\n" |
---|
46 | "\n" |
---|
47 | "Example\n" |
---|
48 | "-------\n" |
---|
49 | ">>> fb = aubio.filterbank(n_filters=100, win_s=2048)\n" |
---|
50 | ">>> samplerate = 44100; freqs = np.linspace(0, 20200, 102)\n" |
---|
51 | ">>> fb.set_triangle_bands(aubio.fvec(freqs), samplerate)\n" |
---|
52 | ""; |
---|
53 | |
---|
54 | static char Py_filterbank_set_mel_coeffs_slaney_doc[] = "" |
---|
55 | "set_mel_coeffs_slaney(samplerate)\n" |
---|
56 | "\n" |
---|
57 | "Set coefficients of filterbank to match Slaney's Auditory Toolbox.\n" |
---|
58 | "\n" |
---|
59 | "The filter coefficients will be set as in Malcolm Slaney's\n" |
---|
60 | "implementation. The filterbank should have been created with\n" |
---|
61 | "`n_filters = 40`.\n" |
---|
62 | "\n" |
---|
63 | "This is approximately equivalent to using :meth:`set_mel_coeffs` with\n" |
---|
64 | "`fmin = 400./3., fmax = 6853.84`.\n" |
---|
65 | "\n" |
---|
66 | "Parameters\n" |
---|
67 | "----------\n" |
---|
68 | "samplerate : float\n" |
---|
69 | " Sampling-rate of the expected input.\n" |
---|
70 | "\n" |
---|
71 | "References\n" |
---|
72 | "----------\n" |
---|
73 | "\n" |
---|
74 | "Malcolm Slaney, `Auditory Toolbox Version 2, Technical Report #1998-010\n" |
---|
75 | "<https://engineering.purdue.edu/~malcolm/interval/1998-010/>`_\n" |
---|
76 | ""; |
---|
77 | |
---|
78 | static char Py_filterbank_set_mel_coeffs_doc[] = "" |
---|
79 | "set_mel_coeffs(samplerate, fmin, fmax)\n" |
---|
80 | "\n" |
---|
81 | "Set coefficients of filterbank to linearly spaced mel scale.\n" |
---|
82 | "\n" |
---|
83 | "Parameters\n" |
---|
84 | "----------\n" |
---|
85 | "samplerate : float\n" |
---|
86 | " Sampling-rate of the expected input.\n" |
---|
87 | "fmin : float\n" |
---|
88 | " Lower frequency boundary of the first filter.\n" |
---|
89 | "fmax : float\n" |
---|
90 | " Upper frequency boundary of the last filter.\n" |
---|
91 | "\n" |
---|
92 | "See also\n" |
---|
93 | "--------\n" |
---|
94 | "hztomel\n" |
---|
95 | ""; |
---|
96 | |
---|
97 | static char Py_filterbank_set_mel_coeffs_htk_doc[] = "" |
---|
98 | "set_mel_coeffs_htk(samplerate, fmin, fmax)\n" |
---|
99 | "\n" |
---|
100 | "Set coefficients of the filters to be linearly spaced in the HTK mel scale.\n" |
---|
101 | "\n" |
---|
102 | "Parameters\n" |
---|
103 | "----------\n" |
---|
104 | "samplerate : float\n" |
---|
105 | " Sampling-rate of the expected input.\n" |
---|
106 | "fmin : float\n" |
---|
107 | " Lower frequency boundary of the first filter.\n" |
---|
108 | "fmax : float\n" |
---|
109 | " Upper frequency boundary of the last filter.\n" |
---|
110 | "\n" |
---|
111 | "See also\n" |
---|
112 | "--------\n" |
---|
113 | "hztomel with `htk=True`\n" |
---|
114 | ""; |
---|
115 | |
---|
116 | static char Py_filterbank_get_coeffs_doc[] = "" |
---|
117 | "get_coeffs()\n" |
---|
118 | "\n" |
---|
119 | "Get coefficients matrix of filterbank.\n" |
---|
120 | "\n" |
---|
121 | "Returns\n" |
---|
122 | "-------\n" |
---|
123 | "array_like\n" |
---|
124 | " Array of shape (n_filters, win_s/2+1) containing the coefficients.\n" |
---|
125 | ""; |
---|
126 | |
---|
127 | static char Py_filterbank_set_coeffs_doc[] = "" |
---|
128 | "set_coeffs(coeffs)\n" |
---|
129 | "\n" |
---|
130 | "Set coefficients of filterbank.\n" |
---|
131 | "\n" |
---|
132 | "Parameters\n" |
---|
133 | "----------\n" |
---|
134 | "coeffs : fmat\n" |
---|
135 | " Array of shape (n_filters, win_s/2+1) containing the coefficients.\n" |
---|
136 | ""; |
---|
137 | |
---|
138 | static char Py_filterbank_set_power_doc[] = "" |
---|
139 | "set_power(power)\n" |
---|
140 | "\n" |
---|
141 | "Set power applied to input spectrum of filterbank.\n" |
---|
142 | "\n" |
---|
143 | "Parameters\n" |
---|
144 | "----------\n" |
---|
145 | "power : float\n" |
---|
146 | " Power to raise input spectrum to before computing the filters.\n" |
---|
147 | ""; |
---|
148 | |
---|
149 | static char Py_filterbank_get_power_doc[] = "" |
---|
150 | "get_power()\n" |
---|
151 | "\n" |
---|
152 | "Get power applied to filterbank.\n" |
---|
153 | "\n" |
---|
154 | "Returns\n" |
---|
155 | "-------\n" |
---|
156 | "float\n" |
---|
157 | " Power parameter.\n" |
---|
158 | ""; |
---|
159 | |
---|
160 | static char Py_filterbank_set_norm_doc[] = "" |
---|
161 | "set_norm(norm)\n" |
---|
162 | "\n" |
---|
163 | "Set norm parameter. If set to `0`, the filters will not be normalized.\n" |
---|
164 | "If set to `1`, the filters will be normalized to one. Default to `1`.\n" |
---|
165 | "\n" |
---|
166 | "This function should be called *before* :meth:`set_triangle_bands`,\n" |
---|
167 | ":meth:`set_mel_coeffs`, :meth:`set_mel_coeffs_htk`, or\n" |
---|
168 | ":meth:`set_mel_coeffs_slaney`.\n" |
---|
169 | "\n" |
---|
170 | "Parameters\n" |
---|
171 | "----------\n" |
---|
172 | "norm : int\n" |
---|
173 | " `0` to disable, `1` to enable\n" |
---|
174 | ""; |
---|
175 | |
---|
176 | static char Py_filterbank_get_norm_doc[] = "" |
---|
177 | "get_norm()\n" |
---|
178 | "\n" |
---|
179 | "Get norm parameter of filterbank.\n" |
---|
180 | "\n" |
---|
181 | "Returns\n" |
---|
182 | "-------\n" |
---|
183 | "float\n" |
---|
184 | " Norm parameter.\n" |
---|
185 | ""; |
---|
186 | |
---|
187 | typedef struct |
---|
188 | { |
---|
189 | PyObject_HEAD |
---|
190 | aubio_filterbank_t * o; |
---|
191 | uint_t n_filters; |
---|
192 | uint_t win_s; |
---|
193 | cvec_t vec; |
---|
194 | fvec_t freqs; |
---|
195 | fmat_t coeffs; |
---|
196 | PyObject *out; |
---|
197 | fvec_t c_out; |
---|
198 | } Py_filterbank; |
---|
199 | |
---|
200 | static PyObject * |
---|
201 | Py_filterbank_new (PyTypeObject * type, PyObject * args, PyObject * kwds) |
---|
202 | { |
---|
203 | int win_s = 0, n_filters = 0; |
---|
204 | Py_filterbank *self; |
---|
205 | static char *kwlist[] = { "n_filters", "win_s", NULL }; |
---|
206 | |
---|
207 | if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist, |
---|
208 | &n_filters, &win_s)) { |
---|
209 | return NULL; |
---|
210 | } |
---|
211 | |
---|
212 | self = (Py_filterbank *) type->tp_alloc (type, 0); |
---|
213 | |
---|
214 | if (self == NULL) { |
---|
215 | return NULL; |
---|
216 | } |
---|
217 | |
---|
218 | self->win_s = Py_default_vector_length; |
---|
219 | if (win_s > 0) { |
---|
220 | self->win_s = win_s; |
---|
221 | } else if (win_s < 0) { |
---|
222 | PyErr_SetString (PyExc_ValueError, |
---|
223 | "can not use negative window size"); |
---|
224 | return NULL; |
---|
225 | } |
---|
226 | |
---|
227 | self->n_filters = 40; |
---|
228 | if (n_filters > 0) { |
---|
229 | self->n_filters = n_filters; |
---|
230 | } else if (n_filters < 0) { |
---|
231 | PyErr_SetString (PyExc_ValueError, |
---|
232 | "can not use negative number of filters"); |
---|
233 | return NULL; |
---|
234 | } |
---|
235 | |
---|
236 | return (PyObject *) self; |
---|
237 | } |
---|
238 | |
---|
239 | static int |
---|
240 | Py_filterbank_init (Py_filterbank * self, PyObject * args, PyObject * kwds) |
---|
241 | { |
---|
242 | self->o = new_aubio_filterbank (self->n_filters, self->win_s); |
---|
243 | if (self->o == NULL) { |
---|
244 | PyErr_Format(PyExc_RuntimeError, "error creating filterbank with" |
---|
245 | " n_filters=%d, win_s=%d", self->n_filters, self->win_s); |
---|
246 | return -1; |
---|
247 | } |
---|
248 | self->out = new_py_fvec(self->n_filters); |
---|
249 | |
---|
250 | return 0; |
---|
251 | } |
---|
252 | |
---|
253 | static void |
---|
254 | Py_filterbank_del (Py_filterbank *self, PyObject *unused) |
---|
255 | { |
---|
256 | if (self->o) { |
---|
257 | free(self->coeffs.data); |
---|
258 | del_aubio_filterbank(self->o); |
---|
259 | } |
---|
260 | Py_XDECREF(self->out); |
---|
261 | Py_TYPE(self)->tp_free((PyObject *) self); |
---|
262 | } |
---|
263 | |
---|
264 | static PyObject * |
---|
265 | Py_filterbank_do(Py_filterbank * self, PyObject * args) |
---|
266 | { |
---|
267 | PyObject *input; |
---|
268 | |
---|
269 | if (!PyArg_ParseTuple (args, "O", &input)) { |
---|
270 | return NULL; |
---|
271 | } |
---|
272 | |
---|
273 | if (!PyAubio_PyCvecToCCvec(input, &(self->vec) )) { |
---|
274 | return NULL; |
---|
275 | } |
---|
276 | |
---|
277 | if (self->vec.length != self->win_s / 2 + 1) { |
---|
278 | PyErr_Format(PyExc_ValueError, |
---|
279 | "input cvec has length %d, but filterbank expects length %d", |
---|
280 | self->vec.length, self->win_s / 2 + 1); |
---|
281 | return NULL; |
---|
282 | } |
---|
283 | |
---|
284 | Py_INCREF(self->out); |
---|
285 | if (!PyAubio_ArrayToCFvec(self->out, &(self->c_out))) { |
---|
286 | return NULL; |
---|
287 | } |
---|
288 | // compute the function |
---|
289 | aubio_filterbank_do (self->o, &(self->vec), &(self->c_out)); |
---|
290 | return self->out; |
---|
291 | } |
---|
292 | |
---|
293 | static PyMemberDef Py_filterbank_members[] = { |
---|
294 | {"win_s", T_INT, offsetof (Py_filterbank, win_s), READONLY, |
---|
295 | "size of the window"}, |
---|
296 | {"n_filters", T_INT, offsetof (Py_filterbank, n_filters), READONLY, |
---|
297 | "number of filters"}, |
---|
298 | {NULL} /* sentinel */ |
---|
299 | }; |
---|
300 | |
---|
301 | static PyObject * |
---|
302 | Py_filterbank_set_triangle_bands (Py_filterbank * self, PyObject *args) |
---|
303 | { |
---|
304 | uint_t err = 0; |
---|
305 | |
---|
306 | PyObject *input; |
---|
307 | smpl_t samplerate; |
---|
308 | if (!PyArg_ParseTuple (args, "O" AUBIO_NPY_SMPL_CHR, &input, &samplerate)) { |
---|
309 | return NULL; |
---|
310 | } |
---|
311 | |
---|
312 | if (input == NULL) { |
---|
313 | return NULL; |
---|
314 | } |
---|
315 | |
---|
316 | if (!PyAubio_ArrayToCFvec(input, &(self->freqs) )) { |
---|
317 | return NULL; |
---|
318 | } |
---|
319 | |
---|
320 | err = aubio_filterbank_set_triangle_bands (self->o, |
---|
321 | &(self->freqs), samplerate); |
---|
322 | if (err > 0) { |
---|
323 | if (PyErr_Occurred() == NULL) { |
---|
324 | PyErr_SetString (PyExc_ValueError, "error running set_triangle_bands"); |
---|
325 | } else { |
---|
326 | // change the RuntimeError into ValueError |
---|
327 | PyObject *type, *value, *traceback; |
---|
328 | PyErr_Fetch(&type, &value, &traceback); |
---|
329 | PyErr_Restore(PyExc_ValueError, value, traceback); |
---|
330 | } |
---|
331 | return NULL; |
---|
332 | } |
---|
333 | Py_RETURN_NONE; |
---|
334 | } |
---|
335 | |
---|
336 | static PyObject * |
---|
337 | Py_filterbank_set_mel_coeffs_slaney (Py_filterbank * self, PyObject *args) |
---|
338 | { |
---|
339 | uint_t err = 0; |
---|
340 | |
---|
341 | smpl_t samplerate; |
---|
342 | if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR, &samplerate)) { |
---|
343 | return NULL; |
---|
344 | } |
---|
345 | |
---|
346 | err = aubio_filterbank_set_mel_coeffs_slaney (self->o, samplerate); |
---|
347 | if (err > 0) { |
---|
348 | if (PyErr_Occurred() == NULL) { |
---|
349 | PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs_slaney"); |
---|
350 | } else { |
---|
351 | // change the RuntimeError into ValueError |
---|
352 | PyObject *type, *value, *traceback; |
---|
353 | PyErr_Fetch(&type, &value, &traceback); |
---|
354 | PyErr_Restore(PyExc_ValueError, value, traceback); |
---|
355 | } |
---|
356 | return NULL; |
---|
357 | } |
---|
358 | Py_RETURN_NONE; |
---|
359 | } |
---|
360 | |
---|
361 | static PyObject * |
---|
362 | Py_filterbank_set_mel_coeffs (Py_filterbank * self, PyObject *args) |
---|
363 | { |
---|
364 | uint_t err = 0; |
---|
365 | |
---|
366 | smpl_t samplerate; |
---|
367 | smpl_t freq_min; |
---|
368 | smpl_t freq_max; |
---|
369 | if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR |
---|
370 | AUBIO_NPY_SMPL_CHR, &samplerate, &freq_min, &freq_max)) { |
---|
371 | return NULL; |
---|
372 | } |
---|
373 | |
---|
374 | err = aubio_filterbank_set_mel_coeffs (self->o, samplerate, |
---|
375 | freq_min, freq_max); |
---|
376 | if (err > 0) { |
---|
377 | if (PyErr_Occurred() == NULL) { |
---|
378 | PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs"); |
---|
379 | } else { |
---|
380 | // change the RuntimeError into ValueError |
---|
381 | PyObject *type, *value, *traceback; |
---|
382 | PyErr_Fetch(&type, &value, &traceback); |
---|
383 | PyErr_Restore(PyExc_ValueError, value, traceback); |
---|
384 | } |
---|
385 | return NULL; |
---|
386 | } |
---|
387 | Py_RETURN_NONE; |
---|
388 | } |
---|
389 | |
---|
390 | static PyObject * |
---|
391 | Py_filterbank_set_mel_coeffs_htk (Py_filterbank * self, PyObject *args) |
---|
392 | { |
---|
393 | uint_t err = 0; |
---|
394 | |
---|
395 | smpl_t samplerate; |
---|
396 | smpl_t freq_min; |
---|
397 | smpl_t freq_max; |
---|
398 | if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR |
---|
399 | AUBIO_NPY_SMPL_CHR, &samplerate, &freq_min, &freq_max)) { |
---|
400 | return NULL; |
---|
401 | } |
---|
402 | |
---|
403 | err = aubio_filterbank_set_mel_coeffs_htk (self->o, samplerate, |
---|
404 | freq_min, freq_max); |
---|
405 | if (err > 0) { |
---|
406 | if (PyErr_Occurred() == NULL) { |
---|
407 | PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs_htk"); |
---|
408 | } else { |
---|
409 | // change the RuntimeError into ValueError |
---|
410 | PyObject *type, *value, *traceback; |
---|
411 | PyErr_Fetch(&type, &value, &traceback); |
---|
412 | PyErr_Restore(PyExc_ValueError, value, traceback); |
---|
413 | } |
---|
414 | return NULL; |
---|
415 | } |
---|
416 | Py_RETURN_NONE; |
---|
417 | } |
---|
418 | |
---|
419 | static PyObject * |
---|
420 | Py_filterbank_set_coeffs (Py_filterbank * self, PyObject *args) |
---|
421 | { |
---|
422 | uint_t err = 0; |
---|
423 | |
---|
424 | PyObject *input; |
---|
425 | if (!PyArg_ParseTuple (args, "O", &input)) { |
---|
426 | return NULL; |
---|
427 | } |
---|
428 | |
---|
429 | if (!PyAubio_ArrayToCFmat(input, &(self->coeffs))) { |
---|
430 | return NULL; |
---|
431 | } |
---|
432 | |
---|
433 | err = aubio_filterbank_set_coeffs (self->o, &(self->coeffs)); |
---|
434 | |
---|
435 | if (err > 0) { |
---|
436 | PyErr_SetString (PyExc_ValueError, |
---|
437 | "error when setting filter coefficients"); |
---|
438 | return NULL; |
---|
439 | } |
---|
440 | Py_RETURN_NONE; |
---|
441 | } |
---|
442 | |
---|
443 | static PyObject * |
---|
444 | Py_filterbank_get_coeffs (Py_filterbank * self, PyObject *unused) |
---|
445 | { |
---|
446 | return (PyObject *)PyAubio_CFmatToArray( |
---|
447 | aubio_filterbank_get_coeffs (self->o) ); |
---|
448 | } |
---|
449 | |
---|
450 | static PyObject * |
---|
451 | Py_filterbank_set_power(Py_filterbank *self, PyObject *args) |
---|
452 | { |
---|
453 | smpl_t power; |
---|
454 | |
---|
455 | if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR, &power)) { |
---|
456 | return NULL; |
---|
457 | } |
---|
458 | if(aubio_filterbank_set_power (self->o, power)) { |
---|
459 | if (PyErr_Occurred() == NULL) { |
---|
460 | PyErr_SetString (PyExc_ValueError, |
---|
461 | "error running filterbank.set_power"); |
---|
462 | } else { |
---|
463 | // change the RuntimeError into ValueError |
---|
464 | PyObject *type, *value, *traceback; |
---|
465 | PyErr_Fetch(&type, &value, &traceback); |
---|
466 | PyErr_Restore(PyExc_ValueError, value, traceback); |
---|
467 | } |
---|
468 | return NULL; |
---|
469 | } |
---|
470 | Py_RETURN_NONE; |
---|
471 | } |
---|
472 | |
---|
473 | static PyObject * |
---|
474 | Py_filterbank_get_power (Py_filterbank * self, PyObject *unused) |
---|
475 | { |
---|
476 | smpl_t power = aubio_filterbank_get_power(self->o); |
---|
477 | return (PyObject *)PyFloat_FromDouble (power); |
---|
478 | } |
---|
479 | |
---|
480 | static PyObject * |
---|
481 | Py_filterbank_set_norm(Py_filterbank *self, PyObject *args) |
---|
482 | { |
---|
483 | smpl_t norm; |
---|
484 | |
---|
485 | if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR, &norm)) { |
---|
486 | return NULL; |
---|
487 | } |
---|
488 | if(aubio_filterbank_set_norm (self->o, norm)) { |
---|
489 | if (PyErr_Occurred() == NULL) { |
---|
490 | PyErr_SetString (PyExc_ValueError, |
---|
491 | "error running filterbank.set_power"); |
---|
492 | } else { |
---|
493 | // change the RuntimeError into ValueError |
---|
494 | PyObject *type, *value, *traceback; |
---|
495 | PyErr_Fetch(&type, &value, &traceback); |
---|
496 | PyErr_Restore(PyExc_ValueError, value, traceback); |
---|
497 | } |
---|
498 | return NULL; |
---|
499 | } |
---|
500 | Py_RETURN_NONE; |
---|
501 | } |
---|
502 | |
---|
503 | static PyObject * |
---|
504 | Py_filterbank_get_norm (Py_filterbank * self, PyObject *unused) |
---|
505 | { |
---|
506 | smpl_t norm = aubio_filterbank_get_norm(self->o); |
---|
507 | return (PyObject *)PyFloat_FromDouble (norm); |
---|
508 | } |
---|
509 | |
---|
510 | static PyMethodDef Py_filterbank_methods[] = { |
---|
511 | {"set_triangle_bands", (PyCFunction) Py_filterbank_set_triangle_bands, |
---|
512 | METH_VARARGS, Py_filterbank_set_triangle_bands_doc}, |
---|
513 | {"set_mel_coeffs_slaney", (PyCFunction) Py_filterbank_set_mel_coeffs_slaney, |
---|
514 | METH_VARARGS, Py_filterbank_set_mel_coeffs_slaney_doc}, |
---|
515 | {"set_mel_coeffs", (PyCFunction) Py_filterbank_set_mel_coeffs, |
---|
516 | METH_VARARGS, Py_filterbank_set_mel_coeffs_doc}, |
---|
517 | {"set_mel_coeffs_htk", (PyCFunction) Py_filterbank_set_mel_coeffs_htk, |
---|
518 | METH_VARARGS, Py_filterbank_set_mel_coeffs_htk_doc}, |
---|
519 | {"get_coeffs", (PyCFunction) Py_filterbank_get_coeffs, |
---|
520 | METH_NOARGS, Py_filterbank_get_coeffs_doc}, |
---|
521 | {"set_coeffs", (PyCFunction) Py_filterbank_set_coeffs, |
---|
522 | METH_VARARGS, Py_filterbank_set_coeffs_doc}, |
---|
523 | {"set_power", (PyCFunction) Py_filterbank_set_power, |
---|
524 | METH_VARARGS, Py_filterbank_set_power_doc}, |
---|
525 | {"get_power", (PyCFunction) Py_filterbank_get_power, |
---|
526 | METH_NOARGS, Py_filterbank_get_power_doc}, |
---|
527 | {"set_norm", (PyCFunction) Py_filterbank_set_norm, |
---|
528 | METH_VARARGS, Py_filterbank_set_norm_doc}, |
---|
529 | {"get_norm", (PyCFunction) Py_filterbank_get_norm, |
---|
530 | METH_NOARGS, Py_filterbank_get_norm_doc}, |
---|
531 | {NULL} |
---|
532 | }; |
---|
533 | |
---|
534 | PyTypeObject Py_filterbankType = { |
---|
535 | PyVarObject_HEAD_INIT (NULL, 0) |
---|
536 | "aubio.filterbank", |
---|
537 | sizeof (Py_filterbank), |
---|
538 | 0, |
---|
539 | (destructor) Py_filterbank_del, |
---|
540 | 0, |
---|
541 | 0, |
---|
542 | 0, |
---|
543 | 0, |
---|
544 | 0, |
---|
545 | 0, |
---|
546 | 0, |
---|
547 | 0, |
---|
548 | 0, |
---|
549 | (ternaryfunc)Py_filterbank_do, |
---|
550 | 0, |
---|
551 | 0, |
---|
552 | 0, |
---|
553 | 0, |
---|
554 | Py_TPFLAGS_DEFAULT, |
---|
555 | Py_filterbank_doc, |
---|
556 | 0, |
---|
557 | 0, |
---|
558 | 0, |
---|
559 | 0, |
---|
560 | 0, |
---|
561 | 0, |
---|
562 | Py_filterbank_methods, |
---|
563 | Py_filterbank_members, |
---|
564 | 0, |
---|
565 | 0, |
---|
566 | 0, |
---|
567 | 0, |
---|
568 | 0, |
---|
569 | 0, |
---|
570 | (initproc) Py_filterbank_init, |
---|
571 | 0, |
---|
572 | Py_filterbank_new, |
---|
573 | 0, |
---|
574 | 0, |
---|
575 | 0, |
---|
576 | 0, |
---|
577 | 0, |
---|
578 | 0, |
---|
579 | 0, |
---|
580 | 0, |
---|
581 | 0, |
---|
582 | }; |
---|