sigrid/aubio

python/ext/aubiomodule.c+10−18

 Py_alpha_norm (PyObject * self, PyObject * args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   smpl_t alpha;
   PyObject *result;
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
   // compute the function
-  result = Py_BuildValue ("f", fvec_alpha_norm (vec, alpha));
+  result = Py_BuildValue ("f", fvec_alpha_norm (&vec, alpha));
-  free(vec);
   if (result == NULL) {
     return NULL;
   }
 Py_zero_crossing_rate (PyObject * self, PyObject * args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   PyObject *result;
   if (!PyArg_ParseTuple (args, "O:zero_crossing_rate", &input)) {
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
   // compute the function
-  result = Py_BuildValue ("f", aubio_zero_crossing_rate (vec));
+  result = Py_BuildValue ("f", aubio_zero_crossing_rate (&vec));
-  free(vec);
   if (result == NULL) {
     return NULL;
   }
 Py_min_removal(PyObject * self, PyObject * args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   if (!PyArg_ParseTuple (args, "O:min_removal", &input)) {
     return NULL;
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
   // compute the function
-  fvec_min_removal (vec);
+  fvec_min_removal (&vec);
   // since this function does not return, we could return None
   //Py_RETURN_NONE;
   // however it is convenient to return the modified vector
-  return (PyObject *) PyAubio_CFvecToArray(vec);
+  return (PyObject *) PyAubio_CFvecToArray(&vec);
   // or even without converting it back to an array
   //Py_INCREF(vec);
   //return (PyObject *)vec;

python/ext/aubioproxy.c+7−9

     return 0;
   }
-  if (mat->height != (uint_t)PyArray_DIM ((PyArrayObject *)input, 0)) {
+  uint_t new_height = (uint_t)PyArray_DIM ((PyArrayObject *)input, 0);
-    /*
+  if (mat->height != new_height) {
-    free(mat->data);
+    if (mat->data) {
-    mat->height = (uint_t)PyArray_DIM ((PyArrayObject *)input, 0);
+      free(mat->data);
-    mat->data = (smpl_t **)malloc(sizeof(smpl_t*) * mat->height);
+    }
-    */
+    mat->data = (smpl_t **)malloc(sizeof(smpl_t*) * new_height);
-    PyErr_Format(PyExc_ValueError, "too many rows, %d but %ld expected",
-                      mat->height, PyArray_DIM ((PyArrayObject *)input, 0) );
-    return 0;
   }
+  mat->height = new_height;
   mat->length = (uint_t)PyArray_DIM ((PyArrayObject *)input, 1);
   for (i=0; i< mat->height; i++) {
     mat->data[i] = (smpl_t*)PyArray_GETPTR1 ((PyArrayObject *)input, i);

python/ext/py-fft.c+10−12

   PyObject_HEAD
   aubio_fft_t * o;
   uint_t win_s;
-  fvec_t *vecin;
+  // do / rdo input vectors
+  fvec_t vecin;
+  cvec_t cvecin;
+  // do / rdo output results
   cvec_t *out;
-  Py_cvec *py_out;
-  cvec_t *cvecin;
   fvec_t *rout;
+  // bridge for cvec output
+  Py_cvec *py_out;
 } Py_fft;
 static PyObject *
     return -1;
   }
-  self->cvecin = (cvec_t *)malloc(sizeof(cvec_t));
-  self->vecin = (fvec_t *)malloc(sizeof(fvec_t));
   self->out = new_cvec(self->win_s);
   self->py_out = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
   Py_XINCREF(self->py_out);
   del_aubio_fft(self->o);
   del_cvec(self->out);
   del_fvec(self->rout);
-  free(self->cvecin);
-  free(self->vecin);
   Py_TYPE(self)->tp_free((PyObject *) self);
 }
     return NULL;
   }
-  if (!PyAubio_ArrayToCFvec(input, self->vecin)) {
+  if (!PyAubio_ArrayToCFvec(input, &(self->vecin))) {
     return NULL;
   }
   // compute the function
-  aubio_fft_do (((Py_fft *)self)->o, self->vecin, self->out);
+  aubio_fft_do (((Py_fft *)self)->o, &(self->vecin), self->out);
 #if 0
   Py_cvec * py_out = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
   PyObject* output = PyAubio_CCvecToPyCvec(self->out, py_out);
     return NULL;
   }
-  if (!PyAubio_ArrayToCCvec (input, self->cvecin) ) {
+  if (!PyAubio_ArrayToCCvec (input, &(self->cvecin)) ) {
     return NULL;
   }
   // compute the function
-  aubio_fft_rdo (self->o, self->cvecin, self->rout);
+  aubio_fft_rdo (self->o, &(self->cvecin), self->rout);
   return PyAubio_CFvecToArray(self->rout);
 }

python/ext/py-filter.c+5−7

   PyObject_HEAD
   aubio_filter_t * o;
   uint_t order;
-  fvec_t *vec;
+  fvec_t vec;
   fvec_t *out;
 } Py_filter;
     return -1;
   }
   self->out = new_fvec(Py_default_vector_length);
