comparison PyPluginObject.cpp @ 35:24eedd23a812

Fix outputs, add getRemainingFeatures

         (infodict, "copyright", pystr(plugin->getCopyright()));
     pd->info = infodict;
 
     pd->inputDomain = plugin->getInputDomain();
 
+    VectorConversion conv;
+
     Plugin::ParameterList pl = plugin->getParameterDescriptors();
-    
     PyObject *params = PyList_New(pl.size());
-
-    VectorConversion conv;
     
     for (int i = 0; i < (int)pl.size(); ++i) {
         PyObject *paramdict = PyDict_New();
         PyDict_SetItemString
             (paramdict, "identifier", pystr(pl[i].identifier));

         
         PyList_SET_ITEM(params, i, paramdict);
     }
 
     pd->parameters = params;
+
+    Plugin::OutputList ol = plugin->getOutputDescriptors();
+    PyObject *outputs = PyList_New(ol.size());
+    
+    for (int i = 0; i < (int)ol.size(); ++i) {
+        PyObject *outdict = PyDict_New();
+        PyDict_SetItemString
+            (outdict, "identifier", pystr(ol[i].identifier));
+        PyDict_SetItemString
+            (outdict, "name", pystr(ol[i].name));
+        PyDict_SetItemString
+            (outdict, "description", pystr(ol[i].description));
+        PyDict_SetItemString
+            (outdict, "binCount", PyInt_FromLong(ol[i].binCount));
+        if (ol[i].binCount > 0) {
+            if (ol[i].hasKnownExtents) {
+                PyDict_SetItemString
+                    (outdict, "hasKnownExtents", Py_True);
+                PyDict_SetItemString
+                    (outdict, "minValue", PyFloat_FromDouble(ol[i].minValue));
+                PyDict_SetItemString
+                    (outdict, "maxValue", PyFloat_FromDouble(ol[i].maxValue));
+            } else {
+                PyDict_SetItemString
+                    (outdict, "hasKnownExtents", Py_False);
+            }
+            if (ol[i].isQuantized) {
+                PyDict_SetItemString
+                    (outdict, "isQuantized", Py_True);
+                PyDict_SetItemString
+                    (outdict, "quantizeStep", PyFloat_FromDouble(ol[i].quantizeStep));
+            } else {
+                PyDict_SetItemString
+                    (outdict, "isQuantized", Py_False);
+            }
+        }
+        PyDict_SetItemString
+            (outdict, "sampleType", PyInt_FromLong((int)ol[i].sampleType));
+        PyDict_SetItemString
+            (outdict, "sampleRate", PyFloat_FromDouble(ol[i].sampleRate));
+        PyDict_SetItemString
+            (outdict, "hasDuration", ol[i].hasDuration ? Py_True : Py_False);
+        
+        PyList_SET_ITEM(outputs, i, outdict);
+    }
+
+    pd->outputs = outputs;
     
     return (PyObject *)pd;
 }
 
 static void

 
     pd->plugin->setParameter(PyString_AS_STRING(pyParam), value);
     return Py_True;
 }
 
