comparison plugin/DSSIPluginInstance.cpp @ 689:573d45e9487b

Merge from debug-output branch

     m_bypassed(false),
     m_grouped(false),
     m_haveLastEventSendTime(false)
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::DSSIPluginInstance(" << identifier << ")"
-	      << std::endl;
+    DEBUG << "DSSIPluginInstance::DSSIPluginInstance(" << identifier << ")"
+	      << endl;
 #endif
 
     init();
 
     m_inputBuffers  = new sample_t*[m_audioPortsIn.size()];

 
 float
 DSSIPluginInstance::getParameter(std::string id) const
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::getParameter(" << id << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::getParameter(" << id << ")" << endl;
 #endif
     for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i) {
         if (id == m_descriptor->LADSPA_Plugin->PortNames[m_controlPortsIn[i].first]) {
 #ifdef DEBUG_DSSI
             std::cerr << "Matches port " << i << std::endl;
 #endif
             float v = getParameterValue(i);
 #ifdef DEBUG_DSSI
-            std::cerr << "Returning " << v << std::endl;
+            DEBUG << "Returning " << v << endl;
 #endif
             return v;
         }
     }
 

 
 void
 DSSIPluginInstance::setParameter(std::string id, float value)
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::setParameter(" << id << ", " << value << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::setParameter(" << id << ", " << value << ")" << endl;
 #endif
 
     for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i) {
         if (id == m_descriptor->LADSPA_Plugin->PortNames[m_controlPortsIn[i].first]) {
             setParameterValue(i, value);

 
 void
 DSSIPluginInstance::init()
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::init" << std::endl;
+    DEBUG << "DSSIPluginInstance::init" << endl;
 #endif
 
     // Discover ports numbers and identities
     //
     const LADSPA_Descriptor *descriptor = m_descriptor->LADSPA_Plugin;

 		}
 	    }
         }
 #ifdef DEBUG_DSSI
         else
