comparison PyPlugin.cpp @ 8:3af6b5990ad8

more examples and some bug fixes

 */
 
 
 
 /**
- * This Vamp plugin is a wrapper for Python Scripts. (vampy)
+ * This Vamp plugin is a wrapper for Python Scripts. (VamPy)
  * Centre for Digital Music, Queen Mary, University of London.
  * Copyright 2008, George Fazekas.
 
 TODO:	needs more complete error checking 
 	  	needs correct implementation of Python threading

 
 
 bool
 PyPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {
+	//useful for debugging Python plugins
+	char method[]="initialise";
+	cerr << "[call] " << method << endl;
 	
 	//placing Mutex before these calls causes deadlock
     if (channels < getMinChannelCount() ||
 	channels > getMaxChannelCount()) return false;
 	
 	m_inputDomain = getInputDomain();
 
 	MutexLocker locker(&m_pythonInterpreterMutex);
 
-	//useful for debugging Python plugins
-	char method[]="initialise";
-	cerr << "[call] " << method << endl;
-
 	initMaps();
 
 	m_stepSize = stepSize;
 	m_blockSize = blockSize;
 	m_channels = channels;
 
 	//quering process implementation type
 	char legacyMethod[]="process";
 	char numpyMethod[]="processN";
-	m_processType = 0;
-
-	if (PyObject_HasAttrString(m_pyInstance,legacyMethod)) 
+
+	if (PyObject_HasAttrString(m_pyInstance,legacyMethod) &
+		m_processType == 0) 
 	{ 
 		m_processType = legacyProcess;
 		m_pyProcess = PyString_FromString(legacyMethod);
 	}
 
-	if (PyObject_HasAttrString(m_pyInstance,numpyMethod))
+	if (PyObject_HasAttrString(m_pyInstance,numpyMethod) & 
+		m_processType == 0)
 	{
 		m_processType = numpyProcess;
 		m_pyProcess = PyString_FromString(numpyMethod);
 	}
 	

 			PyObject *pyInputSampleRate = PyFloat_FromDouble((double)m_inputSampleRate);
 			
 			//Call the method
 			PyObject *pyBool = 
 			PyObject_CallMethodObjArgs(m_pyInstance,pyMethod,pyChannels,pyStepSize,pyBlockSize,pyInputSampleRate,NULL);
-			
+						
 			Py_DECREF(pyMethod);
 			Py_DECREF(pyChannels);
 			Py_DECREF(pyStepSize);
 			Py_DECREF(pyBlockSize);
 			Py_DECREF(pyInputSampleRate);
 
 			//Check return value
-			if (!PyBool_Check(pyBool)) {
+			if (PyErr_Occurred() || !PyBool_Check(pyBool)) {
+				PyErr_Print(); PyErr_Clear();
 				Py_CLEAR(pyBool);
 				cerr << "ERROR: In Python plugin [" << m_class << "::" << method 
 				<< "] Expected Bool return value." << endl;
 				return false;
 			}

 { 
 	MutexLocker locker(&m_pythonInterpreterMutex);
 
 	char method[]="getPreferredStepSize";
 	cerr << "[call] " << method << endl;
-	size_t rValue=0; //not set by default
+	size_t rValue=1024; //not set by default
 	if ( PyObject_HasAttrString(m_pyInstance,method) ) {
 		PyObject *pyInt = PyObject_CallMethod(m_pyInstance, method, NULL);
 		
 		//Check return value
 		if (!PyInt_Check(pyInt)) {

 		PyObject *pyDict, *pyKey, *pyValue;
 		
 		//Parse Output List
 		for (Py_ssize_t i = 0; i < PyList_GET_SIZE(pyList); ++i) {
 	
-			//Get i-th Vamp output descriptor (Borrowed Reference)
+			//Get i-th VAMP output descriptor (Borrowed Reference)
 			pyDict = PyList_GET_ITEM(pyList,i);
 			
 			//We only care about dictionaries holding output descriptors
 			if ( !PyDict_Check(pyDict) ) continue;
 			

 			while (PyDict_Next(pyDict, &pyPos, &pyKey, &pyValue)) 
 			{		
 				switch (outKeys[PyString_AsString(pyKey)]) 
 				{
 					case not_found : 	
-						cerr << "Unknown key in Vamp OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
+						cerr << "Unknown key in VAMP OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
 						break;
 					case identifier: 	
 						od.identifier = PyString_AsString(pyValue); 
 						break;				
 					case name: 			

 					case sampleType: 				
 						od.sampleType = (OutputDescriptor::SampleType) sampleKeys[PyString_AsString(pyValue)];
 						break;
 					case sampleRate:
 						od.sampleRate = (float) PyFloat_AS_DOUBLE(pyValue);
+//						od.sampleRate = m_inputSampleRate / m_stepSize;
+						cerr << od.sampleRate << endl;
 						break;					
 					default : 	
-						cerr << "Invalid key in Vamp OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
+						cerr << "Invalid key in VAMP OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
 				} 					
 			} // while dict
 			list.push_back(od);
 		} // for list
 		Py_CLEAR(pyList);

 		PyObject *pyDict, *pyKey, *pyValue;
 		
 		//Parse Output List
 		for (Py_ssize_t i = 0; i < PyList_GET_SIZE(pyList); ++i) {
 	
-			//Get i-th Vamp output descriptor (Borrowed Reference)
+			//Get i-th VAMP output descriptor (Borrowed Reference)
 			pyDict = PyList_GET_ITEM(pyList,i);
 			
 			//We only care about dictionaries holding output descriptors
 			if ( !PyDict_Check(pyDict) ) continue;
 			

 			while (PyDict_Next(pyDict, &pyPos, &pyKey, &pyValue)) 
 			{		
 				switch (parmKeys[PyString_AsString(pyKey)]) 
 				{
 					case not_found : 	
-						cerr << "Unknown key in Vamp OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
+						cerr << "Unknown key in VAMP OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
 						break;
 					case p::identifier: 	
 						pd.identifier = PyString_AsString(pyValue); 
 						break;				
 					case p::name: 			

 						break;
 					case p::isQuantized:
 						pd.isQuantized = (bool) PyInt_AS_LONG(pyValue); 
 						break;					
 					default : 	
-						cerr << "Invalid key in Vamp OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
+						cerr << "Invalid key in VAMP OutputDescriptor: " << PyString_AsString(pyKey) << endl; 
 				} 				
 			} // while dict
 			list.push_back(pd);
 		} // for list
 		Py_CLEAR(pyList);

 #ifdef _DEBUG	
 	cerr << "[call] process, frame:" << proccounter << endl;
 	proccounter++;
 #endif
 
-    if (m_blockSize == 0) {
+    if (m_blockSize == 0 || m_channels == 0) {
 	cerr << "ERROR: PyPlugin::process: "
 	     << "Plugin has not been initialised" << endl;
 	return FeatureSet();
     }
 

 	return FeatureSet();
 	}
 
 	string method=PyString_AsString(m_pyProcess);
 
-	
-
 		PyObject *pyOutputList = NULL;
 		
 		/*new numPy support*/
 		if (m_processType == numpyProcess) {
-
-		//declare buffer object
-		PyObject *pyBuffer; 
-
-		//Expose memory using the Buffer Interface of C/API		
-		//This will virtually pass a pointer only that can be 
-		//recasted in Python code             
-		pyBuffer = 
-		PyBuffer_FromMemory((void *) (float *) inputBuffers[0], 
-		(Py_ssize_t) sizeof(float) * m_blockSize);
-		
-		//Call python process (returns new reference)
-		pyOutputList = 
-		PyObject_CallMethodObjArgs(m_pyInstance,m_pyProcess,pyBuffer,NULL);
+			
+			//create a list of buffers
+			PyObject *pyChannelList = PyList_New((Py_ssize_t) m_channels);
+			for (size_t i=0; i < m_channels; ++i) {
+
+				//Expose memory using the Buffer Interface of C/API		
+				//This will virtually pass a pointer which can be 
+				//recasted in Python code as float or complex array             
+				PyObject *pyBuffer = PyBuffer_FromMemory
+				((void *) (float *) inputBuffers[i], 
+				(Py_ssize_t) sizeof(float) * m_blockSize);
+
+			PyList_SET_ITEM(pyChannelList, (Py_ssize_t) i, pyBuffer);
+			}
+
+			//pass RealTime as frameCount
+			PyObject *pyLongSample = PyLong_FromLong (
+			Vamp::RealTime::realTime2Frame 
+			(timestamp, (unsigned int) m_inputSampleRate));
+		
+			//Call python process (returns new reference)
+			pyOutputList = PyObject_CallMethodObjArgs
+			(m_pyInstance,m_pyProcess,pyChannelList,pyLongSample,NULL);
+			
+			Py_DECREF(pyChannelList);
+			Py_DECREF(pyLongSample);
 
 		} 
 		
 		if (m_processType == legacyProcess) { 
 
-		//Declare new list object
-		PyObject *pyFloat, *pyList;
-		pyList = PyList_New((Py_ssize_t) m_blockSize);
-
-		//Pack samples into a Python List Object
-		//pyFloat types will always be new references, 
-		//these will be discarded when the list is deallocated
-		for (size_t i = 0; i < m_blockSize; ++i) {
-		pyFloat=PyFloat_FromDouble((double) inputBuffers[0][i]);
-		PyList_SET_ITEM(pyList, (Py_ssize_t) i, pyFloat);
-		}
-
-		//Call python process (returns new reference)
-		pyOutputList = 
-		PyObject_CallMethodObjArgs(m_pyInstance,m_pyProcess,pyList,NULL);
-						
-		}
-
+			//create a list of lists
+			PyObject *pyChannelList = PyList_New((Py_ssize_t) m_channels);
+			for (size_t i=0; i < m_channels; ++i) {
+
+				//Declare new list object
+				PyObject *pyFloat, *pyList;
+				pyList = PyList_New((Py_ssize_t) m_blockSize);
+
+				//Pack samples into a Python List Object
+				//pyFloat types will always be new references, 
+				//these will be discarded when the list is deallocated
+				for (size_t j = 0; j < m_blockSize; ++j) {
+					pyFloat=PyFloat_FromDouble(
+						(double) inputBuffers[i][j]);
+					PyList_SET_ITEM(pyList, (Py_ssize_t) j, pyFloat);
+				}
+				PyList_SET_ITEM(pyChannelList, (Py_ssize_t) i, pyList);				
+			}
+
+			//pass RealTime as frameCount
+			PyObject *pyLongSample = PyLong_FromLong (
+			Vamp::RealTime::realTime2Frame 
+			(timestamp, (unsigned int) m_inputSampleRate));
+
+			//Call python process (returns new reference)
+			pyOutputList = PyObject_CallMethodObjArgs
+			(m_pyInstance,m_pyProcess,pyChannelList,pyLongSample,NULL);
+			
+			Py_DECREF(pyChannelList);
+			Py_DECREF(pyLongSample);
+
+		}
+
+		//return nothing
+		//Py_CLEAR(pyOutputList);
+		//return FeatureSet();
 
 		//Check return type
 		if (pyOutputList == NULL || !PyList_Check(pyOutputList) ) {
 			if (pyOutputList == NULL) {				
 				cerr << "ERROR: In Python plugin [" << m_class << "::" << method 

 				if (PyErr_Occurred()) { PyErr_Print(); PyErr_Clear(); }
 			} else {
 				cerr << "ERROR: In Python plugin [" << m_class << "::" << method 
 				<< "] Expected List return type." << endl;				
 			}
-			//Py_CLEAR(pyMethod);
 			Py_CLEAR(pyOutputList);
 			return FeatureSet();
 		}
 			