-static PyObject *
-vampyhost_process(PyObject *self, PyObject *args)
-{
-    cerr << "vampyhost_process" << endl;
-
-    PyObject *pyBuffer;
-    PyObject *pyRealTime;
-
-    if (!PyArg_ParseTuple(args, "OO",
-			  &pyBuffer,			// Audio data
-			  &pyRealTime)) {		// TimeStamp
-	PyErr_SetString(PyExc_TypeError,
-			"process() takes plugin handle (object), buffer (2D array of channels * samples floats) and timestamp (RealTime) arguments");
-	return 0; }
-
-    if (!PyRealTime_Check(pyRealTime)) {
-	PyErr_SetString(PyExc_TypeError,"Valid timestamp required.");
-	return 0; }
-
-    if (!PyList_Check(pyBuffer)) {
-	PyErr_SetString(PyExc_TypeError, "List of NumPy Array required for process input.");
-        return 0;
-    }
-
-    PyPluginObject *pd = getPluginObject(self);
-    if (!pd) return 0;
-
-    if (!pd->isInitialised) {
-	PyErr_SetString(PyExc_StandardError,
-			"Plugin has not been initialised.");
-	return 0;
-    }
-
-    int channels =  pd->channels;
-
-    if (PyList_GET_SIZE(pyBuffer) != channels) {
-        cerr << "Wrong number of channels: got " << PyList_GET_SIZE(pyBuffer) << ", expected " << channels << endl;
-	PyErr_SetString(PyExc_TypeError, "Wrong number of channels");
-        return 0;
-    }
-
-    float **inbuf = new float *[channels];
-
-    VectorConversion typeConv;
-
-    vector<vector<float> > data;
-    for (int c = 0; c < channels; ++c) {
-        PyObject *cbuf = PyList_GET_ITEM(pyBuffer, c);
-        data.push_back(typeConv.PyValue_To_FloatVector(cbuf));
-    }
-    
-    for (int c = 0; c < channels; ++c) {
-        if (data[c].size() != pd->blockSize) {
-            cerr << "Wrong number of samples on channel " << c << ": expected " << pd->blockSize << " (plugin's block size), got " << data[c].size() << endl;
-            PyErr_SetString(PyExc_TypeError, "Wrong number of samples");
-            return 0;
-        }
-        inbuf[c] = &data[c][0];
-    }
-
-    RealTime timeStamp = *PyRealTime_AsRealTime(pyRealTime);
-
-    Plugin::FeatureSet fs = pd->plugin->process(inbuf, timeStamp);
-
-    delete[] inbuf;
-
+static
+PyObject *
+convertFeatureSet(const Plugin::FeatureSet &fs)
+{
     VectorConversion conv;
     
     PyObject *pyFs = PyDict_New();
 
     for (Plugin::FeatureSet::const_iterator fsi = fs.begin();

     
     return pyFs;
 }
 
 static PyObject *
+vampyhost_process(PyObject *self, PyObject *args)
+{
+    cerr << "vampyhost_process" << endl;
+
+    PyObject *pyBuffer;
+    PyObject *pyRealTime;
+
+    if (!PyArg_ParseTuple(args, "OO",
+			  &pyBuffer,			// Audio data
+			  &pyRealTime)) {		// TimeStamp
+	PyErr_SetString(PyExc_TypeError,
+			"process() takes plugin handle (object), buffer (2D array of channels * samples floats) and timestamp (RealTime) arguments");
+	return 0; }
+
+    if (!PyRealTime_Check(pyRealTime)) {
+	PyErr_SetString(PyExc_TypeError,"Valid timestamp required.");
+	return 0; }
+
+    if (!PyList_Check(pyBuffer)) {
+	PyErr_SetString(PyExc_TypeError, "List of NumPy Array required for process input.");
+        return 0;
+    }
+
+    PyPluginObject *pd = getPluginObject(self);
+    if (!pd) return 0;
+
+    if (!pd->isInitialised) {
+	PyErr_SetString(PyExc_StandardError,
+			"Plugin has not been initialised.");
+	return 0;
+    }
+
+    int channels =  pd->channels;
+
+    if (PyList_GET_SIZE(pyBuffer) != channels) {
+        cerr << "Wrong number of channels: got " << PyList_GET_SIZE(pyBuffer) << ", expected " << channels << endl;
+	PyErr_SetString(PyExc_TypeError, "Wrong number of channels");
+        return 0;
+    }
+
+    float **inbuf = new float *[channels];
+
+    VectorConversion typeConv;
+
+    vector<vector<float> > data;
+    for (int c = 0; c < channels; ++c) {
+        PyObject *cbuf = PyList_GET_ITEM(pyBuffer, c);
+        data.push_back(typeConv.PyValue_To_FloatVector(cbuf));
+    }
+    
+    for (int c = 0; c < channels; ++c) {
+        if (data[c].size() != pd->blockSize) {
+            cerr << "Wrong number of samples on channel " << c << ": expected " << pd->blockSize << " (plugin's block size), got " << data[c].size() << endl;
+            PyErr_SetString(PyExc_TypeError, "Wrong number of samples");
+            return 0;
+        }
+        inbuf[c] = &data[c][0];
+    }
+
+    RealTime timeStamp = *PyRealTime_AsRealTime(pyRealTime);
+
+    Plugin::FeatureSet fs = pd->plugin->process(inbuf, timeStamp);
+
+    delete[] inbuf;
+
+    return convertFeatureSet(fs);
+}
+
+static PyObject *
+vampyhost_getRemainingFeatures(PyObject *self, PyObject *)
+{
+    cerr << "vampyhost_getRemainingFeatures" << endl;
+
+    PyPluginObject *pd = getPluginObject(self);
+    if (!pd) return 0;
+
+    if (!pd->isInitialised) {
+	PyErr_SetString(PyExc_StandardError,
+			"Plugin has not been initialised.");
+	return 0;
+    }
+
+    Plugin::FeatureSet fs = pd->plugin->getRemainingFeatures();
+
+    return convertFeatureSet(fs);
+}
+
+static PyObject *
 vampyhost_unload(PyObject *self, PyObject *)
 {
     cerr << "vampyhost_unloadPlugin" << endl;
     
     PyPluginObject *pd = getPluginObject(self);

     {(char *)"inputDomain", T_INT, offsetof(PyPluginObject, inputDomain), READONLY,
      xx_foo_doc},
 
     {(char *)"parameters", T_OBJECT, offsetof(PyPluginObject, parameters), READONLY,
      xx_foo_doc},
+
+    {(char *)"outputs", T_OBJECT, offsetof(PyPluginObject, outputs), READONLY,
+     xx_foo_doc},
     
     {0, 0}
 };
 
 static PyMethodDef PyPluginObject_methods[] =

 
     {"reset",	vampyhost_reset, METH_NOARGS,
      xx_foo_doc},
 
     {"process",	vampyhost_process, METH_VARARGS,
+     xx_foo_doc},
+
+    {"getRemainingFeatures",	vampyhost_getRemainingFeatures, METH_NOARGS,
      xx_foo_doc},
 
     {"unload", vampyhost_unload, METH_NOARGS,
      xx_foo_doc},