comparison PyPlugin.cpp @ 3:134313c59d82

* Add global mutex to PyPlugin -- all plugin method calls are strictly
  serialised in order to avoid problems with Python interpreter's lack of
  thread safety.

 		support multiple plugins per script in scanner
 		ensure proper cleanup, host do a good job though
 
 */
 
-//#include "Python.h"
-#include "/usr/include/python/Python.h"
+#include <Python.h>
 #include "PyPlugin.h"
 
 #ifdef _WIN32
 #define pathsep ('\\')
 #else 

 using std::vector;
 using std::cerr;
 using std::endl;
 using std::map;
 
-extern volatile bool mutex;
-
 // Maps to associate strings with enum values
 static std::map<std::string, eOutDescriptors> outKeys;
 static std::map<std::string, eSampleTypes> sampleKeys;
 static std::map<std::string, eFeatureFields> ffKeys;
 static std::map<std::string, p::eParmDescriptors> parmKeys;
+
+Mutex PyPlugin::m_pythonInterpreterMutex;
 
 void initMaps()
 {
 	outKeys["identifier"] = identifier;
 	outKeys["name"] = name;

     m_previousSample(0.0f),
 	m_plugin(pluginKey),
 	m_class(pluginKey.substr(pluginKey.rfind(':')+1,pluginKey.size()-1)),
 	m_path((pluginKey.substr(0,pluginKey.rfind(pathsep))))
 {	
-
-/*TODO: this is a nasty way of ensuring the process is 
-finished before we create a new instance accessing the Python/C API.
-The Python/C API is not fully thread safe. 
-Calling into a python class while the process is doing heavy 
-computation may cause segmentation fault. 
-Manipulating the GIL and thread states only gave me a grief so far.*/
-	
-	if (mutex) {
-		cerr << "PyPlugin::PyPlugin:" << m_class 
-		<< " Warning: Waiting for clear signal from parallel process." << endl;
-		while (mutex) { }
-	}	
 }
 
 PyPlugin::~PyPlugin()
 {
 	cerr << "PyPlugin::PyPlugin:" << m_class 
 	<< " Instance deleted." << endl;
-	//for safety only. has been cleared after process.
-	mutex = false;	
 }
 
 
 string
 PyPlugin::getIdentifier() const
 {	
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getIdentifier"; 
 	cerr << "[call] " << method << endl;
 	string rString="VampPy-x";
 
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {

 
 
 string
 PyPlugin::getName() const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
 
 	char method[]="getName";
 	cerr << "[call] " << method << endl;
 	string rString="VamPy Plugin (Noname)";
 	

 }
 
 string
 PyPlugin::getDescription() const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getDescription";
 	cerr << "[call] " << method << endl;
 	string rString="Not given. (Hint: Implement getDescription method.)";
 	
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {

 }
 
 string
 PyPlugin::getMaker() const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getMaker";
 	cerr << "[call] " << method << endl;
 	string rString="Generic VamPy Plugin.";
 	
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {

 }
 
 string
 PyPlugin::getCopyright() const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getCopyright";
 	cerr << "[call] " << method << endl;
 	string rString="BSD License";
 	
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {

 
 
 bool
 PyPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
     if (channels < getMinChannelCount() ||
 	channels > getMaxChannelCount()) return false;
 
     m_stepSize = std::min(stepSize, blockSize);
 	char method[]="initialise";

 }
 
 void
 PyPlugin::reset()
 {
+	//!!! implement this!
     m_previousSample = 0.0f;
 }
 
 PyPlugin::InputDomain PyPlugin::getInputDomain() const 
 { 
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getInputDomain";
 	cerr << "[call] " << method << endl;
 	PyPlugin::InputDomain rValue = TimeDomain; // TimeDomain
 	
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {

     return rValue; 
 }
 
 size_t PyPlugin::getPreferredBlockSize() const 
 { 
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getPreferredBlockSize";
 	cerr << "[call] " << method << endl;
 	size_t rValue=0; //not set by default
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {
 		PyObject *pyInt = PyObject_CallMethod(m_pyInstance, method, NULL);

 }
 
 //size_t PyPlugin::getPreferredStepSize() const { return 0; }
 size_t PyPlugin::getPreferredStepSize() const 
 { 
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getPreferredStepSize";
 	cerr << "[call] " << method << endl;
 	size_t rValue=0; //not set by default
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {
 		PyObject *pyInt = PyObject_CallMethod(m_pyInstance, method, NULL);

     return rValue; 
 }
 
 size_t PyPlugin::getMinChannelCount() const 
 { 
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getMinChannelCount";
 	cerr << "[call] " << method << endl;
 	size_t rValue=1; //default value
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {
 		PyObject *pyInt = PyObject_CallMethod(m_pyInstance, method, NULL);

     return rValue; 
 }
 
 size_t PyPlugin::getMaxChannelCount() const 
 { 
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getMaxChannelCount";	
 	cerr << "[call] " << method << endl;
 	size_t rValue=1; //default value
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {
 		PyObject *pyInt = PyObject_CallMethod(m_pyInstance, method, NULL);

 
 
 PyPlugin::OutputList
 PyPlugin::getOutputDescriptors() const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	//PyEval_AcquireThread(newThreadState);
 	OutputList list;
 	OutputDescriptor od;
 	char method[]="getOutputDescriptors";
 	cerr << "[call] " << method << endl;

 }
 
 PyPlugin::ParameterList
 PyPlugin::getParameterDescriptors() const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	ParameterList list;
 	ParameterDescriptor pd;
 	char method[]="getParameterDescriptors";
 	cerr << "[call] " << method << endl;
 

 	return list;
 }
 
 void PyPlugin::setParameter(std::string paramid, float newval)
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="setParameter";
 	cerr << "[call] " << method << endl;
 
 		//Check if the method is implemented in Python
 		if (PyObject_HasAttrString(m_pyInstance,method)) {

 		}
 }
 
 float PyPlugin::getParameter(std::string paramid) const
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	char method[]="getParameter";
 	cerr << "[call] " << method << endl;
 	float rValue = 0.0f;
 	
 		//Check if the method is implemented in Python

 
 PyPlugin::FeatureSet
 PyPlugin::process(const float *const *inputBuffers,
                       Vamp::RealTime timestamp)
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
     if (m_stepSize == 0) {
 	cerr << "ERROR: PyPlugin::process: "
 	     << "Plugin has not been initialised" << endl;
 	return FeatureSet();
     }
-	mutex = true;
 	static char method[]="process";
 
 #ifdef _DEBUG	
 	cerr << "[call] " << method << " frame:" << proccounter << endl;
 	proccounter++;

 				cerr << "ERROR: In Python plugin [" << m_class << "::" << method 
 				<< "] Expected List return type." << endl;				
 			}
 			Py_CLEAR(pyMethod);
 			Py_CLEAR(pyOutputList);
-			mutex = false;
 			return FeatureSet();
 		}
 			
 		Py_DECREF(pyMethod);
 		// Py_DECREF(pyList); 

 
 			}// for j = FeatureList			
 
 		}//for i = FeatureSet
 		Py_CLEAR(pyOutputList);
-		mutex = false;
 		return returnFeatures;
 
 	}//if (has_attribute)
