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