-  self->vec = (fvec_t *)malloc(sizeof(fvec_t));
   return 0;
 }
 {
   del_fvec(self->out);
   del_aubio_filter (self->o);
-  free(self->vec);
   Py_TYPE(self)->tp_free ((PyObject *) self);
 }
     return NULL;
   }
-  if (!PyAubio_ArrayToCFvec(input, self->vec)) {
+  if (!PyAubio_ArrayToCFvec(input, &(self->vec))) {
     return NULL;
   }
   // reallocate the output if needed
-  if (self->vec->length != self->out->length) {
+  if (self->vec.length != self->out->length) {
     del_fvec(self->out);
-    self->out = new_fvec(self->vec->length);
+    self->out = new_fvec(self->vec.length);
   }
   // compute the function
-  aubio_filter_do_outplace (self->o, self->vec, self->out);
+  aubio_filter_do_outplace (self->o, &(self->vec), self->out);
   return PyAubio_CFvecToArray(self->out);
 }

python/ext/py-filterbank.c+10−21

   aubio_filterbank_t * o;
   uint_t n_filters;
   uint_t win_s;
-  cvec_t *vec;
+  cvec_t vec;
+  fvec_t freqs;
+  fmat_t coeffs;
   fvec_t *out;
-  fvec_t *freqs;
-  fmat_t *coeffs;
 } Py_filterbank;
 static PyObject *
   }
   self->out = new_fvec(self->n_filters);
-  self->vec = (cvec_t *)malloc(sizeof(cvec_t));
-  self->freqs = (fvec_t *)malloc(sizeof(fvec_t));
-  self->coeffs = (fmat_t *)malloc(sizeof(fmat_t));
-  self->coeffs->data = (smpl_t **)malloc(sizeof(smpl_t*) * self->n_filters);
-  self->coeffs->height = self->n_filters;
   return 0;
 }
 {
   del_aubio_filterbank(self->o);
   del_fvec(self->out);
-  free(self->vec);
+  free(self->coeffs.data);
-  free(self->freqs);
-  free(self->coeffs->data);
-  free(self->coeffs);
   Py_TYPE(self)->tp_free((PyObject *) self);
 }
     return NULL;
   }
-  if (!PyAubio_ArrayToCCvec(input, self->vec)) {
+  if (!PyAubio_ArrayToCCvec(input, &(self->vec) )) {
     return NULL;
   }
   // compute the function
-  aubio_filterbank_do (self->o, self->vec, self->out);
+  aubio_filterbank_do (self->o, &(self->vec), self->out);
   return (PyObject *)PyAubio_CFvecToArray(self->out);
 }
     return NULL;
   }
-  if (!PyAubio_ArrayToCFvec(input, self->freqs)) {
+  if (!PyAubio_ArrayToCFvec(input, &(self->freqs) )) {
     return NULL;
   }
   err = aubio_filterbank_set_triangle_bands (self->o,
-      self->freqs, samplerate);
+      &(self->freqs), samplerate);
   if (err > 0) {
     PyErr_SetString (PyExc_ValueError,
         "error when setting filter to A-weighting");
     return NULL;
   }
