comparison vampyhost.cpp @ 16:7987e3123909

Rationalise plugin handle management

 #define PY_ARRAY_UNIQUE_SYMBOL VAMPY_ARRAY_API
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #include "numpy/arrayobject.h"
 
 #include <vampyhost.h>
-
-#include "PyTypeConversions.h"
-#include "PyRealTime.h"
-
-//!!! NB all our NumPy stuff is currently using the deprecated API --
-//!!! need to work out how to update this
-//#include "numpy/arrayobject.h"
 
 #define HAVE_NUMPY 1 // Required
 
 //includes for vamp host
 #include "vamp-hostsdk/Plugin.h"
 #include "vamp-hostsdk/PluginHostAdapter.h"
 #include "vamp-hostsdk/PluginChannelAdapter.h"
 #include "vamp-hostsdk/PluginInputDomainAdapter.h"
 #include "vamp-hostsdk/PluginLoader.h"
-//#include "vamp/vamp.h"
+
+#include "PyTypeConversions.h"
+#include "PyRealTime.h"
 
 #include <iostream>
 #include <fstream>
 #include <set>
 #include <sndfile.h>
 
 #include <cstring>
 #include <cstdlib>
 #include <string>
 
-#include "system.h"
-
 #include <cmath>
-
 
 using namespace std;
 using namespace Vamp;
 
 using Vamp::Plugin;

 using Vamp::RealTime;
 using Vamp::HostExt::PluginLoader;
 
 #define HOST_VERSION "1.1"
 
+// structure for holding plugin instance data
+struct PyPluginData
+{
+    PyPluginData(string k, Plugin *p, float rate) :
+        key(k),
+        plugin(p),
+        inputSampleRate(rate),
+        isInitialised(false),
+        channels(0),
+        blockSize(0),
+        stepSize(0) {
+    }
+    
+    string key;
+    Plugin *plugin;
+    float inputSampleRate;
+    bool isInitialised;
+    size_t channels;
+    size_t blockSize;
+    size_t stepSize;
+    Vamp::Plugin::FeatureSet output;
+};
 
 /* MODULE HELPER FUNCTIONS */
 PyDoc_STRVAR(xx_foo_doc, "Some description"); //!!!
 
-/*obtain C plugin handle and key from pyCobject */
-bool getPluginHandle
-(PyObject *pyPluginHandle, Plugin **plugin, string **pKey=NULL) {
-
-    //char errormsg[]="Wrong input argument: Plugin Handle required.";
-
-    *plugin = NULL;
-    if (!PyCObject_Check(pyPluginHandle)) return false;
-
-    //try to convert to Plugin pointer
-    Plugin *p = (Plugin*) PyCObject_AsVoidPtr(pyPluginHandle);
-    if (!p) return false;
-
-    string pId;
-
-    if (pKey) {
-	*pKey = (string*) PyCObject_GetDesc(pyPluginHandle);
-	if (!*pKey) return false;
-	pId = *(string*) *pKey;
-
+//!!! nb "The CObject API is deprecated" https://docs.python.org/2/c-api/cobject.html
+
+PyPluginData *
+getPluginData(PyObject *pyPluginHandle)
+{
+    PyPluginData *pd = 0;
+    if (PyCObject_Check(pyPluginHandle)) {
+        pd = (PyPluginData *)PyCObject_AsVoidPtr(pyPluginHandle);
+    }
+    if (!pd || !pd->plugin) {
+        PyErr_SetString(PyExc_AttributeError,
+			"Invalid or already deleted plugin handle.");
+        return 0;
     } else {
-
-	void *pKey = PyCObject_GetDesc(pyPluginHandle);
-	if (!pKey) return false;
-	pId = *(string*) pKey;
-    }
-
-    string::size_type pos = pId.find(':');
-    if (pos == string::npos) return false;
-
-    pId = pId.substr(pId.rfind(':')+1);
-    string identifier = p->getIdentifier();
-
-    if (pId.compare(identifier)) return false;
-
-    *plugin = p;
-    return true;
-}
-
-/*
-  ----------------------------------------------------------------
-*/
-
-
-
-/*
-  VAMPYHOST MAIN
-  ---------------------------------------------------------------------
-*/
+        return pd;
+    }
+}
 
 static PyObject *
 vampyhost_enumeratePlugins(PyObject *self, PyObject *args)
 {
     PluginLoader *loader = PluginLoader::getInstance();

     PyObject *pyPluginKey;
 
     if (!PyArg_ParseTuple(args, "S", &pyPluginKey)) {
 	PyErr_SetString(PyExc_TypeError,
 			"getLibraryPathForPlugin() takes plugin key (string) argument");
-	return NULL; }
+	return 0; }
 
     string pluginKey = toPluginKey(pyPluginKey);
