Merge branch 'master' into feature/pydocstrings
[aubio.git] / python / ext / py-filter.c
1 #include "aubio-types.h"
2
3 typedef 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
13 static char Py_filter_doc[] = ""
14 "digital_filter(order=7)\n"
15 "\n"
16 "Create a digital filter.\n"
17 "";
18
19 static 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
33 static 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
47 static 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
66 static PyObject *
67 Py_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
97 static int
98 Py_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
108 static void
109 Py_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
116 static PyObject *
117 Py_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
147 static PyObject *
148 Py_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
165 static PyObject *
166 Py_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
183 static PyObject *
184 Py_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
201 static 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
208 static 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
218 PyTypeObject 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 };