python/ext/py-sink.c

   1 #include "aubio-types.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   fvec_t write_data;
  11   fmat_t mwrite_data;
  12 } Py_sink;
  13
  14 static char Py_sink_doc[] = ""
  15 "  __new__(path, samplerate = 44100, channels = 1)\n"
  16 "\n"
  17 "      Create a new sink, opening the given path for writing.\n"
  18 "\n"
  19 "      Examples\n"
  20 "      --------\n"
  21 "\n"
  22 "      Create a new sink at 44100Hz, mono:\n"
  23 "\n"
  24 "      >>> sink('/tmp/t.wav')\n"
  25 "\n"
  26 "      Create a new sink at 8000Hz, mono:\n"
  27 "\n"
  28 "      >>> sink('/tmp/t.wav', samplerate = 8000)\n"
  29 "\n"
  30 "      Create a new sink at 32000Hz, stereo:\n"
  31 "\n"
  32 "      >>> sink('/tmp/t.wav', samplerate = 32000, channels = 2)\n"
  33 "\n"
  34 "      Create a new sink at 32000Hz, 5 channels:\n"
  35 "\n"
  36 "      >>> sink('/tmp/t.wav', channels = 5, samplerate = 32000)\n"
  37 "\n"
  38 "  __call__(vec, write)\n"
  39 "      x(vec,write) <==> x.do(vec, write)\n"
  40 "\n"
  41 "      Write vector to sink.\n"
  42 "\n"
  43 "      See also\n"
  44 "      --------\n"
  45 "      aubio.sink.do\n"
  46 "\n";
  47
  48 static char Py_sink_do_doc[] = ""
  49 "x.do(vec, write) <==> x(vec, write)\n"
  50 "\n"
  51 "write monophonic vector to sink";
  52
  53 static char Py_sink_do_multi_doc[] = ""
  54 "x.do_multi(mat, write)\n"
  55 "\n"
  56 "write polyphonic vector to sink";
  57
  58 static char Py_sink_close_doc[] = ""
  59 "x.close()\n"
  60 "\n"
  61 "close this sink now";
  62
  63 static PyObject *
  64 Py_sink_new (PyTypeObject * pytype, PyObject * args, PyObject * kwds)
  65 {
  66   Py_sink *self;
  67   char_t* uri = NULL;
  68   uint_t samplerate = 0;
  69   uint_t channels = 0;
  70   static char *kwlist[] = { "uri", "samplerate", "channels", NULL };
  71
  72   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|sII", kwlist,
  73           &uri, &samplerate, &channels)) {
  74     return NULL;
  75   }
  76
  77   self = (Py_sink *) pytype->tp_alloc (pytype, 0);
  78
  79   if (self == NULL) {
  80     return NULL;
  81   }
  82
  83   self->uri = "none";
  84   if (uri != NULL) {
  85     self->uri = uri;
  86   }
  87
  88   self->samplerate = Py_aubio_default_samplerate;
  89   if ((sint_t)samplerate > 0) {
  90     self->samplerate = samplerate;
  91   } else if ((sint_t)samplerate < 0) {
  92     PyErr_SetString (PyExc_ValueError,
  93         "can not use negative value for samplerate");
  94     return NULL;
  95   }
  96
  97   self->channels = 1;
  98   if ((sint_t)channels > 0) {
  99     self->channels = channels;
 100   } else if ((sint_t)channels < 0) {
 101     PyErr_SetString (PyExc_ValueError,
 102         "can not use negative or null value for channels");
 103     return NULL;
 104   }
 105
 106   return (PyObject *) self;
 107 }
 108
 109 static int
 110 Py_sink_init (Py_sink * self, PyObject * args, PyObject * kwds)
 111 {
 112   if (self->channels == 1) {
 113     self->o = new_aubio_sink ( self->uri, self->samplerate );
 114   } else {
 115     self->o = new_aubio_sink ( self->uri, 0 );
 116     aubio_sink_preset_channels ( self->o, self->channels );
 117     aubio_sink_preset_samplerate ( self->o, self->samplerate );
 118   }
 119   if (self->o == NULL) {
 120     PyErr_SetString (PyExc_RuntimeError, "error creating sink with this uri");
 121     return -1;
 122   }
 123   self->samplerate = aubio_sink_get_samplerate ( self->o );
 124   self->channels = aubio_sink_get_channels ( self->o );
 125
 126   return 0;
 127 }
 128
 129 static void
 130 Py_sink_del (Py_sink *self, PyObject *unused)
 131 {
 132   del_aubio_sink(self->o);
 133   free(self->mwrite_data.data);
 134   Py_TYPE(self)->tp_free((PyObject *) self);
 135 }
 136
 137 /* function Py_sink_do */
 138 static PyObject *
 139 Py_sink_do(Py_sink * self, PyObject * args)
 140 {
 141   /* input vectors python prototypes */
 142   PyObject * write_data_obj;
 143
 144   /* input vectors prototypes */
 145   uint_t write;
 146
 147
 148   if (!PyArg_ParseTuple (args, "OI", &write_data_obj, &write)) {
 149     return NULL;
 150   }
 151
 152   /* input vectors parsing */
 153   if (!PyAubio_ArrayToCFvec(write_data_obj, &(self->write_data))) {
 154     return NULL;
 155   }
 156
 157
 158   /* compute _do function */
 159   aubio_sink_do (self->o, &(self->write_data), write);
 160
 161   Py_RETURN_NONE;
 162 }
 163
 164 /* function Py_sink_do_multi */
 165 static PyObject *
 166 Py_sink_do_multi(Py_sink * self, PyObject * args)
 167 {
 168   /* input vectors python prototypes */
 169   PyObject * write_data_obj;
 170
 171   /* input vectors prototypes */
 172   uint_t write;
 173
 174
 175   if (!PyArg_ParseTuple (args, "OI", &write_data_obj, &write)) {
 176     return NULL;
 177   }
 178
 179
 180   /* input vectors parsing */
 181   if (!PyAubio_ArrayToCFmat(write_data_obj, &(self->mwrite_data))) {
 182     return NULL;
 183   }
 184
 185   /* compute _do function */
 186   aubio_sink_do_multi (self->o, &(self->mwrite_data), write);
 187   Py_RETURN_NONE;
 188 }
 189
 190 static PyMemberDef Py_sink_members[] = {
 191   {"uri", T_STRING, offsetof (Py_sink, uri), READONLY,
 192     "path at which the sink was created"},
 193   {"samplerate", T_INT, offsetof (Py_sink, samplerate), READONLY,
 194     "samplerate at which the sink was created"},
 195   {"channels", T_INT, offsetof (Py_sink, channels), READONLY,
 196     "number of channels with which the sink was created"},
 197   { NULL } // sentinel
 198 };
 199
 200 static PyObject *
 201 Pyaubio_sink_close (Py_sink *self, PyObject *unused)
 202 {
 203   aubio_sink_close (self->o);
 204   Py_RETURN_NONE;
 205 }
 206
 207 static PyMethodDef Py_sink_methods[] = {
 208   {"do", (PyCFunction) Py_sink_do, METH_VARARGS, Py_sink_do_doc},
 209   {"do_multi", (PyCFunction) Py_sink_do_multi, METH_VARARGS, Py_sink_do_multi_doc},
 210   {"close", (PyCFunction) Pyaubio_sink_close, METH_NOARGS, Py_sink_close_doc},
 211   {NULL} /* sentinel */
 212 };
 213
 214 PyTypeObject Py_sinkType = {
 215   PyVarObject_HEAD_INIT (NULL, 0)
 216   "aubio.sink",
 217   sizeof (Py_sink),
 218   0,
 219   (destructor) Py_sink_del,
 220   0,
 221   0,
 222   0,
 223   0,
 224   0,
 225   0,
 226   0,
 227   0,
 228   0,
 229   (ternaryfunc)Py_sink_do,
 230   0,
 231   0,
 232   0,
 233   0,
 234   Py_TPFLAGS_DEFAULT,
 235   Py_sink_doc,
 236   0,
 237   0,
 238   0,
 239   0,
 240   0,
 241   0,
 242   Py_sink_methods,
 243   Py_sink_members,
 244   0,
 245   0,
 246   0,
 247   0,
 248   0,
 249   0,
 250   (initproc) Py_sink_init,
 251   0,
 252   Py_sink_new,
 253   0,
 254   0,
 255   0,
 256   0,
 257   0,
 258   0,
 259   0,
 260   0,
 261   0,
 262 };