-    if (pluginKey == "") return NULL;
+    if (pluginKey == "") return 0;
     
     PluginLoader *loader = PluginLoader::getInstance();
     string path = loader->getLibraryPathForPlugin(pluginKey);
     PyObject *pyPath = PyString_FromString(path.c_str());
     return pyPath;

     PyObject *pyPluginKey;
 
     if (!PyArg_ParseTuple(args, "S", &pyPluginKey)) {
 	PyErr_SetString(PyExc_TypeError,
 			"getPluginCategory() takes plugin key (string) argument");
-	return NULL; }
+	return 0; }
 
     string pluginKey = toPluginKey(pyPluginKey);
-    if (pluginKey == "") return NULL;
+    if (pluginKey == "") return 0;
 
     PluginLoader *loader = PluginLoader::getInstance();
     PluginLoader::PluginCategoryHierarchy
 	category = loader->getPluginCategory(pluginKey);
 

 }
 
 static PyObject *
 vampyhost_getOutputList(PyObject *self, PyObject *args)
 {
-    PyObject *pyPluginHandle;
+    PyObject *keyOrHandle;
     Plugin::OutputList outputs;
 
-    if (!PyArg_ParseTuple(args, "O", &pyPluginHandle)) {
+    if (!PyArg_ParseTuple(args, "O", &keyOrHandle)) {
 	PyErr_SetString(PyExc_TypeError,
 			"getOutputList() takes plugin handle (object) or plugin key (string) argument");
-	return NULL;
-    }
-
-    if (PyString_Check(pyPluginHandle) ) {
+	return 0;
+    }
+
+    if (PyString_Check(keyOrHandle) ) {
 
         // we have a plugin key
 
-        string pluginKey = toPluginKey(pyPluginHandle);
-        if (pluginKey == "") return NULL;
+        string pluginKey = toPluginKey(keyOrHandle);
+        if (pluginKey == "") return 0;
 
         PluginLoader *loader = PluginLoader::getInstance();
 
         Plugin *plugin = loader->loadPlugin
             (pluginKey, 48000, PluginLoader::ADAPT_ALL_SAFE);
         if (!plugin) {
             string pyerr("Failed to load plugin: "); pyerr += pluginKey;
             PyErr_SetString(PyExc_TypeError,pyerr.c_str());
-            return NULL;
+            return 0;
         }
 
         outputs = plugin->getOutputDescriptors();
 
         delete plugin;
         
     } else {
 
         // we have a loaded plugin handle
         
-	string *key;
-	Plugin *plugin;
-
-	if ( !getPluginHandle(pyPluginHandle, &plugin, &key) ) {
-	    PyErr_SetString(PyExc_TypeError,
-			    "Invalid or deleted plugin handle.");
-	    return NULL; }
-
-        outputs = plugin->getOutputDescriptors();
+        PyPluginData *pd = getPluginData(keyOrHandle);
+        if (!pd) return 0;
+
+        outputs = pd->plugin->getOutputDescriptors();
     }
 
     PyObject *pyList = PyList_New(outputs.size());
 
     for (size_t i = 0; i < outputs.size(); ++i) {

     if (!PyArg_ParseTuple(args, "Sf",
 			  &pyPluginKey,
 			  &inputSampleRate)) {
 	PyErr_SetString(PyExc_TypeError,
 			"loadPlugin() takes plugin key (string) and sample rate (number) arguments");
-	return NULL; }
+	return 0; }
 
     string pluginKey = toPluginKey(pyPluginKey);
-    if (pluginKey == "") return NULL;
+    if (pluginKey == "") return 0;
 
     PluginLoader *loader = PluginLoader::getInstance();
 
     Plugin *plugin = loader->loadPlugin(pluginKey, inputSampleRate,
                                         PluginLoader::ADAPT_ALL_SAFE);
     if (!plugin) {
 	string pyerr("Failed to load plugin: "); pyerr += pluginKey;
 	PyErr_SetString(PyExc_TypeError,pyerr.c_str());
-	return NULL;
-    }
-
-    PyPluginDescriptor *pd = new PyPluginDescriptor;
-
-    pd->key = pluginKey;
-    pd->isInitialised = false;
-    pd->inputSampleRate = inputSampleRate;
-
-    PyObject *pyPluginHandle = PyCObject_FromVoidPtrAndDesc(
-	(void*) plugin, (void*) pd, NULL);
-
-    return pyPluginHandle;
-}
-
-
-
-/* UNLOAD PLUGIN */
+	return 0;
+    }
+
+    PyPluginData *pd = new PyPluginData(pluginKey, plugin, inputSampleRate);
+    return PyCObject_FromVoidPtr(pd, 0);
+}
 
 static PyObject *
 vampyhost_unloadPlugin(PyObject *self, PyObject *args)
 {
     PyObject *pyPluginHandle;
 
     if (!PyArg_ParseTuple(args, "O", &pyPluginHandle)) {
 	PyErr_SetString(PyExc_TypeError,
-			"Wrong input argument: Plugin Handle required.");
-	return NULL; }
-
-    string *key;
-    Plugin *plugin;
-
-    if ( !getPluginHandle(pyPluginHandle, &plugin, &key) ) {
-	PyErr_SetString(PyExc_TypeError,
-			"Invalid or already deleted plugin handle.");
-	return NULL; }
-
-/*	Prevent repeated calls from causing segfault
-	sice it will fail type checking the 2nd time:						*/
-    PyCObject_SetVoidPtr(pyPluginHandle,NULL);
-
-    PyPluginDescriptor *pd = (PyPluginDescriptor*) key;
-
-    delete plugin;
+			"unloadPlugin() takes plugin handle (object) argument");
+	return 0;
+    }
+
+    PyPluginData *pd = getPluginData(pyPluginHandle);
+    if (!pd) return 0;
+
+    /* Prevent repeated calls from causing segfault since it will fail
+     * type checking the 2nd time: */
+    PyCObject_SetVoidPtr(pyPluginHandle, 0);
+
+    delete pd->plugin;
     delete pd;
     return pyPluginHandle;
