python/ext/py-sink.c

   1 #include "aubiowraphell.h"
   2
   3 typedef struct
   4 {
   5   PyObject_HEAD
   6   aubio_sink_t * o;
   7   char_t* uri;
   8   uint_t samplerate;
   9   uint_t channels;
  10 } Py_sink;
  11
  12 static char Py_sink_doc[] = "sink object";
  13
  14 static PyObject *
  15 Py_sink_new (PyTypeObject * pytype, PyObject * args, PyObject * kwds)
  16 {
  17   Py_sink *self;
  18   char_t* uri = NULL;
  19   uint_t samplerate = 0;
  20   uint_t channels = 0;
  21   static char *kwlist[] = { "uri", "samplerate", "channels", NULL };
  22
  23   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|sII", kwlist,
  24           &uri, &samplerate, &channels)) {
  25     return NULL;
  26   }
  27
  28   self = (Py_sink *) pytype->tp_alloc (pytype, 0);
  29
  30   if (self == NULL) {
  31     return NULL;
  32   }
  33
  34   self->uri = "none";
  35   if (uri != NULL) {
  36     self->uri = uri;
  37   }
  38
  39   self->samplerate = Py_aubio_default_samplerate;
  40   if ((sint_t)samplerate > 0) {
  41     self->samplerate = samplerate;
  42   } else if ((sint_t)samplerate < 0) {
  43     PyErr_SetString (PyExc_ValueError,
  44         "can not use negative value for samplerate");
  45     return NULL;
  46   }
  47
  48   self->channels = 1;
  49   if ((sint_t)channels > 0) {
  50     self->channels = channels;
  51   } else if ((sint_t)channels < 0) {
  52     PyErr_SetString (PyExc_ValueError,
  53         "can not use negative or null value for channels");
  54     return NULL;
  55   }
  56
  57   return (PyObject *) self;
  58 }
  59
  60 static int
  61 Py_sink_init (Py_sink * self, PyObject * args, PyObject * kwds)
  62 {
  63   if (self->channels == 1) {
  64     self->o = new_aubio_sink ( self->uri, self->samplerate );
  65   } else {
  66     self->o = new_aubio_sink ( self->uri, 0 );
  67     aubio_sink_preset_channels ( self->o, self->channels );
  68     aubio_sink_preset_samplerate ( self->o, self->samplerate );
  69   }
  70   if (self->o == NULL) {
  71     PyErr_SetString (PyExc_StandardError, "error creating sink with this uri");
  72     return -1;
  73   }
  74   self->samplerate = aubio_sink_get_samplerate ( self->o );
  75   self->channels = aubio_sink_get_channels ( self->o );
  76
  77   return 0;
  78 }
  79
  80 AUBIO_DEL(sink)
  81
  82 /* function Py_sink_do */
  83 static PyObject *
  84 Py_sink_do(Py_sink * self, PyObject * args)
  85 {
  86   /* input vectors python prototypes */
  87   PyObject * write_data_obj;
  88
  89   /* input vectors prototypes */
  90   fvec_t* write_data;
  91   uint_t write;
  92
  93
  94   if (!PyArg_ParseTuple (args, "OI", &write_data_obj, &write)) {
  95     return NULL;
  96   }
  97
  98
  99   /* input vectors parsing */
 100   write_data = PyAubio_ArrayToCFvec (write_data_obj);
 101
 102   if (write_data == NULL) {
 103     return NULL;
 104   }
 105
 106
 107
 108
 109
 110   /* compute _do function */
 111   aubio_sink_do (self->o, write_data, write);
 112
 113   Py_RETURN_NONE;
 114 }
 115
 116 /* function Py_sink_do */
 117 static PyObject *
 118 Py_sink_do_multi(Py_sink * self, PyObject * args)
 119 {
 120   /* input vectors python prototypes */
 121   PyObject * write_data_obj;
 122
 123   /* input vectors prototypes */
 124   fmat_t * write_data;
 125   uint_t write;
 126
 127
 128   if (!PyArg_ParseTuple (args, "OI", &write_data_obj, &write)) {
 129     return NULL;
 130   }
 131
 132
 133   /* input vectors parsing */
 134   write_data = PyAubio_ArrayToCFmat (write_data_obj);
 135
 136   if (write_data == NULL) {
 137     return NULL;
 138   }
 139
 140
 141
 142
 143
 144   /* compute _do function */
 145   aubio_sink_do_multi (self->o, write_data, write);
 146   Py_RETURN_NONE;
 147 }
 148
 149 AUBIO_MEMBERS_START(sink)
 150   {"uri", T_STRING, offsetof (Py_sink, uri), READONLY, ""},
 151   {"samplerate", T_INT, offsetof (Py_sink, samplerate), READONLY, ""},
 152   {"channels", T_INT, offsetof (Py_sink, channels), READONLY, ""},
 153 AUBIO_MEMBERS_STOP(sink)
 154
 155 static PyObject *
 156 Pyaubio_sink_close (Py_sink *self, PyObject *unused)
 157 {
 158   aubio_sink_close (self->o);
 159   Py_RETURN_NONE;
 160 }
 161
 162 static PyMethodDef Py_sink_methods[] = {
 163   {"__call__", (PyCFunction) Py_sink_do, METH_VARARGS,
 164     "x.__call__(vec, write)\n"
 165     "write monophonic vector to sink"
 166     ""},
 167   {"do", (PyCFunction) Py_sink_do, METH_VARARGS,
 168     "x.do(vec, write)\n"
 169     "write monophonic vector to sink"
 170     ""},
 171   {"do_multi", (PyCFunction) Py_sink_do_multi, METH_VARARGS,
 172     "x.do_multi(mat, write)\n"
 173     "write polyphonic vector to sink"},
 174   {"close", (PyCFunction) Pyaubio_sink_close, METH_NOARGS,
 175     "x.close()\n"
 176     "close this sink now"},
 177   {NULL} /* sentinel */
 178 };
 179
 180 AUBIO_TYPEOBJECT(sink, "aubio.sink")