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   if (self->o)
 113     del_aubio_filter (self->o);
 114   Py_TYPE(self)->tp_free ((PyObject *) self);
 115 }
 116
 117 static PyObject *
 118 Py_filter_do(Py_filter * self, PyObject * args)
 119 {
 120   PyObject *input;
 121
 122   if (!PyArg_ParseTuple (args, "O:digital_filter.do", &input)) {
 123     return NULL;
 124   }
 125
 126   if (input == NULL) {
 127     return NULL;
 128   }
 129
 130   if (!PyAubio_ArrayToCFvec(input, &(self->vec))) {
 131     return NULL;
 132   }
 133
 134   // initialize output now
 135   if (self->out == NULL) {
 136     self->out = new_py_fvec(self->vec.length);
 137   }
 138
 139   Py_INCREF(self->out);
 140   if (!PyAubio_ArrayToCFvec(self->out, &(self->c_out)) ) {
 141     return NULL;
 142   }
 143   // compute the function
 144   aubio_filter_do_outplace (self->o, &(self->vec), &(self->c_out));
 145   return self->out;
 146 }
 147
 148 static PyObject *
 149 Py_filter_set_c_weighting (Py_filter * self, PyObject *args)
 150 {
 151   uint_t err = 0;
 152   uint_t samplerate;
 153   if (!PyArg_ParseTuple (args, "I", &samplerate)) {
 154     return NULL;
 155   }
 156
 157   err = aubio_filter_set_c_weighting (self->o, samplerate);
 158   if (err > 0) {
 159     if (PyErr_Occurred() == NULL) {
 160       PyErr_SetString (PyExc_ValueError,
 161           "error when setting filter to C-weighting");
 162     } else {
 163       // change the RuntimeError into ValueError
 164       PyObject *type, *value, *traceback;
 165       PyErr_Fetch(&type, &value, &traceback);
 166       PyErr_Restore(PyExc_ValueError, value, traceback);
 167     }
 168     return NULL;
 169   }
 170   Py_RETURN_NONE;
 171 }
 172
 173 static PyObject *
 174 Py_filter_set_a_weighting (Py_filter * self, PyObject *args)
 175 {
 176   uint_t err = 0;
 177   uint_t samplerate;
 178   if (!PyArg_ParseTuple (args, "I", &samplerate)) {
 179     return NULL;
 180   }
 181
 182   err = aubio_filter_set_a_weighting (self->o, samplerate);
 183   if (err > 0) {
 184     if (PyErr_Occurred() == NULL) {
 185       PyErr_SetString (PyExc_ValueError,
 186           "error when setting filter to A-weighting");
 187     } else {
 188       // change the RuntimeError into ValueError
 189       PyObject *type, *value, *traceback;
 190       PyErr_Fetch(&type, &value, &traceback);
 191       PyErr_Restore(PyExc_ValueError, value, traceback);
 192     }
 193     return NULL;
 194   }
 195   Py_RETURN_NONE;
 196 }
 197
 198 static PyObject *
 199 Py_filter_set_biquad(Py_filter * self, PyObject *args)
 200 {
 201   uint_t err = 0;
 202   lsmp_t b0, b1, b2, a1, a2;
 203   if (!PyArg_ParseTuple (args, "ddddd", &b0, &b1, &b2, &a1, &a2)) {
 204     return NULL;
 205   }
 206
 207   err = aubio_filter_set_biquad (self->o, b0, b1, b2, a1, a2);
 208   if (err > 0) {
 209     if (PyErr_Occurred() == NULL) {
 210       PyErr_SetString (PyExc_ValueError,
 211           "error when setting filter with biquad coefficients");
 212     } else {
 213       // change the RuntimeError into ValueError
 214       PyObject *type, *value, *traceback;
 215       PyErr_Fetch(&type, &value, &traceback);
 216       PyErr_Restore(PyExc_ValueError, value, traceback);
 217     }
 218     return NULL;
 219   }
 220   Py_RETURN_NONE;
 221 }
 222
 223 static PyMemberDef Py_filter_members[] = {
 224   // TODO remove READONLY flag and define getter/setter
 225   {"order", T_INT, offsetof (Py_filter, order), READONLY,
 226       "order of the filter"},
 227   {NULL}                        /* Sentinel */
 228 };
 229
 230 static PyMethodDef Py_filter_methods[] = {
 231   {"set_c_weighting", (PyCFunction) Py_filter_set_c_weighting, METH_VARARGS,
 232       Py_filter_set_c_weighting_doc},
 233   {"set_a_weighting", (PyCFunction) Py_filter_set_a_weighting, METH_VARARGS,
 234       Py_filter_set_a_weighting_doc},
 235   {"set_biquad", (PyCFunction) Py_filter_set_biquad, METH_VARARGS,
 236       Py_filter_set_biquad_doc},
 237   {NULL}
 238 };
 239
 240 PyTypeObject Py_filterType = {
 241   PyVarObject_HEAD_INIT(NULL, 0)
 242   "aubio.digital_filter",       /* tp_name           */
 243   sizeof (Py_filter),           /* tp_basicsize      */
 244   0,                            /* tp_itemsize       */
 245   (destructor) Py_filter_del,   /* tp_dealloc        */
 246   0,                            /* tp_print          */
 247   0,                            /* tp_getattr        */
 248   0,                            /* tp_setattr        */
 249   0,                            /* tp_compare        */
 250   0, //(reprfunc) Py_filter_repr,    /* tp_repr           */
 251   0,                            /* tp_as_number      */
 252   0,                            /* tp_as_sequence    */
 253   0,                            /* tp_as_mapping     */
 254   0,                            /* tp_hash           */
 255   (ternaryfunc)Py_filter_do,    /* tp_call           */
 256   0,                            /* tp_str            */
 257   0,                            /* tp_getattro       */
 258   0,                            /* tp_setattro       */
 259   0,                            /* tp_as_buffer      */
 260   Py_TPFLAGS_DEFAULT,           /* tp_flags          */
 261   Py_filter_doc,                /* tp_doc            */
 262   0,                            /* tp_traverse       */
 263   0,                            /* tp_clear          */
 264   0,                            /* tp_richcompare    */
 265   0,                            /* tp_weaklistoffset */
 266   0,                            /* tp_iter           */
 267   0,                            /* tp_iternext       */
 268   Py_filter_methods,            /* tp_methods        */
 269   Py_filter_members,            /* tp_members        */
 270   0,                            /* tp_getset         */
 271   0,                            /* tp_base           */
 272   0,                            /* tp_dict           */
 273   0,                            /* tp_descr_get      */
 274   0,                            /* tp_descr_set      */
 275   0,                            /* tp_dictoffset     */
 276   (initproc) Py_filter_init,    /* tp_init           */
 277   0,                            /* tp_alloc          */
 278   Py_filter_new,                /* tp_new            */
 279   0,
 280   0,
 281   0,
 282   0,
 283   0,
 284   0,
 285   0,
 286   0,
 287   0,
 288 };