-
 }
 
 
 /* INITIALISE PLUGIN */
 

 			   (size_t) &stepSize,
 			   (size_t) &blockSize))
     {
 	PyErr_SetString(PyExc_TypeError,
 			"Wrong input arguments: requires a valid plugin handle,channels,stepSize,blockSize.");
-	return NULL;
-    }
-
-    Plugin *plugin;
-    string *key;
-
-    if ( !getPluginHandle(pyPluginHandle, &plugin, &key) ) {
-	PyErr_SetString(PyExc_TypeError,
-			"Invalid plugin handle.");
-	return NULL; }
-
-    // here we cast the void pointer as PyPluginDescriptor instead of string
-    PyPluginDescriptor *plugDesc = (PyPluginDescriptor*) key;
-
-    plugDesc->channels = channels;
-    plugDesc->stepSize = stepSize;
-    plugDesc->blockSize = blockSize;
-
-    if (!plugin->initialise(channels, stepSize, blockSize)) {
+	return 0;
+    }
+
+    PyPluginData *pd = getPluginData(pyPluginHandle);
+    if (!pd) return 0;
+
+    pd->channels = channels;
+    pd->stepSize = stepSize;
+    pd->blockSize = blockSize;
+
+    if (!pd->plugin->initialise(channels, stepSize, blockSize)) {
         std::cerr << "Failed to initialise native plugin adapter with channels = " << channels << ", stepSize = " << stepSize << ", blockSize = " << blockSize << " and ADAPT_ALL_SAFE set" << std::endl;
 	PyErr_SetString(PyExc_TypeError,
 			"Plugin initialization failed.");
-	return NULL;
-    }
-
-    plugDesc->identifier =
-	plugDesc->key.substr(plugDesc->key.rfind(':')+1);
-    plugDesc->isInitialised = true;
+	return 0;
+    }
+
+    pd->isInitialised = true;
 
     return Py_True;
 }
 
 /* RUN PROCESS */

 			  &pyPluginHandle,	// C object holding a pointer to a plugin and its descriptor
 			  &pyBuffer,			// Audio data
 			  &pyRealTime)) {		// TimeStamp
 	PyErr_SetString(PyExc_TypeError,
 			"Required: plugin handle, buffer, timestmap.");
-	return NULL; }
+	return 0; }
 
     if (!PyRealTime_Check(pyRealTime)) {
 	PyErr_SetString(PyExc_TypeError,"Valid timestamp required.");
-	return NULL; }
-
-    string *key;
-    Plugin *plugin;
-
-    if (!getPluginHandle(pyPluginHandle, &plugin, &key)) {
-	PyErr_SetString(PyExc_AttributeError,
-			"Invalid or already deleted plugin handle.");
-	return NULL;
-    }
-
-    PyPluginDescriptor *pd = (PyPluginDescriptor*) key;
+	return 0; }
+
+    PyPluginData *pd = getPluginData(pyPluginHandle);
+    if (!pd) return 0;
 
     if (!pd->isInitialised) {
 	PyErr_SetString(PyExc_StandardError,
 			"Plugin has not been initialised.");
-	return NULL; }
+	return 0;
+    }
 
     int channels =  pd->channels;
 //    int blockSize = pd->blockSize;
 
     if (!PyList_Check(pyBuffer)) {
 	PyErr_SetString(PyExc_TypeError, "List of NumPy Array required for process input.");
-        return NULL;
+        return 0;
     }
 
     if (PyList_GET_SIZE(pyBuffer) != channels) {
         std::cerr << "Wrong number of channels: got " << PyList_GET_SIZE(pyBuffer) << ", expected " << channels << std::endl;
 	PyErr_SetString(PyExc_TypeError, "Wrong number of channels");
-        return NULL;
+        return 0;
     }
 
     float **inbuf = new float *[channels];
 
     PyTypeConversions typeConv;

     }
 
     RealTime timeStamp = *PyRealTime_AsRealTime(pyRealTime);
 
     //Call process and store the output
