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     }
 163     return NULL;
 164   }
 165   Py_RETURN_NONE;
 166 }
 167
 168 static PyObject *
 169 Py_filter_set_a_weighting (Py_filter * self, PyObject *args)
 170 {
 171   uint_t err = 0;
 172   uint_t samplerate;
 173   if (!PyArg_ParseTuple (args, "I", &samplerate)) {
 174     return NULL;
 175   }
 176
 177   err = aubio_filter_set_a_weighting (self->o, samplerate);
 178   if (err > 0) {
 179     if (PyErr_Occurred() == NULL) {
 180       PyErr_SetString (PyExc_ValueError,
 181           "error when setting filter to A-weighting");
 182     }
 183     return NULL;
 184   }
 185   Py_RETURN_NONE;
 186 }
 187
 188 static PyObject *
 189 Py_filter_set_biquad(Py_filter * self, PyObject *args)
 190 {
 191   uint_t err = 0;
 192   lsmp_t b0, b1, b2, a1, a2;
 193   if (!PyArg_ParseTuple (args, "ddddd", &b0, &b1, &b2, &a1, &a2)) {
 194     return NULL;
 195   }
 196
 197   err = aubio_filter_set_biquad (self->o, b0, b1, b2, a1, a2);
 198   if (err > 0) {
 199     if (PyErr_Occurred() == NULL) {
 200       PyErr_SetString (PyExc_ValueError,
 201           "error when setting filter with biquad coefficients");
 202     }
 203     return NULL;
 204   }
 205   Py_RETURN_NONE;
 206 }
 207
 208 static PyMemberDef Py_filter_members[] = {
 209   // TODO remove READONLY flag and define getter/setter
 210   {"order", T_INT, offsetof (Py_filter, order), READONLY,
 211       "order of the filter"},
 212   {NULL}                        /* Sentinel */
 213 };
 214
 215 static PyMethodDef Py_filter_methods[] = {
 216   {"set_c_weighting", (PyCFunction) Py_filter_set_c_weighting, METH_VARARGS,
 217       Py_filter_set_c_weighting_doc},
 218   {"set_a_weighting", (PyCFunction) Py_filter_set_a_weighting, METH_VARARGS,
 219       Py_filter_set_a_weighting_doc},
 220   {"set_biquad", (PyCFunction) Py_filter_set_biquad, METH_VARARGS,
 221       Py_filter_set_biquad_doc},
 222   {NULL}
 223 };
 224
 225 PyTypeObject Py_filterType = {
 226   PyVarObject_HEAD_INIT(NULL, 0)
 227   "aubio.digital_filter",       /* tp_name           */
 228   sizeof (Py_filter),           /* tp_basicsize      */
 229   0,                            /* tp_itemsize       */
 230   (destructor) Py_filter_del,   /* tp_dealloc        */
 231   0,                            /* tp_print          */
 232   0,                            /* tp_getattr        */
 233   0,                            /* tp_setattr        */
 234   0,                            /* tp_compare        */
 235   0, //(reprfunc) Py_filter_repr,    /* tp_repr           */
 236   0,                            /* tp_as_number      */
 237   0,                            /* tp_as_sequence    */
 238   0,                            /* tp_as_mapping     */
 239   0,                            /* tp_hash           */
 240   (ternaryfunc)Py_filter_do,    /* tp_call           */
 241   0,                            /* tp_str            */
 242   0,                            /* tp_getattro       */
 243   0,                            /* tp_setattro       */
 244   0,                            /* tp_as_buffer      */
 245   Py_TPFLAGS_DEFAULT,           /* tp_flags          */
 246   Py_filter_doc,                /* tp_doc            */
 247   0,                            /* tp_traverse       */
 248   0,                            /* tp_clear          */
 249   0,                            /* tp_richcompare    */
 250   0,                            /* tp_weaklistoffset */
 251   0,                            /* tp_iter           */
 252   0,                            /* tp_iternext       */
 253   Py_filter_methods,            /* tp_methods        */
 254   Py_filter_members,            /* tp_members        */
 255   0,                            /* tp_getset         */
 256   0,                            /* tp_base           */
 257   0,                            /* tp_dict           */
 258   0,                            /* tp_descr_get      */
 259   0,                            /* tp_descr_set      */
 260   0,                            /* tp_dictoffset     */
 261   (initproc) Py_filter_init,    /* tp_init           */
 262   0,                            /* tp_alloc          */
 263   Py_filter_new,                /* tp_new            */
 264   0,
 265   0,
 266   0,
 267   0,
 268   0,
 269   0,
 270   0,
 271   0,
 272   0,
 273 };