comparison vampyhost.cpp @ 23:9dc444c79aa5

Pull out the functions that act on a plugin from module to plugin object scope. Also reverse previous decision to remove unload(), I think it is needed

 
 // structure for holding plugin instance data
 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;
     Plugin *plugin;
     float inputSampleRate;
     bool isInitialised;
     size_t channels;

     delete self->key;
     delete self->plugin;
     PyObject_Del(self);
 }
 
-/* MODULE HELPER FUNCTIONS */
 PyDoc_STRVAR(xx_foo_doc, "Some description"); //!!!
 
 PyPluginObject *
 getPluginObject(PyObject *pyPluginHandle)
 {

         return pd;
     }
 }
 
 static PyObject *
-vampyhost_enumeratePlugins(PyObject *self, PyObject *args)
+vampyhost_enumeratePlugins(PyObject *self, PyObject *)
 {
     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)
+vampyhost_getPluginPath(PyObject *self, PyObject *)
 {
     cerr << "vampyhost_getPluginPath" << endl;
 
     vector<string> path = PluginHostAdapter::getPluginPath();
     PyTypeConversions conv;

 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,
+    if (!PyArg_ParseTuple (args, "nnn",
 			   (size_t) &channels,
 			   (size_t) &stepSize,
-			   (size_t) &blockSize))
-    {
-	PyErr_SetString(PyExc_TypeError,
-			"initialise() takes plugin handle (object), channel count, step size, and block size arguments");
+			   (size_t) &blockSize)) {
+	PyErr_SetString(PyExc_TypeError,
+			"initialise() takes channel count, step size, and block size arguments");
 	return 0;
     }
 
-    PyPluginObject *pd = getPluginObject(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
     pd->channels = channels;
     pd->stepSize = stepSize;
     pd->blockSize = blockSize;

 
     return Py_True;
 }
 
 static PyObject *
-vampyhost_reset(PyObject *self, PyObject *args)
+vampyhost_reset(PyObject *self, PyObject *)
 {
     cerr << "vampyhost_reset" << endl;
     
-    PyObject *pyPluginHandle;
-
-    if (!PyArg_ParseTuple (args, "O",  &pyPluginHandle))
-    {
-	PyErr_SetString(PyExc_TypeError,
-			"initialise() takes plugin handle (object) argument");
-	return 0;
-    }
-
-    PyPluginObject *pd = getPluginObject(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(self);
     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");
+    if (!PyArg_ParseTuple(args, "S", &pyParam)) {
+	PyErr_SetString(PyExc_TypeError,
+			"getParameter() takes parameter id (string) argument");
 	return 0; }
 
-    PyPluginObject *pd = getPluginObject(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(self);
     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");
+    if (!PyArg_ParseTuple(args, "Sf", &pyParam, &value)) {
+	PyErr_SetString(PyExc_TypeError,
+			"setParameter() takes parameter id (string), and value (float) arguments");
 	return 0; }
 
-    PyPluginObject *pd = getPluginObject(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(self);
     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",
-			  &pyPluginHandle,	// C object holding a pointer to a plugin and its descriptor
+    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 (!PyList_Check(pyBuffer)) {
 	PyErr_SetString(PyExc_TypeError, "List of NumPy Array required for process input.");
         return 0;
     }
 
-    PyPluginObject *pd = getPluginObject(pyPluginHandle);
+    PyPluginObject *pd = getPluginObject(self);
     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 PyObject *
+vampyhost_unload(PyObject *self, PyObject *)
+{
+    cerr << "vampyhost_unloadPlugin" << endl;
+    
+    PyPluginObject *pd = getPluginObject(self);
+    if (!pd) return 0;
+
+    delete pd->plugin;
+    pd->plugin = 0; // This is checked by getPluginObject, so we 
+                    // attempt to avoid repeated calls from blowing up
+
+    return Py_True;
+}
+
 static PyMethodDef PyPluginObject_methods[] =
 {
+    {"getParameter",	vampyhost_getParameter, METH_VARARGS,
+     xx_foo_doc}, //!!! fix all these!
+
+    {"setParameter",	vampyhost_setParameter, METH_VARARGS,
+     xx_foo_doc},
+
+    {"initialise",	vampyhost_initialise, METH_VARARGS,
+     xx_foo_doc},
+
+    {"reset",	vampyhost_reset, METH_NOARGS,
+     xx_foo_doc},
+
+    {"process",	vampyhost_process, METH_VARARGS,
+     xx_foo_doc},
+
+    {"unload", vampyhost_unload, METH_NOARGS,
+     xx_foo_doc},
+    
     {0, 0}
 };
+
+static int
+PyPluginObject_setattr(PyPluginObject *self, char *name, PyObject *value)
+{
+    return -1;
+}
+
+static PyObject *
+PyPluginObject_getattr(PyPluginObject *self, char *name)
+{
+    return Py_FindMethod(PyPluginObject_methods, (PyObject *)self, name);
+}
 
 /* Doc:: 10.3 Type Objects */ /* static */ 
 PyTypeObject Plugin_Type = 
 {
     PyObject_HEAD_INIT(NULL)

     "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*/
+    (getattrfunc)PyPluginObject_getattr, /*tp_getattr*/
+    (setattrfunc)PyPluginObject_setattr, /*tp_setattr*/
     0,						/*tp_compare*/
     0,			/*tp_repr*/
     0,	/*tp_as_number*/
     0,						/*tp_as_sequence*/
     0,						/*tp_as_mapping*/

      xx_foo_doc},
 
     {"loadPlugin",	vampyhost_loadPlugin, METH_VARARGS,
      xx_foo_doc},
 
-    {"getParameter",	vampyhost_getParameter, METH_VARARGS,
-     xx_foo_doc},
-
-    {"setParameter",	vampyhost_setParameter, METH_VARARGS,
-     xx_foo_doc},
-
-    {"initialise",	vampyhost_initialise, METH_VARARGS,
-     xx_foo_doc},
-
-    {"reset",	vampyhost_reset, METH_VARARGS,
-     xx_foo_doc},
-
-    {"process",	vampyhost_process, METH_VARARGS,
-     xx_foo_doc},
-
     {0,		0}		/* sentinel */
 };
 
 PyPluginObject *
 PyPluginObject::create_internal()