-    pd->output = plugin->process(inbuf, timeStamp);
+    pd->output = pd->plugin->process(inbuf, timeStamp);
 
     /* TODO:  DO SOMETHONG WITH THE FEATURE SET HERE */
 /// convert to appropriate python objects, reuse types and conversion utilities from Vampy ...
 
     delete[] inbuf;
 
-    return NULL; //!!! Need to return actual features!
+    return 0; //!!! Need to return actual features!
 
 }
 
 /* GET / SET OUTPUT */
 

     if (!PyArg_ParseTuple(args, "OO",
 			  &pyPluginHandle,	// C object holding a pointer to a plugin and its descriptor
 			  &pyOutput)) {		// Output reference
 	PyErr_SetString(PyExc_TypeError,
 			"Required: plugin handle, buffer, timestmap.");
-	return NULL; }
-
-    string *key;
-    Plugin *plugin;
-
-    if ( !getPluginHandle(pyPluginHandle, &plugin, &key) ) {
-	PyErr_SetString(PyExc_AttributeError,
-			"Invalid or already deleted plugin handle.");
-	return NULL; }
-
-    PyPluginDescriptor *pd = (PyPluginDescriptor*) key;
+	return 0; }
+
+    PyPluginData *pd = getPluginData(pyPluginHandle);
+    if (!pd) return 0;
 
     unsigned int outputNo = (unsigned int) PyInt_AS_LONG(pyOutput);
 
     //Get output list: but we don't need it
     //Plugin::FeatureList features = pd->output[outputNo];

 
     for (size_t i = 0; i < outLength; ++i) {
 	// Test:
 	/*
 	  XxoObject *pyFeature = PyObject_New(XxoObject, &Xxo_Type);
-	  if (pyFeature == NULL) break; //return NULL;
-
-	  pyFeature->x_attr = NULL;
+	  if (pyFeature == 0) break; //return 0;
+
+	  pyFeature->x_attr = 0;
 	  pyFeature->feature = &pd->output[outputNo][i];
 
 	  PyList_SET_ITEM(pyFeatureList,i,(PyObject*)pyFeature);
 	*/
     }

     //     Plugin::OutputList outputs = plugin->getOutputDescriptors();
     //
     // if (outputs.size()<1) {
     // 	string pyerr("Plugin has no output: "); pyerr += pluginKey;
     // 	PyErr_SetString(PyExc_TypeError,pyerr.c_str());
-    // 	return NULL;
+    // 	return 0;
     // }
     //
     // //New list object
     // PyObject *pyList = PyList_New(outputs.size());
     //

      PyDoc_STR("frame2RealTime((int64)frame, (uint32)sampleRate ) -> returns new RealTime object from frame.")},
 
     {"realtime",	(PyCFunction)RealTime_new,		METH_VARARGS,
      PyDoc_STR("realtime() -> returns new RealTime object")},
 */
-    {NULL,		NULL}		/* sentinel */
+    {0,		0}		/* sentinel */
 };
 
 //Documentation for our new module
 PyDoc_STRVAR(module_doc, "This is a template module just for instruction.");
 

 	return;
 //	PyModule_AddObject(m, "Real_Time", (PyObject *)&RealTime_Type);
 
     /* Create the module and add the functions */
     m = Py_InitModule3("vampyhost", vampyhost_methods, module_doc);
-    if (m == NULL) return;
+    if (!m) return;
 
     import_array();
 
     // PyModule_AddObject(m, "realtime", (PyObject *)&RealTime_Type);