-		//Py_DECREF(pyMethod);
 		// Py_DECREF(pyList); 
 		// This appears to be tracked by the cyclic garbage collector
 		// hence decrefing produces GC error
 #ifdef _DEBUG								
 		cerr << "Process Returned Features" << endl;

 				{	
 					emptyFeature = false;
 					switch (ffKeys[PyString_AsString(pyKey)]) 
 					{
 						case not_found : 	
-							cerr << "Unknown key in Vamp FeatureSet: " 
+							cerr << "Unknown key in VAMP FeatureSet: " 
 							<< PyString_AsString(pyKey) << endl; 
 							break;
 						case hasTimestamp: 	
 							feature.hasTimestamp = (bool) PyInt_AS_LONG(pyValue); 
 							break;				
 						case timeStamp: 			
-							feature.timestamp = timestamp + 
-							Vamp::RealTime::frame2RealTime
-							((size_t)PyInt_AS_LONG(pyValue), (size_t)m_inputSampleRate);
+							feature.timestamp =  
+							Vamp::RealTime::frame2RealTime(
+							PyLong_AsLong(pyValue), 
+							(unsigned int) m_inputSampleRate );
+#ifdef _DEBUG
+							cerr << "Timestamp: " 
+							<< (long)PyLong_AsLong(pyValue) << ", ->" 
+							<< feature.timestamp.toString() << endl;
+#endif
 							break;
 						case values: 	
 							feature.values = PyList_As_FloatVector(pyValue); 
 							break; 								
 						case label: 			
 							feature.label = PyString_AsString(pyValue); 
 							break; 													
 						default : 	
-							cerr << "Invalid key in Vamp FeatureSet: " 
+							cerr << "Invalid key in VAMP FeatureSet: " 
 							<< PyString_AsString(pyKey) << endl; 
 					} // switch					
 
 				} // while 
 				if (emptyFeature) cerr << "Warning: This feature is empty or badly formatted." << endl;

 		}
 		Py_DECREF(pyMethod);
 	
 		PyObject *pyFeatureList, *pyDict, *pyKey, *pyValue;
 		FeatureSet returnFeatures;
