source: python/ext/py-filter.c @ 1030a7b

feature/autosinkfeature/constantqfeature/pitchshiftfeature/pydocstringsfeature/timestretch
Last change on this file since 1030a7b was 1030a7b, checked in by Paul Brossier <piem@piem.org>, 2 years ago

[py] add docstrings for digital_filter

  • Property mode set to 100644
File size: 7.0 KB
Line 
1#include "aubio-types.h"
2
3typedef struct
4{
5  PyObject_HEAD
6  aubio_filter_t * o;
7  uint_t order;
8  fvec_t vec;
9  PyObject *out;
10  fvec_t c_out;
11} Py_filter;
12
13static char Py_filter_doc[] = ""
14"digital_filter(order=7)\n"
15"\n"
16"Create a digital filter.\n"
17"";
18
19static char Py_filter_set_c_weighting_doc[] = ""
20"set_c_weighting(samplerate)\n"
21"\n"
22"Set filter coefficients to C-weighting.\n"
23"\n"
24"`samplerate` should be one of 8000, 11025, 16000, 22050, 24000, 32000,\n"
25"44100, 48000, 88200, 96000, or 192000. `order` of the filter should be 5.\n"
26"\n"
27"Parameters\n"
28"----------\n"
29"samplerate : int\n"
30"    Sampling-rate of the input signal, in Hz.\n"
31"";
32
33static char Py_filter_set_a_weighting_doc[] = ""
34"set_a_weighting(samplerate)\n"
35"\n"
36"Set filter coefficients to A-weighting.\n"
37"\n"
38"`samplerate` should be one of 8000, 11025, 16000, 22050, 24000, 32000,\n"
39"44100, 48000, 88200, 96000, or 192000. `order` of the filter should be 7.\n"
40"\n"
41"Parameters\n"
42"----------\n"
43"samplerate : int\n"
44"    Sampling-rate of the input signal.\n"
45"";
46
47static char Py_filter_set_biquad_doc[] = ""
48"set_biquad(b0, b1, b2, a1, a2)\n"
49"\n"
50"Set biquad coefficients. `order` of the filter should be 3.\n"
51"\n"
52"Parameters\n"
53"----------\n"
54"b0 : float\n"
55"    Forward filter coefficient.\n"
56"b1 : float\n"
57"    Forward filter coefficient.\n"
58"b2 : float\n"
59"    Forward filter coefficient.\n"
60"a1 : float\n"
61"    Feedback filter coefficient.\n"
62"a2 : float\n"
63"    Feedback filter coefficient.\n"
64"";
65
66static PyObject *
67Py_filter_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
68{
69  int order= 0;
70  Py_filter *self;
71  static char *kwlist[] = { "order", NULL };
72
73  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
74          &order)) {
75    return NULL;
76  }
77
78  self = (Py_filter *) type->tp_alloc (type, 0);
79
80  if (self == NULL) {
81    return NULL;
82  }
83
84  self->order = 7;
85
86  if (order > 0) {
87    self->order = order;
88  } else if (order < 0) {
89    PyErr_SetString (PyExc_ValueError,
90        "can not use negative order");
91    return NULL;
92  }
93
94  return (PyObject *) self;
95}
96
97static int
98Py_filter_init (Py_filter * self, PyObject * args, PyObject * kwds)
99{
100  self->o = new_aubio_filter (self->order);
101  if (self->o == NULL) {
102    return -1;
103  }
104  self->out = NULL;
105  return 0;
106}
107
108static void
109Py_filter_del (Py_filter * self)
110{
111  Py_XDECREF(self->out);
112  del_aubio_filter (self->o);
113  Py_TYPE(self)->tp_free ((PyObject *) self);
114}
115
116static PyObject *
117Py_filter_do(Py_filter * self, PyObject * args)
118{
119  PyObject *input;
120
121  if (!PyArg_ParseTuple (args, "O:digital_filter.do", &input)) {
122    return NULL;
123  }
124
125  if (input == NULL) {
126    return NULL;
127  }
128
129  if (!PyAubio_ArrayToCFvec(input, &(self->vec))) {
130    return NULL;
131  }
132
133  // initialize output now
134  if (self->out == NULL) {
135    self->out = new_py_fvec(self->vec.length);
136  }
137
138  Py_INCREF(self->out);
139  if (!PyAubio_ArrayToCFvec(self->out, &(self->c_out)) ) {
140    return NULL;
141  }
142  // compute the function
143  aubio_filter_do_outplace (self->o, &(self->vec), &(self->c_out));
144  return self->out;
145}
146
147static PyObject *
148Py_filter_set_c_weighting (Py_filter * self, PyObject *args)
149{
150  uint_t err = 0;
151  uint_t samplerate;
152  if (!PyArg_ParseTuple (args, "I", &samplerate)) {
153    return NULL;
154  }
155
156  err = aubio_filter_set_c_weighting (self->o, samplerate);
157  if (err > 0) {
158    PyErr_SetString (PyExc_ValueError,
159        "error when setting filter to C-weighting");
160    return NULL;
161  }
162  Py_RETURN_NONE;
163}
164
165static PyObject *
166Py_filter_set_a_weighting (Py_filter * self, PyObject *args)
167{
168  uint_t err = 0;
169  uint_t samplerate;
170  if (!PyArg_ParseTuple (args, "I", &samplerate)) {
171    return NULL;
172  }
173
174  err = aubio_filter_set_a_weighting (self->o, samplerate);
175  if (err > 0) {
176    PyErr_SetString (PyExc_ValueError,
177        "error when setting filter to A-weighting");
178    return NULL;
179  }
180  Py_RETURN_NONE;
181}
182
183static PyObject *
184Py_filter_set_biquad(Py_filter * self, PyObject *args)
185{
186  uint_t err = 0;
187  lsmp_t b0, b1, b2, a1, a2;
188  if (!PyArg_ParseTuple (args, "ddddd", &b0, &b1, &b2, &a1, &a2)) {
189    return NULL;
190  }
191
192  err = aubio_filter_set_biquad (self->o, b0, b1, b2, a1, a2);
193  if (err > 0) {
194    PyErr_SetString (PyExc_ValueError,
195        "error when setting filter with biquad coefficients");
196    return NULL;
197  }
198  Py_RETURN_NONE;
199}
200
201static PyMemberDef Py_filter_members[] = {
202  // TODO remove READONLY flag and define getter/setter
203  {"order", T_INT, offsetof (Py_filter, order), READONLY,
204      "order of the filter"},
205  {NULL}                        /* Sentinel */
206};
207
208static PyMethodDef Py_filter_methods[] = {
209  {"set_c_weighting", (PyCFunction) Py_filter_set_c_weighting, METH_VARARGS,
210      Py_filter_set_c_weighting_doc},
211  {"set_a_weighting", (PyCFunction) Py_filter_set_a_weighting, METH_VARARGS,
212      Py_filter_set_a_weighting_doc},
213  {"set_biquad", (PyCFunction) Py_filter_set_biquad, METH_VARARGS,
214      Py_filter_set_biquad_doc},
215  {NULL}
216};
217
218PyTypeObject Py_filterType = {
219  PyVarObject_HEAD_INIT(NULL, 0)
220  "aubio.digital_filter",       /* tp_name           */
221  sizeof (Py_filter),           /* tp_basicsize      */
222  0,                            /* tp_itemsize       */
223  (destructor) Py_filter_del,   /* tp_dealloc        */
224  0,                            /* tp_print          */
225  0,                            /* tp_getattr        */
226  0,                            /* tp_setattr        */
227  0,                            /* tp_compare        */
228  0, //(reprfunc) Py_filter_repr,    /* tp_repr           */
229  0,                            /* tp_as_number      */
230  0,                            /* tp_as_sequence    */
231  0,                            /* tp_as_mapping     */
232  0,                            /* tp_hash           */
233  (ternaryfunc)Py_filter_do,    /* tp_call           */
234  0,                            /* tp_str            */
235  0,                            /* tp_getattro       */
236  0,                            /* tp_setattro       */
237  0,                            /* tp_as_buffer      */
238  Py_TPFLAGS_DEFAULT,           /* tp_flags          */
239  Py_filter_doc,                /* tp_doc            */
240  0,                            /* tp_traverse       */
241  0,                            /* tp_clear          */
242  0,                            /* tp_richcompare    */
243  0,                            /* tp_weaklistoffset */
244  0,                            /* tp_iter           */
245  0,                            /* tp_iternext       */
246  Py_filter_methods,            /* tp_methods        */
247  Py_filter_members,            /* tp_members        */
248  0,                            /* tp_getset         */
249  0,                            /* tp_base           */
250  0,                            /* tp_dict           */
251  0,                            /* tp_descr_get      */
252  0,                            /* tp_descr_set      */
253  0,                            /* tp_dictoffset     */
254  (initproc) Py_filter_init,    /* tp_init           */
255  0,                            /* tp_alloc          */
256  Py_filter_new,                /* tp_new            */
257  0,
258  0,
259  0,
260  0,
261  0,
262  0,
263  0,
264  0,
265  0,
266};
Note: See TracBrowser for help on using the repository browser.