comparison PyExtensionModule.cpp @ 31:4f1894c7591b vampy2

Created Vampy2 branch

+#include <Python.h>
+#include "PyExtensionModule.h"
+#include "PyRealTime.h"
+#include "PyFeature.h"
+#include "PyFeatureSet.h"
+#include "PyParameterDescriptor.h"
+#include "PyOutputDescriptor.h"
+#include "vamp-sdk/Plugin.h"
+
+using namespace std;
+using namespace Vamp;
+using Vamp::Plugin;
+using Vamp::RealTime;
+
+/* Simple Example Function */
+
+static int five=5;
+
+PyObject*
+get_five(PyObject *self, PyObject *args)
+{
+    if(!PyArg_ParseTuple(args, ":five")) return NULL;
+    return Py_BuildValue("i", five);
+}
+
+
+/*			 Functions Exposed by Vampy 					*/
+
+/*			 Creating PyRealTime Objects 					*/
+
+
+/* New RealTime object from Frame (with given samplerate) */
+static PyObject *
+RealTime_frame2RealTime(PyObject *ignored, PyObject *args)
+{
+	long frame;
+	unsigned int sampleRate;
+
+    if (!PyArg_ParseTuple(args, "lI:realtime.frame2RealTime ", 
+	&frame,&sampleRate))
+		return NULL;
+
+	RealTimeObject *self;
+	self = PyObject_New(RealTimeObject, &RealTime_Type); 
+	if (self == NULL) return NULL;
+
+	self->rt = new RealTime::RealTime(
+	RealTime::frame2RealTime(frame,sampleRate));
+
+	return (PyObject *) self;
+}
+
+/*			 Creating PyParameterDescriptor Objects 			  	*/
+
+/* New ParameterDescriptor object 
+static PyObject *
+ParameterDescriptor_new(PyObject *ignored, PyObject *args)
+{
+
+    if (!PyArg_ParseTuple(args, ":ParameterDescriptor")) { 
+		PyErr_SetString(PyExc_TypeError, 
+		"Error: ParameterDescriptor initialised with arguments.");
+		return NULL; 
+	  }
+
+	ParameterDescriptorObject *self = 
+	PyObject_New(ParameterDescriptorObject, &ParameterDescriptor_Type); 
+	if (self == NULL) return NULL;
+    self->dict = PyDict_New();
+	if (self->dict == NULL) return NULL;
+	return (PyObject *) self;
+}
+*/
+
+/*			 Creating PyOutputDescriptor Objects 					*/
+
+/* New OutputDescriptor object 
+static PyObject *
+OutputDescriptor_new(PyObject *ignored, PyObject *args)
+{
+
+	if (!PyArg_ParseTuple(args, ":OutputDescriptor")) { 
+		PyErr_SetString(PyExc_TypeError, 
+		"Error: OutputDescriptor initialised with arguments.");
+		return NULL; 
+	  }
+
+	OutputDescriptorObject *self = 
+	PyObject_New(OutputDescriptorObject, &OutputDescriptor_Type); 
+	if (self == NULL) return NULL;
+    self->dict = PyDict_New();
+	if (self->dict == NULL) return NULL;
+	return (PyObject *) self;
+}
+*/
+
+/*			 Creating PyOutputList Objects 					*/
+
+/* New OutputList object */
+static PyObject *
+OutputList_new(PyObject *ignored, PyObject *args)
+{
+	if (!PyArg_ParseTuple(args, ":OutputList")) { 
+		PyErr_SetString(PyExc_TypeError, 
+		"Error: OutputList initialised with arguments.");
+		return NULL; 
+	  }
+
+	return (PyObject *) PyList_New(0);
+}
+
+
+/*			 Creating PyParameterList Objects 					*/
+
+/* New ParameterList object */
+static PyObject *
+ParameterList_new(PyObject *ignored, PyObject *args)
+{
+    if (!PyArg_ParseTuple(args, ":ParameterList")) { 
+		PyErr_SetString(PyExc_TypeError, 
+		"Error: ParameterList initialised with arguments.");
+		return NULL; 
+	  }
+	return (PyObject *) PyList_New(0);
+}
+
+
+/*			 Creating PyFeatureList Objects 					*/
+
+/* New FeatureList object 
+static PyObject *
+FeatureList_new(PyObject *ignored, PyObject *args)
+{
+	if (!PyArg_ParseTuple(args, ":FeatureList")) { 
+		PyErr_SetString(PyExc_TypeError, 
+		"Error: FeatureList initialised with arguments.");
+		return NULL; 
+	  }
+	return (PyObject *) PyList_New(0);
+}
+*/
+
+/*			 Creating PyFeatureSet Objects 					*/
+
+/* New FeatureSet object 
+static PyObject *
+FeatureSet_new(PyObject *ignored, PyObject *args)
+{
+	if (!PyArg_ParseTuple(args, ":FeatureSet")) { 
+		PyErr_SetString(PyExc_TypeError, 
+		"Error: FeatureSet initialised with arguments.");
+		return NULL; 
+	  }
+	return (PyObject *) PyDict_New();
+}
+*/
+
+
+/*		 	Declare the methods exposed by the vampy module 		*/
+
+
+PyMethodDef VampyMethods[] = {
+/*NOTE: This is conventionally static, but limiting the scope
+	here will cause seg fault if the declared functions are 
+	called back from a Python function wrapped in a C++ class.*/
+    {"five", get_five, METH_VARARGS, "Return a number."},
+
+	{"frame2RealTime",	(PyCFunction)RealTime_frame2RealTime,	METH_VARARGS,
+		PyDoc_STR("frame2RealTime((int64)frame, (uint32)sampleRate ) -> returns new RealTime object from frame.")},
+
+	/*{"RealTime",	RealTime_new,		METH_VARARGS,
+		PyDoc_STR("RealTime() -> returns new RealTime object")},*/
+
+	/*{"Feature",	Feature_new,		METH_VARARGS,
+		PyDoc_STR("Feature() -> returns new Feature object")},*/
+
+	/*{"ParameterDescriptor",	ParameterDescriptor_new,		METH_VARARGS,
+		PyDoc_STR("ParameterDescriptor() -> returns new ParameterDescriptor object")},
+
+	{"OutputDescriptor",	OutputDescriptor_new,		METH_VARARGS,
+		PyDoc_STR("OutputDescriptor() -> returns new OutputDescriptor object")},
+
+	{"FeatureList",	FeatureList_new,		METH_VARARGS,
+		PyDoc_STR("FeatureList() -> returns new FeatureList object")},*/
+
+	{"OutputList",	OutputList_new,		METH_VARARGS,
+		PyDoc_STR("OutputList() -> returns new OutputList object")},
+
+	{"ParameterList",	ParameterList_new,		METH_VARARGS,
+		PyDoc_STR("ParameterList() -> returns new ParameterList object")},
+
+    {NULL, NULL, 0, NULL} 
+};
+
+/* Module Documentation */
+// PyDoc_STRVAR(vampy_doc,"This module exposes Vamp plugin data type wrappers.");
+
+PyMODINIT_FUNC
+initvampy(void)
+{
+	PyObject* module;
+
+	// if (PyType_Ready(&Feature_Type) < 0) return;
+	/// Why do we get a segfault if this is initialised here?
+	/*PyType_Ready adds these object to the GC.
+	This is OK for an extension module, but it is a mistake here, 
+	because the reference count will be decremented in the Vamp 
+	wrapper plugin outside the interpreter.
+	When the GC tries to visit a deallocated object, it will throw up.*/
+	
+	RealTime_Type.ob_type = &PyType_Type;
+	Feature_Type.ob_type = &PyType_Type;
+	OutputDescriptor_Type.ob_type = &PyType_Type;
+	ParameterDescriptor_Type.ob_type = &PyType_Type;
+	initFeatureSetType(); /// this is derived from the builtin dict
+
+	PyImport_AddModule("vampy");
+	module = Py_InitModule("vampy", VampyMethods);
+	if (!module) return;
+	
+	Py_INCREF(&RealTime_Type);
+    PyModule_AddObject(module,"RealTime",(PyObject*)&RealTime_Type);
+	// Py_INCREF(&RealTime_Type);
+
+	Py_INCREF((PyObject*)&Feature_Type);
+	PyModule_AddObject(module,"Feature",(PyObject*)&Feature_Type);
+	// Py_INCREF((PyObject*)&Feature_Type);
+
+	Py_INCREF((PyObject*)&FeatureSet_Type);
+	PyModule_AddObject(module,"FeatureSet",(PyObject*)&FeatureSet_Type);
+	// Py_INCREF((PyObject*)&FeatureSet_Type);
+
+	Py_INCREF((PyObject*)&OutputDescriptor_Type);
+	PyModule_AddObject(module,"OutputDescriptor",(PyObject*)&OutputDescriptor_Type);
+
+	Py_INCREF((PyObject*)&ParameterDescriptor_Type);
+	PyModule_AddObject(module,"ParameterDescriptor",(PyObject*)&ParameterDescriptor_Type);
+	
+	cerr << "Vampy: extension module initialised." << endl;
+}
+
+/*
+NOTE: Why do we need to clean up the module?
+
+The module exposed by Vampy to the embedded interpreter
+contains callback functions. These functions are accessed
+via function pointers stored in the extension module dictionary.
+
+Unfortunately, when the Vampy shared library is unloaded and
+reloaded again during a host session, these addresses might
+change. Therefore, we reinitialise the module dict before 
+each use. However, this will cause garbage collection errors
+or segmentation faults, when elements of the dict of the 
+previous session are attempted to free. Therefore, we hold
+a global reference count to all initialised Vampy plugins,
+and when this reaches zero, we clean up the module dict.
+
+This is an attempt to catch the moment when the shared lib
+is finally unloaded and the references are still point to valid
+memory addresses.
+
+Why doesn't the GC clean this up correctly?
+
+In a normal Python session the GC would deallocate the module
+dict at the end. In embedded python, although the GC appears
+to be called when the shared lib is unloaded, the interpreter
+is reused. Since there is no C/API call to unload modules,
+and at the time of unloading vampy the wrapped function pointers
+are still valid, the GC doesn't collect them, nor are they freed
+by the interpreter. When vampy is reloaded however, the module
+dict will contain invalid addresses. The above procedure solves
+this problem.
+
+
+*/
+
+void cleanModule(void)
+{
+	PyObject *m = PyImport_AddModule("vampy");
+	if (!m) cerr << "Destr: PyImport_AddModule returned NULL!" << endl;
+	else {
+		// cerr << "Destr: Add module found existing." << endl;
+		PyObject *dict = PyModule_GetDict(m);
+		Py_ssize_t ln = PyDict_Size(dict);
+		cerr << "Destr: Size of module dict = " << (int) ln << endl;
+		/// Clean the module dictionary.
+		PyDict_Clear(dict);
+	    ln = PyDict_Size(dict);
+		cerr << "Destr: Cleaned size of module dict = " << (int) ln << endl;
+	}
+}
+