-
+		
+		//iterate through list of outputs
 		for (Py_ssize_t i = 0; i < PyList_GET_SIZE(pyOutputList); ++i) {
 
 			pyFeatureList = PyList_GET_ITEM(pyOutputList,i);
 
+			//iterate list of Features
 			for (Py_ssize_t j = 0; j < PyList_GET_SIZE(pyFeatureList); ++j) {				
-
+#ifdef _DEBUG
+				cerr << "feature: " << j << endl;
+#endif
 				pyDict = PyList_GET_ITEM(pyFeatureList,j);
 
 				if ( !PyDict_Check(pyDict) ) continue;
 
 				Py_ssize_t pyPos = NULL;

 				{	
 					emptyFeature = false;
 					switch (ffKeys[PyString_AsString(pyKey)]) 
 					{
 						case not_found : 	
-							cerr << "Unknown key in Vamp FeatureSet: " 
+							cerr << "Unknown key in VAMP FeatureSet: " 
 							<< PyString_AsString(pyKey) << endl; 
 							break;
 						case hasTimestamp: 	
 							feature.hasTimestamp = (bool) PyInt_AS_LONG(pyValue); 
 							break;				
-						// TODO: clarify what to do here
 						case timeStamp: 			
 							feature.timestamp =  
-							Vamp::RealTime::frame2RealTime
-							((size_t)PyInt_AS_LONG(pyValue), (size_t)m_inputSampleRate);
+							Vamp::RealTime::frame2RealTime(
+							PyLong_AsLong(pyValue), 
+							(unsigned int) m_inputSampleRate );
+#ifdef _DEBUG
+							cerr << "Timestamp: " 
+							<< (long)PyLong_AsLong(pyValue) << ", ->" 
+							<< feature.timestamp.toString() << endl;
+#endif
 							break;
 						case values: 	
 							feature.values = PyList_As_FloatVector(pyValue); 
 							break; 								
 						case label: 			

 
 	for (Py_ssize_t k = 0; k < PyList_GET_SIZE(inputList); ++k) {
 		//Get next list item (Borrowed Reference)
 		pyFloat =  PyList_GET_ITEM(inputList,k);
 		ListElement = (float) PyFloat_AS_DOUBLE(pyFloat);
+#ifdef _DEBUG
+		cerr << "value: " << ListElement << endl;
+#endif
 		Output.push_back(ListElement);
 	}
 
 	return Output;
 }