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 (samplerate != 0) {
  90     self->samplerate = samplerate;
  91   }
  92
  93   self->channels = 1;
  94   if (channels != 0) {
  95     self->channels = channels;
  96   }
  97
  98   return (PyObject *) self;
  99 }
 100
 101 static int
 102 Py_sink_init (Py_sink * self, PyObject * args, PyObject * kwds)
 103 {
 104   self->o = new_aubio_sink ( self->uri, 0 );
 105   if (self->o == NULL) {
 106     // error string was set in new_aubio_sink
 107     return -1;
 108   }
 109   if (aubio_sink_preset_channels(self->o, self->channels) != 0) {
 110     // error string was set in aubio_sink_preset_channels
 111     return -1;
 112   }
 113   if (aubio_sink_preset_samplerate(self->o, self->samplerate) != 0) {
 114     // error string was set in aubio_sink_preset_samplerate
 115     return -1;
 116   }
 117
 118   self->samplerate = aubio_sink_get_samplerate ( self->o );
 119   self->channels = aubio_sink_get_channels ( self->o );
 120
 121   return 0;
 122 }
 123
 124 static void
 125 Py_sink_del (Py_sink *self, PyObject *unused)
 126 {
 127   del_aubio_sink(self->o);
 128   free(self->mwrite_data.data);
 129   Py_TYPE(self)->tp_free((PyObject *) self);
 130 }
 131
 132 /* function Py_sink_do */
 133 static PyObject *
 134 Py_sink_do(Py_sink * self, PyObject * args)
 135 {
 136   /* input vectors python prototypes */
 137   PyObject * write_data_obj;
 138
 139   /* input vectors prototypes */
 140   uint_t write;
 141
 142
 143   if (!PyArg_ParseTuple (args, "OI", &write_data_obj, &write)) {
 144     return NULL;
 145   }
 146
 147   /* input vectors parsing */
 148   if (!PyAubio_ArrayToCFvec(write_data_obj, &(self->write_data))) {
 149     return NULL;
 150   }
 151
 152
 153   /* compute _do function */
 154   aubio_sink_do (self->o, &(self->write_data), write);
 155
 156   Py_RETURN_NONE;
 157 }
 158
 159 /* function Py_sink_do_multi */
 160 static PyObject *
 161 Py_sink_do_multi(Py_sink * self, PyObject * args)
 162 {
 163   /* input vectors python prototypes */
 164   PyObject * write_data_obj;
 165
 166   /* input vectors prototypes */
 167   uint_t write;
 168
 169
 170   if (!PyArg_ParseTuple (args, "OI", &write_data_obj, &write)) {
 171     return NULL;
 172   }
 173
 174
 175   /* input vectors parsing */
 176   if (!PyAubio_ArrayToCFmat(write_data_obj, &(self->mwrite_data))) {
 177     return NULL;
 178   }
 179
 180   /* compute _do function */
 181   aubio_sink_do_multi (self->o, &(self->mwrite_data), write);
 182   Py_RETURN_NONE;
 183 }
 184
 185 static PyMemberDef Py_sink_members[] = {
 186   {"uri", T_STRING, offsetof (Py_sink, uri), READONLY,
 187     "path at which the sink was created"},
 188   {"samplerate", T_INT, offsetof (Py_sink, samplerate), READONLY,
 189     "samplerate at which the sink was created"},
 190   {"channels", T_INT, offsetof (Py_sink, channels), READONLY,
 191     "number of channels with which the sink was created"},
 192   { NULL } // sentinel
 193 };
 194
 195 static PyObject *
 196 Pyaubio_sink_close (Py_sink *self, PyObject *unused)
 197 {
 198   aubio_sink_close (self->o);
 199   Py_RETURN_NONE;
 200 }
 201
 202 static PyMethodDef Py_sink_methods[] = {
 203   {"do", (PyCFunction) Py_sink_do, METH_VARARGS, Py_sink_do_doc},
 204   {"do_multi", (PyCFunction) Py_sink_do_multi, METH_VARARGS, Py_sink_do_multi_doc},
 205   {"close", (PyCFunction) Pyaubio_sink_close, METH_NOARGS, Py_sink_close_doc},
 206   {NULL} /* sentinel */
 207 };
 208
 209 PyTypeObject Py_sinkType = {
 210   PyVarObject_HEAD_INIT (NULL, 0)
 211   "aubio.sink",
 212   sizeof (Py_sink),
 213   0,
 214   (destructor) Py_sink_del,
 215   0,
 216   0,
 217   0,
 218   0,
 219   0,
 220   0,
 221   0,
 222   0,
 223   0,
 224   (ternaryfunc)Py_sink_do,
 225   0,
 226   0,
 227   0,
 228   0,
 229   Py_TPFLAGS_DEFAULT,
 230   Py_sink_doc,
 231   0,
 232   0,
 233   0,
 234   0,
 235   0,
 236   0,
 237   Py_sink_methods,
 238   Py_sink_members,
 239   0,
 240   0,
 241   0,
 242   0,
 243   0,
 244   0,
 245   (initproc) Py_sink_init,
 246   0,
 247   Py_sink_new,
 248   0,
 249   0,
 250   0,
 251   0,
 252   0,
 253   0,
 254   0,
 255   0,
 256   0,
 257 };