-  if (!PyAubio_ArrayToCFmat(input, self->coeffs)) {
+  if (!PyAubio_ArrayToCFmat(input, &(self->coeffs))) {
     return NULL;
   }
-  err = aubio_filterbank_set_coeffs (self->o, self->coeffs);
+  err = aubio_filterbank_set_coeffs (self->o, &(self->coeffs));
   if (err > 0) {
     PyErr_SetString (PyExc_ValueError,

python/ext/py-musicutils.c+12−24

 Py_aubio_level_lin(PyObject *self, PyObject *args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   PyObject *level_lin;
   if (!PyArg_ParseTuple (args, "O:level_lin", &input)) {
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
-  level_lin = Py_BuildValue("f", aubio_level_lin(vec));
+  level_lin = Py_BuildValue("f", aubio_level_lin(&vec));
-  free(vec);
   if (level_lin == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing level_lin");
     return NULL;
 Py_aubio_db_spl(PyObject *self, PyObject *args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   PyObject *db_spl;
   if (!PyArg_ParseTuple (args, "O:db_spl", &input)) {
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
-  db_spl = Py_BuildValue("f", aubio_db_spl(vec));
+  db_spl = Py_BuildValue("f", aubio_db_spl(&vec));
-  free(vec);
   if (db_spl == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing db_spl");
     return NULL;
 Py_aubio_silence_detection(PyObject *self, PyObject *args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   PyObject *silence_detection;
   smpl_t threshold;
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
-  silence_detection = Py_BuildValue("I", aubio_silence_detection(vec, threshold));
+  silence_detection = Py_BuildValue("I", aubio_silence_detection(&vec, threshold));
-  free(vec);
   if (silence_detection == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing silence_detection");
     return NULL;
 Py_aubio_level_detection(PyObject *self, PyObject *args)
 {
   PyObject *input;
-  fvec_t *vec;
+  fvec_t vec;
   PyObject *level_detection;
   smpl_t threshold;
     return NULL;
   }
-  vec = (fvec_t *)malloc(sizeof(fvec_t));
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
-  if (!PyAubio_ArrayToCFvec(input, vec)) {
-    free(vec);
     return NULL;
   }
-  level_detection = Py_BuildValue("f", aubio_level_detection(vec, threshold));
+  level_detection = Py_BuildValue("f", aubio_level_detection(&vec, threshold));
-  free(vec);
   if (level_detection == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing level_detection");
     return NULL;

python/ext/py-phasevoc.c+6−13

 #include "aubio-types.h"
-static char Py_pvoc_doc[] = "pvoc object";
 typedef struct
 {
   PyObject_HEAD
   aubio_pvoc_t * o;
   uint_t win_s;
   uint_t hop_s;
-  fvec_t *vecin;
+  fvec_t vecin;
   cvec_t *output;
   Py_cvec *py_out;
-  cvec_t *cvecin;
+  cvec_t cvecin;
   fvec_t *routput;
 } Py_pvoc;
     return -1;
   }
-  self->cvecin = (cvec_t *)malloc(sizeof(cvec_t));
-  self->vecin = (fvec_t *)malloc(sizeof(fvec_t));
   self->output = new_cvec(self->win_s);
   self->py_out = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
   self->routput = new_fvec(self->hop_s);
   del_aubio_pvoc(self->o);
   del_cvec(self->output);
   del_fvec(self->routput);
-  free(self->cvecin);
-  free(self->vecin);
   Py_TYPE(self)->tp_free((PyObject *) self);
 }
     return NULL;
   }
-  if (!PyAubio_ArrayToCFvec (input, self->vecin)) {
+  if (!PyAubio_ArrayToCFvec (input, &(self->vecin) )) {
     return NULL;
   }
   // compute the function
-  aubio_pvoc_do (self->o, self->vecin, self->output);
+  aubio_pvoc_do (self->o, &(self->vecin), self->output);
 #if 0
   Py_cvec * py_out = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
   PyObject* output = PyAubio_CCvecToPyCvec(self->output, py_out);
     return NULL;
   }
-  if (!PyAubio_ArrayToCCvec (input, self->cvecin)) {
+  if (!PyAubio_ArrayToCCvec (input, &(self->cvecin) )) {
     return NULL;
   }
   // compute the function
-  aubio_pvoc_rdo (self->o, self->cvecin, self->routput);
+  aubio_pvoc_rdo (self->o, &(self->cvecin), self->routput);
   return PyAubio_CFvecToArray(self->routput);
 }

python/ext/py-sink.c+7−13

   char_t* uri;
   uint_t samplerate;
   uint_t channels;
-  fvec_t *write_data;
+  fvec_t write_data;
-  fmat_t *mwrite_data;
+  fmat_t mwrite_data;
 } Py_sink;
 static char Py_sink_doc[] = ""
   self->samplerate = aubio_sink_get_samplerate ( self->o );
   self->channels = aubio_sink_get_channels ( self->o );
-  self->write_data = (fvec_t *)malloc(sizeof(fvec_t));
-  self->mwrite_data = (fmat_t *)malloc(sizeof(fmat_t));
-  self->mwrite_data->height = self->channels;
-  self->mwrite_data->data = (smpl_t **)malloc(sizeof(smpl_t*) * self->channels);
   return 0;
 }
 Py_sink_del (Py_sink *self, PyObject *unused)
 {
   del_aubio_sink(self->o);
-  free(self->write_data);
+  free(self->mwrite_data.data);
-  free(self->mwrite_data->data);
-  free(self->mwrite_data);
   Py_TYPE(self)->tp_free((PyObject *) self);
 }
   }
   /* input vectors parsing */
-  if (!PyAubio_ArrayToCFvec(write_data_obj, self->write_data)) {
+  if (!PyAubio_ArrayToCFvec(write_data_obj, &(self->write_data))) {
     return NULL;
   }
   /* compute _do function */
-  aubio_sink_do (self->o, self->write_data, write);
+  aubio_sink_do (self->o, &(self->write_data), write);
   Py_RETURN_NONE;
 }
   /* input vectors parsing */
-  if (!PyAubio_ArrayToCFmat(write_data_obj, self->mwrite_data)) {
+  if (!PyAubio_ArrayToCFmat(write_data_obj, &(self->mwrite_data))) {
     return NULL;
   }
   /* compute _do function */
-  aubio_sink_do_multi (self->o, self->mwrite_data, write);
+  aubio_sink_do_multi (self->o, &(self->mwrite_data), write);
   Py_RETURN_NONE;
 }

python/ext: simplify memory allocations, removed unneeded malloc/free calls

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code