-	mutex = false;
 	return FeatureSet(); 
 }
 
 
 
 PyPlugin::FeatureSet
 PyPlugin::getRemainingFeatures()
 {
+	MutexLocker locker(&m_pythonInterpreterMutex);
+
 	static char method[]="getRemainingFeatures";
 	cerr << "[call] " << method << endl;
 
 	//check if the method is implemented
-	mutex = true;
 	if ( ! PyObject_HasAttrString(m_pyInstance,method) ) {
 		return FeatureSet(); 
 		}
 			
 		PyObject *pyMethod = PyString_FromString(method);		

 				cerr << "ERROR: In Python plugin [" << m_class << "::" << method 
 				<< "] Expected List return type." << endl;				
 			}
 			Py_CLEAR(pyMethod);
 			Py_CLEAR(pyOutputList);
-			mutex = false;
 			return FeatureSet();
 		}
 		Py_DECREF(pyMethod);
 	
 		PyObject *pyFeatureList, *pyDict, *pyKey, *pyValue;

 				if (emptyFeature) cerr << "Warning: This feature is empty or badly formatted." << endl;
 				else returnFeatures[i].push_back(feature);
 			}// for j 			
 		}//for i 
 		Py_CLEAR(pyOutputList);
-		mutex = false;
 		return returnFeatures;
 }