comparison vampyhost.cpp @ 21:4b4a7ec1080d

Replace the pointer-holding CObject with a "real" Python object (next up: methods and attributes)

 using Vamp::HostExt::PluginLoader;
 
 #define HOST_VERSION "1.1"
 
 // structure for holding plugin instance data
-struct PyPluginData
-{
+struct PyPluginObject
+{
+    PyObject_HEAD
+    /*    
     PyPluginData(string k, Plugin *p, float rate) :
         key(k),
         plugin(p),
         inputSampleRate(rate),
         isInitialised(false),
         channels(0),
         blockSize(0),
         stepSize(0) {
     }
-    
-    string key;
+    */    
+    string *key;
     Plugin *plugin;
     float inputSampleRate;
     bool isInitialised;
     size_t channels;
     size_t blockSize;
     size_t stepSize;
+    static PyPluginObject *create_internal();
 };
+
+PyAPI_DATA(PyTypeObject) Plugin_Type;
+#define PyPlugin_Check(v) PyObject_TypeCheck(v, &Plugin_Type)
+    
+static void
+PyPluginObject_dealloc(PyPluginObject *self)
+{
+    cerr << "PyPluginObject_dealloc" << endl;
+    delete self->key;
+    delete self->plugin;
+    PyObject_Del(self);
+}
 
 /* MODULE HELPER FUNCTIONS */
 PyDoc_STRVAR(xx_foo_doc, "Some description"); //!!!
 
-//!!! 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);
+PyPluginObject *
+getPluginObject(PyObject *pyPluginHandle)
+{
+    cerr << "getPluginObject" << endl;
+
+    PyPluginObject *pd = 0;
+    if (PyPlugin_Check(pyPluginHandle)) {
+        pd = (PyPluginObject *)pyPluginHandle;
     }
     if (!pd || !pd->plugin) {
         PyErr_SetString(PyExc_AttributeError,
 			"Invalid or already deleted plugin handle.");
         return 0;

 }
 
 static PyObject *
 vampyhost_enumeratePlugins(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_enumeratePlugins" << endl;
+
     PluginLoader *loader = PluginLoader::getInstance();
     vector<PluginLoader::PluginKey> plugins = loader->listPlugins();
     PyTypeConversions conv;
     return conv.PyValue_From_StringVector(plugins);
 }
 
 static PyObject *
 vampyhost_getPluginPath(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_getPluginPath" << endl;
+
     vector<string> path = PluginHostAdapter::getPluginPath();
     PyTypeConversions conv;
     return conv.PyValue_From_StringVector(path);
 }
 
 static string toPluginKey(PyObject *pyPluginKey)
 {
+    cerr << "toPluginKey" << endl;
+
     //convert to stl string
     string pluginKey(PyString_AS_STRING(pyPluginKey));
 
     //check pluginKey Validity
     string::size_type ki = pluginKey.find(':');

 }
 
 static PyObject *
 vampyhost_getLibraryFor(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_getLibraryFor" << endl;
+
     PyObject *pyPluginKey;
 
     if (!PyArg_ParseTuple(args, "S", &pyPluginKey)) {
 	PyErr_SetString(PyExc_TypeError,
 			"getLibraryPathForPlugin() takes plugin key (string) argument");

 }
 
 static PyObject *
 vampyhost_getPluginCategory(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_getPluginCategory" << endl;
+
     PyObject *pyPluginKey;
 
     if (!PyArg_ParseTuple(args, "S", &pyPluginKey)) {
 	PyErr_SetString(PyExc_TypeError,
 			"getPluginCategory() takes plugin key (string) argument");

 }
 
 static PyObject *
 vampyhost_getOutputList(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_getOutputList" << endl;
+
     PyObject *keyOrHandle;
     Plugin::OutputList outputs;
 
     if (!PyArg_ParseTuple(args, "O", &keyOrHandle)) {
 	PyErr_SetString(PyExc_TypeError,

         
     } else {
 
         // we have a loaded plugin handle
         
-        PyPluginData *pd = getPluginData(keyOrHandle);
+        PyPluginObject *pd = getPluginObject(keyOrHandle);
         if (!pd) return 0;
 
         outputs = pd->plugin->getOutputDescriptors();
     }
 

 }
 
 static PyObject *
 vampyhost_loadPlugin(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_loadPlugin" << endl;
+
     PyObject *pyPluginKey;
     float inputSampleRate;
 
     if (!PyArg_ParseTuple(args, "Sf",
 			  &pyPluginKey,

 	string pyerr("Failed to load plugin: "); pyerr += pluginKey;
 	PyErr_SetString(PyExc_TypeError,pyerr.c_str());
 	return 0;
     }
 
-    PyPluginData *pd = new PyPluginData(pluginKey, plugin, inputSampleRate);
-    return PyCObject_FromVoidPtr(pd, 0);
+    PyPluginObject *pd = PyPluginObject::create_internal();
+    pd->key = new string(pluginKey);
+    pd->plugin = plugin;
+    pd->inputSampleRate = inputSampleRate;
+    pd->isInitialised = false;
+    pd->channels = 0;
+    pd->blockSize = 0;
+    pd->stepSize = 0;
+    return (PyObject *)pd;
 }
 
 static PyObject *
 vampyhost_unloadPlugin(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_unloadPlugin" << endl;
+    
     PyObject *pyPluginHandle;
 
     if (!PyArg_ParseTuple(args, "O", &pyPluginHandle)) {
 	PyErr_SetString(PyExc_TypeError,
 			"unloadPlugin() takes plugin handle (object) argument");
 	return 0;
     }
 
-    PyPluginData *pd = getPluginData(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(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;
+    pd->plugin = 0; // This is checked by getPluginObject, so we 
+                    // attempt to avoid repeated calls from blowing up
+
+    return Py_True;
 }
 
 static PyObject *
 vampyhost_initialise(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_initialise" << endl;
+    
     PyObject *pyPluginHandle;
     size_t channels, blockSize, stepSize;
 
     if (!PyArg_ParseTuple (args, "Onnn",  &pyPluginHandle,
 			   (size_t) &channels,

 	PyErr_SetString(PyExc_TypeError,
 			"initialise() takes plugin handle (object), channel count, step size, and block size arguments");
 	return 0;
     }
 
-    PyPluginData *pd = getPluginData(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(pyPluginHandle);
     if (!pd) return 0;
 
     pd->channels = channels;
     pd->stepSize = stepSize;
     pd->blockSize = blockSize;

 }
 
 static PyObject *
 vampyhost_reset(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_reset" << endl;
+    
     PyObject *pyPluginHandle;
 
     if (!PyArg_ParseTuple (args, "O",  &pyPluginHandle))
     {
 	PyErr_SetString(PyExc_TypeError,
 			"initialise() takes plugin handle (object) argument");
 	return 0;
     }
 
-    PyPluginData *pd = getPluginData(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(pyPluginHandle);
     if (!pd) return 0;
 
     if (!pd->isInitialised) {
         PyErr_SetString(PyExc_StandardError,
                         "Plugin has not been initialised");

 }
 
 static PyObject *
 vampyhost_getParameter(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_getParameter" << endl;
+
     PyObject *pyPluginHandle;
     PyObject *pyParam;
 
     if (!PyArg_ParseTuple(args, "OS", &pyPluginHandle, &pyParam)) {
 	PyErr_SetString(PyExc_TypeError,
 			"getParameter() takes plugin handle (object) and parameter id (string) arguments");
 	return 0; }
 
-    PyPluginData *pd = getPluginData(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(pyPluginHandle);
     if (!pd) return 0;
 
     float value = pd->plugin->getParameter(PyString_AS_STRING(pyParam));
     return PyFloat_FromDouble(double(value));
 }
 
 static PyObject *
 vampyhost_setParameter(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_setParameter" << endl;
+
     PyObject *pyPluginHandle;
     PyObject *pyParam;
     float value;
 
     if (!PyArg_ParseTuple(args, "OSf", &pyPluginHandle, &pyParam, &value)) {
 	PyErr_SetString(PyExc_TypeError,
 			"setParameter() takes plugin handle (object), parameter id (string), and value (float) arguments");
 	return 0; }
 
-    PyPluginData *pd = getPluginData(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(pyPluginHandle);
     if (!pd) return 0;
 
     pd->plugin->setParameter(PyString_AS_STRING(pyParam), value);
     return Py_True;
 }
 
 static PyObject *
 vampyhost_process(PyObject *self, PyObject *args)
 {
+    cerr << "vampyhost_process" << endl;
+
     PyObject *pyPluginHandle;
     PyObject *pyBuffer;
     PyObject *pyRealTime;
 
     if (!PyArg_ParseTuple(args, "OOO",

     if (!PyList_Check(pyBuffer)) {
 	PyErr_SetString(PyExc_TypeError, "List of NumPy Array required for process input.");
         return 0;
     }
 
-    PyPluginData *pd = getPluginData(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(pyPluginHandle);
     if (!pd) return 0;
 
     if (!pd->isInitialised) {
 	PyErr_SetString(PyExc_StandardError,
 			"Plugin has not been initialised.");

     cerr << "no you fool, here!"  << endl;
     
     return pyFs;
 }
 
+static PyMethodDef PyPluginObject_methods[] =
+{
+    {0, 0}
+};
+
+/* Doc:: 10.3 Type Objects */ /* static */ 
+PyTypeObject Plugin_Type = 
+{
+    PyObject_HEAD_INIT(NULL)
+    0,						/*ob_size*/
+    "vampyhost.Plugin",				/*tp_name*/
+    sizeof(PyPluginObject),	/*tp_basicsize*/
+    0,		/*tp_itemsize*/
+    (destructor)PyPluginObject_dealloc, /*tp_dealloc*/
+    0,						/*tp_print*/
+    0, /*tp_getattr*/
+    0, /*tp_setattr*/
+    0,						/*tp_compare*/
+    0,			/*tp_repr*/
+    0,	/*tp_as_number*/
+    0,						/*tp_as_sequence*/
+    0,						/*tp_as_mapping*/
+    0,						/*tp_hash*/
+    0,                      /*tp_call*/
+    0,                      /*tp_str*/
+    0,                      /*tp_getattro*/
+    0,                      /*tp_setattro*/
+    0,                      /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT,     /*tp_flags*/
+    "Plugin Object",      /*tp_doc*/
+    0,                      /*tp_traverse*/
+    0,                      /*tp_clear*/
+    0,                      /*tp_richcompare*/
+    0,                      /*tp_weaklistoffset*/
+    0,                      /*tp_iter*/
+    0,                      /*tp_iternext*/
+    PyPluginObject_methods,       /*tp_methods*/ 
+    0,                      /*tp_members*/
+    0,                      /*tp_getset*/
+    0,                      /*tp_base*/
+    0,                      /*tp_dict*/
+    0,                      /*tp_descr_get*/
+    0,                      /*tp_descr_set*/
+    0,                      /*tp_dictoffset*/
+    0,                      /*tp_init*/
+    PyType_GenericAlloc,         /*tp_alloc*/
+    0,           /*tp_new*/
+    PyObject_Del,			/*tp_free*/
+    0,                      /*tp_is_gc*/
+};
 
 // module methods table
 static PyMethodDef vampyhost_methods[] = {
 
     {"listPlugins",	vampyhost_enumeratePlugins,	METH_NOARGS,

     {"unloadPlugin",	vampyhost_unloadPlugin, METH_VARARGS,
      xx_foo_doc},
 
     {0,		0}		/* sentinel */
 };
+
+PyPluginObject *
+PyPluginObject::create_internal()
+{
+    return (PyPluginObject *)PyType_GenericAlloc(&Plugin_Type, 0);
+}
 
 //Documentation for our new module
 PyDoc_STRVAR(module_doc, "This is a template module just for instruction.");