-            std::cerr << "DSSIPluginInstance::DSSIPluginInstance - "
-                      << "unrecognised port type" << std::endl;
+            DEBUG << "DSSIPluginInstance::DSSIPluginInstance - "
+                      << "unrecognised port type" << endl;
 #endif
     }
 
     m_outputBufferCount = std::max(m_idealChannelCount, m_audioPortsOut.size());
 }

 DSSIPluginInstance::getLatency()
 {
     size_t latency = 0;
 
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::getLatency(): m_latencyPort " << m_latencyPort << ", m_run " << m_run << std::endl;
+    DEBUG << "DSSIPluginInstance::getLatency(): m_latencyPort " << m_latencyPort << ", m_run " << m_run << endl;
 #endif
 
     if (m_latencyPort) {
 	if (!m_run) {
             for (size_t i = 0; i < getAudioInputCount(); ++i) {

         }
 	latency = (size_t)(*m_latencyPort + 0.1);
     }
     
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::getLatency(): latency is " << latency << std::endl;
+    DEBUG << "DSSIPluginInstance::getLatency(): latency is " << latency << endl;
 #endif
 
     return latency;
 }
 

 
 void
 DSSIPluginInstance::setIdealChannelCount(size_t channels)
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::setIdealChannelCount: channel count "
-	      << channels << " (was " << m_idealChannelCount << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::setIdealChannelCount: channel count "
+	      << channels << " (was " << m_idealChannelCount << ")" << endl;
 #endif
 
     if (channels == m_idealChannelCount) {
 	silence();
 	return;

 }
 
 DSSIPluginInstance::~DSSIPluginInstance()
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::~DSSIPluginInstance" << std::endl;
+    DEBUG << "DSSIPluginInstance::~DSSIPluginInstance" << endl;
 #endif
 
     if (m_threads.find(m_instanceHandle) != m_threads.end()) {
 
 	for (std::set<NonRTPluginThread *>::iterator i =

 {
     if (m_programCacheValid) return;
     m_cachedPrograms.clear();
 
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::checkProgramCache" << std::endl;
+    DEBUG << "DSSIPluginInstance::checkProgramCache" << endl;
 #endif
 
     if (!m_descriptor || !m_descriptor->get_program) {
 	m_programCacheValid = true;
 	return;

 	d.name = programDescriptor->Name;
 	m_cachedPrograms.push_back(d);
     }
 
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::checkProgramCache: have " << m_cachedPrograms.size() << " programs" << std::endl;
+    DEBUG << "DSSIPluginInstance::checkProgramCache: have " << m_cachedPrograms.size() << " programs" << endl;
 #endif
 
     m_programCacheValid = true;
 }
 
 DSSIPluginInstance::ProgramList
 DSSIPluginInstance::getPrograms() const
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::getPrograms" << std::endl;
+    DEBUG << "DSSIPluginInstance::getPrograms" << endl;
 #endif
 
     if (!m_descriptor) return ProgramList();
 
     checkProgramCache();

 
 std::string
 DSSIPluginInstance::getProgram(int bank, int program) const
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::getProgram(" << bank << "," << program << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::getProgram(" << bank << "," << program << ")" << endl;
 #endif
 
     if (!m_descriptor) return std::string();
 
     checkProgramCache();

 
 unsigned long
 DSSIPluginInstance::getProgram(std::string name) const
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::getProgram(" << name << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::getProgram(" << name << ")" << endl;
 #endif
 
     if (!m_descriptor) return 0;
 
     checkProgramCache();

 
 void
 DSSIPluginInstance::selectProgramAux(std::string program, bool backupPortValues)
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::selectProgram(" << program << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::selectProgram(" << program << ")" << endl;
 #endif
 
     if (!m_descriptor) return;
 
     checkProgramCache();

 	    bankNo = i->bank;
 	    programNo = i->program;
 	    found = true;
 
 #ifdef DEBUG_DSSI
-	    std::cerr << "DSSIPluginInstance::selectProgram(" << program << "): found at bank " << bankNo << ", program " << programNo << std::endl;
+	    DEBUG << "DSSIPluginInstance::selectProgram(" << program << "): found at bank " << bankNo << ", program " << programNo << endl;
 #endif
 
 	    break;
 	}
     }

     m_processLock.lock();
     m_descriptor->select_program(m_instanceHandle, bankNo, programNo);
     m_processLock.unlock();
 
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::selectProgram(" << program << "): made select_program(" << bankNo << "," << programNo << ") call" << std::endl;
+    DEBUG << "DSSIPluginInstance::selectProgram(" << program << "): made select_program(" << bankNo << "," << programNo << ") call" << endl;
 #endif
 
     if (backupPortValues) {
 	for (size_t i = 0; i < m_backupControlPortsIn.size(); ++i) {
 	    m_backupControlPortsIn[i] = *m_controlPortsIn[i].second;

 
 void
 DSSIPluginInstance::activate()
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::activate" << std::endl;
+    DEBUG << "DSSIPluginInstance::activate" << endl;
 #endif
 
     if (!m_descriptor || !m_descriptor->LADSPA_Plugin->activate) return;
     m_descriptor->LADSPA_Plugin->activate(m_instanceHandle);
 
     if (m_program != "") {
 #ifdef DEBUG_DSSI
-	std::cerr << "DSSIPluginInstance::activate: restoring program " << m_program << std::endl;
+	DEBUG << "DSSIPluginInstance::activate: restoring program " << m_program << endl;
 #endif
 	selectProgramAux(m_program, false);
     }
 
     for (size_t i = 0; i < m_backupControlPortsIn.size(); ++i) {
 #ifdef DEBUG_DSSI
-	std::cerr << "DSSIPluginInstance::activate: setting port " << m_controlPortsIn[i].first << " to " << m_backupControlPortsIn[i] << std::endl;
+	DEBUG << "DSSIPluginInstance::activate: setting port " << m_controlPortsIn[i].first << " to " << m_backupControlPortsIn[i] << endl;
 #endif
 	*m_controlPortsIn[i].second = m_backupControlPortsIn[i];
     }
 }
 
 void
 DSSIPluginInstance::connectPorts()
 {
     if (!m_descriptor || !m_descriptor->LADSPA_Plugin->connect_port) return;
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::connectPorts: " << m_audioPortsIn.size() 
+    DEBUG << "DSSIPluginInstance::connectPorts: " << m_audioPortsIn.size() 
 	      << " audio ports in, " << m_audioPortsOut.size() << " out, "
-	      << m_outputBufferCount << " output buffers" << std::endl;
+	      << m_outputBufferCount << " output buffers" << endl;
 #endif
 
     assert(sizeof(LADSPA_Data) == sizeof(float));
     assert(sizeof(sample_t) == sizeof(float));
     

             float defaultValue = f->getPortDefault
                 (m_descriptor->LADSPA_Plugin, m_controlPortsIn[i].first);
             *m_controlPortsIn[i].second = defaultValue;
             m_backupControlPortsIn[i] = defaultValue;
 #ifdef DEBUG_DSSI
-            std::cerr << "DSSIPluginInstance::connectPorts: set control port " << i << " to default value " << defaultValue << std::endl;
+            DEBUG << "DSSIPluginInstance::connectPorts: set control port " << i << " to default value " << defaultValue << endl;
 #endif
         }
     }
 
     for (unsigned int i = 0; i < m_controlPortsOut.size(); ++i) {

 
 void
 DSSIPluginInstance::setParameterValue(unsigned int parameter, float value)
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::setParameterValue(" << parameter << ") to " << value << std::endl;
+    DEBUG << "DSSIPluginInstance::setParameterValue(" << parameter << ") to " << value << endl;
 #endif
     if (parameter >= m_controlPortsIn.size()) return;
 
     unsigned int portNumber = m_controlPortsIn[parameter].first;
 

 
 void
 DSSIPluginInstance::setPortValueFromController(unsigned int port, int cv)
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::setPortValueFromController(" << port << ") to " << cv << std::endl;
+    DEBUG << "DSSIPluginInstance::setPortValueFromController(" << port << ") to " << cv << endl;
 #endif
 
     const LADSPA_Descriptor *p = m_descriptor->LADSPA_Plugin;
     LADSPA_PortRangeHintDescriptor d = p->PortRangeHints[port].HintDescriptor;
     LADSPA_Data lb = p->PortRangeHints[port].LowerBound;

 
 float
 DSSIPluginInstance::getParameterValue(unsigned int parameter) const
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::getParameterValue(" << parameter << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::getParameterValue(" << parameter << ")" << endl;
 #endif
     if (parameter >= m_controlPortsIn.size()) return 0.0;
     return (*m_controlPortsIn[parameter].second);
 }
 

 #endif
     }
 	
     
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::configure(" << key << "," << value << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::configure(" << key << "," << value << ")" << endl;
 #endif
 
     char *message = m_descriptor->configure(m_instanceHandle,
 					    key.c_str(),
 					    value.c_str());

 void
 DSSIPluginInstance::sendEvent(const Vamp::RealTime &eventTime,
 			      const void *e)
 {
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::sendEvent: last was " << m_lastEventSendTime << " (valid " << m_haveLastEventSendTime << "), this is " << eventTime << std::endl;
+    DEBUG << "DSSIPluginInstance::sendEvent: last was " << m_lastEventSendTime << " (valid " << m_haveLastEventSendTime << "), this is " << eventTime << endl;
 #endif
 
     // The process mechanism only works correctly if the events are
     // sorted.  It's the responsibility of the caller to ensure that:
     // we will happily drop events here if we find the timeline going

 	clearEvents();
     }
 
     snd_seq_event_t *event = (snd_seq_event_t *)e;
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::sendEvent at " << eventTime << std::endl;
+    DEBUG << "DSSIPluginInstance::sendEvent at " << eventTime << endl;
 #endif
     snd_seq_event_t ev(*event);
 
     ev.time.time.tv_sec = eventTime.sec;
     ev.time.time.tv_nsec = eventTime.nsec;

 DSSIPluginInstance::handleController(snd_seq_event_t *ev)
 {
     int controller = ev->data.control.param;
 
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::handleController " << controller << std::endl;
+    DEBUG << "DSSIPluginInstance::handleController " << controller << endl;
 #endif
 
     if (controller == 0) { // bank select MSB
 	
 	m_pending.msb = ev->data.control.value;

 	if (needLock) m_processLock.unlock();
 	return;
     }
 
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::run(" << blockTime << ")" << std::endl;
+    DEBUG << "DSSIPluginInstance::run(" << blockTime << ")" << endl;
 #endif
 
 #ifdef DEBUG_DSSI_PROCESS
     if (m_eventBuffer.getReadSpace() > 0) {
-	std::cerr << "DSSIPluginInstance::run: event buffer has "
-		  << m_eventBuffer.getReadSpace() << " event(s) in it" << std::endl;
+	DEBUG << "DSSIPluginInstance::run: event buffer has "
+		  << m_eventBuffer.getReadSpace() << " event(s) in it" << endl;
     }
 #endif
 
     while (m_eventBuffer.getReadSpace() > 0) {
 

 	if (evTime > blockTime) {
 	    frameOffset = Vamp::RealTime::realTime2Frame(evTime - blockTime, m_sampleRate);
 	}
 
 #ifdef DEBUG_DSSI_PROCESS
-	std::cerr << "DSSIPluginInstance::run: evTime " << evTime << ", blockTime " << blockTime << ", frameOffset " << frameOffset
-		  << ", blockSize " << m_blockSize << std::endl;
+	DEBUG << "DSSIPluginInstance::run: evTime " << evTime << ", blockTime " << blockTime << ", frameOffset " << frameOffset
+		  << ", blockSize " << m_blockSize << endl;
 	std::cerr << "Type: " << int(ev->type) << ", pitch: " << int(ev->data.note.note) << ", velocity: " << int(ev->data.note.velocity) << std::endl;
 #endif
 
 	if (frameOffset >= int(count)) break;
 	if (frameOffset < 0) {

 
 	int program = m_pending.program;
 	int bank = m_pending.lsb + 128 * m_pending.msb;
 
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::run: making select_program(" << bank << "," << program << ") call" << std::endl;
+    DEBUG << "DSSIPluginInstance::run: making select_program(" << bank << "," << program << ") call" << endl;
 #endif
 
 	m_pending.lsb = m_pending.msb = m_pending.program = -1;
 	m_descriptor->select_program(m_instanceHandle, bank, program);
 
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::run: made select_program(" << bank << "," << program << ") call" << std::endl;
-#endif
-    }
-
-#ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::run: running with " << evCount << " events"
-	      << std::endl;
+    DEBUG << "DSSIPluginInstance::run: made select_program(" << bank << "," << program << ") call" << endl;
+#endif
+    }
+
+#ifdef DEBUG_DSSI_PROCESS
+    DEBUG << "DSSIPluginInstance::run: running with " << evCount << " events"
+	      << endl;
 #endif
 
     m_descriptor->run_synth(m_instanceHandle, count,
 			    localEventBuffer, evCount);
 

     bool needRun = true;
 
     PluginSet &s = m_groupMap[m_identifier];
 
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::runGrouped(" << blockTime << "): this is " << this << "; " << s.size() << " elements in m_groupMap[" << m_identifier << "]" << std::endl;
+    DEBUG << "DSSIPluginInstance::runGrouped(" << blockTime << "): this is " << this << "; " << s.size() << " elements in m_groupMap[" << m_identifier << "]" << endl;
 #endif
 
     if (m_lastRunTime != blockTime) {
 	for (PluginSet::iterator i = s.begin(); i != s.end(); ++i) {
 	    DSSIPluginInstance *instance = *i;
 	    if (instance != this && instance->m_lastRunTime == blockTime) {
 #ifdef DEBUG_DSSI_PROCESS
-		std::cerr << "DSSIPluginInstance::runGrouped(" << blockTime << "): plugin " << instance << " has already been run" << std::endl;
+		DEBUG << "DSSIPluginInstance::runGrouped(" << blockTime << "): plugin " << instance << " has already been run" << endl;
 #endif
 		needRun = false;
 	    }
 	}
     }
 
     if (!needRun) {
 #ifdef DEBUG_DSSI_PROCESS
-	std::cerr << "DSSIPluginInstance::runGrouped(" << blockTime << "): already run, returning" << std::endl;
+	DEBUG << "DSSIPluginInstance::runGrouped(" << blockTime << "): already run, returning" << endl;
 #endif
 	return;
     }
 
 #ifdef DEBUG_DSSI_PROCESS
-    std::cerr << "DSSIPluginInstance::runGrouped(" << blockTime << "): I'm the first, running" << std::endl;
+    DEBUG << "DSSIPluginInstance::runGrouped(" << blockTime << "): I'm the first, running" << endl;
 #endif
 
     size_t index = 0;
     unsigned long *counts = (unsigned long *)
 	alloca(m_groupLocalEventBufferCount * sizeof(unsigned long));

 	DSSIPluginInstance *instance = *i;
 	counts[index] = 0;
 	instances[index] = instance->m_instanceHandle;
 
 #ifdef DEBUG_DSSI_PROCESS
-	std::cerr << "DSSIPluginInstance::runGrouped(" << blockTime << "): running " << instance << std::endl;
+	DEBUG << "DSSIPluginInstance::runGrouped(" << blockTime << "): running " << instance << endl;
 #endif
 
 	if (instance->m_pending.program >= 0 &&
 	    instance->m_descriptor->select_program) {
 	    int program = instance->m_pending.program;

 	    if (evTime > blockTime) {
 		frameOffset = Vamp::RealTime::realTime2Frame(evTime - blockTime, m_sampleRate);
 	    }
 
 #ifdef DEBUG_DSSI_PROCESS
-	    std::cerr << "DSSIPluginInstance::runGrouped: evTime " << evTime << ", frameOffset " << frameOffset
-		      << ", block size " << m_blockSize << std::endl;
+	    DEBUG << "DSSIPluginInstance::runGrouped: evTime " << evTime << ", frameOffset " << frameOffset
+		      << ", block size " << m_blockSize << endl;
 #endif
 
 	    if (frameOffset >= int(m_blockSize)) break;
 	    if (frameOffset < 0) frameOffset = 0;
 

 				    unsigned char /* ports */,
 				    unsigned char /* channels */)
 {
     // This is called from a non-RT context (during instantiate)
 
-    std::cerr << "DSSIPluginInstance::requestMidiSend" << std::endl;
+    DEBUG << "DSSIPluginInstance::requestMidiSend" << endl;
     return 1;
 }
 
 void
 DSSIPluginInstance::midiSend(LADSPA_Handle /* instance */,
 			     snd_seq_event_t * /* events */,
 			     unsigned long /* eventCount */)
 {
     // This is likely to be called from an RT context
 
-    std::cerr << "DSSIPluginInstance::midiSend" << std::endl;
+    DEBUG << "DSSIPluginInstance::midiSend" << endl;
 }
 
 void
 DSSIPluginInstance::NonRTPluginThread::run()
 {

 
 void
 DSSIPluginInstance::deactivate()
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::deactivate " << m_identifier << std::endl;
+    DEBUG << "DSSIPluginInstance::deactivate " << m_identifier << endl;
 #endif
     if (!m_descriptor || !m_descriptor->LADSPA_Plugin->deactivate) return;
 
     for (size_t i = 0; i < m_backupControlPortsIn.size(); ++i) {
 	m_backupControlPortsIn[i] = *m_controlPortsIn[i].second;
     }
 
     m_descriptor->LADSPA_Plugin->deactivate(m_instanceHandle);
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::deactivate " << m_identifier << " done" << std::endl;
+    DEBUG << "DSSIPluginInstance::deactivate " << m_identifier << " done" << endl;
 #endif
 
     m_bufferScavenger.scavenge();
 }
 
 void
 DSSIPluginInstance::cleanup()
 {
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::cleanup " << m_identifier << std::endl;
+    DEBUG << "DSSIPluginInstance::cleanup " << m_identifier << endl;
 #endif
     if (!m_descriptor) return;
 
     if (!m_descriptor->LADSPA_Plugin->cleanup) {
 	std::cerr << "Bad plugin: plugin id "

     }
 
     m_descriptor->LADSPA_Plugin->cleanup(m_instanceHandle);
     m_instanceHandle = 0;
 #ifdef DEBUG_DSSI
-    std::cerr << "DSSIPluginInstance::cleanup " << m_identifier << " done" << std::endl;
-#endif
-}
-
+    DEBUG << "DSSIPluginInstance::cleanup " << m_identifier << " done" << endl;
+#endif
+}
+