comparison plugin/DSSIPluginInstance.cpp @ 1038:cc27f35aa75c cxx11

Introducing the signed 64-bit frame index type, and fixing build failures from inclusion of -Wconversion with -Werror. Not finished yet.

 
 DSSIPluginInstance::DSSIPluginInstance(RealTimePluginFactory *factory,
 				       int clientId,
 				       QString identifier,
 				       int position,
-				       unsigned long sampleRate,
+				       int sampleRate,
 				       size_t blockSize,
 				       int idealChannelCount,
 				       const DSSI_Descriptor* descriptor) :
     RealTimePluginInstance(factory, identifier),
     m_client(clientId),

 {
     ParameterList list;
     LADSPAPluginFactory *f = dynamic_cast<LADSPAPluginFactory *>(m_factory);
     if (!f) return list;
     
-    for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i) {
+    for (int i = 0; in_range_for(m_controlPortsIn, i); ++i) {
         
         ParameterDescriptor pd;
-        unsigned int pn = m_controlPortsIn[i].first;
+        int pn = (int)m_controlPortsIn[i].first;
 
         pd.identifier = m_descriptor->LADSPA_Plugin->PortNames[pn];
         pd.name = pd.identifier;
         pd.description = "";
         pd.minValue = f->getPortMinimum(m_descriptor->LADSPA_Plugin, pn);

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

 {
 #ifdef DEBUG_DSSI
     SVDEBUG << "DSSIPluginInstance::setParameter(" << id << ", " << value << ")" << endl;
 #endif
 
-    for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i) {
+    for (int i = 0; in_range_for(m_controlPortsIn, i); ++i) {
         if (id == m_descriptor->LADSPA_Plugin->PortNames[m_controlPortsIn[i].first]) {
             setParameterValue(i, value);
             break;
         }
     }

 
     // Discover ports numbers and identities
     //
     const LADSPA_Descriptor *descriptor = m_descriptor->LADSPA_Plugin;
 
-    for (unsigned long i = 0; i < descriptor->PortCount; ++i)
+    for (int i = 0; i < (int)descriptor->PortCount; ++i)
     {
         if (LADSPA_IS_PORT_AUDIO(descriptor->PortDescriptors[i]))
         {
             if (LADSPA_IS_PORT_INPUT(descriptor->PortDescriptors[i])) {
                 m_audioPortsIn.push_back(i);

         {
 	    if (LADSPA_IS_PORT_INPUT(descriptor->PortDescriptors[i])) {
 
 		LADSPA_Data *data = new LADSPA_Data(0.0);
 
-		m_controlPortsIn.push_back(std::pair<unsigned long, LADSPA_Data*>
+		m_controlPortsIn.push_back(std::pair<long, LADSPA_Data*>
 					   (i, data));
 
 		m_backupControlPortsIn.push_back(0.0);
 
 	    } else {
 		LADSPA_Data *data = new LADSPA_Data(0.0);
 		m_controlPortsOut.push_back(
-                    std::pair<unsigned long, LADSPA_Data*>(i, data));
+                    std::pair<long, LADSPA_Data*>(i, data));
 		if (!strcmp(descriptor->PortNames[i], "latency") ||
 		    !strcmp(descriptor->PortNames[i], "_latency")) {
 #ifdef DEBUG_DSSI
 		    cerr << "Wooo! We have a latency port!" << endl;
 #endif

 	deactivate();
     }
 
     cleanup();
 
-    for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i)
+    for (int i = 0; in_range_for(m_controlPortsIn, i); ++i)
         delete m_controlPortsIn[i].second;
 
-    for (unsigned int i = 0; i < m_controlPortsOut.size(); ++i)
+    for (int i = 0; in_range_for(m_controlPortsOut, i); ++i)
         delete m_controlPortsOut[i].second;
 
     m_controlPortsIn.clear();
     m_controlPortsOut.clear();
 

     m_audioPortsOut.clear();
 }
 
 
 void
-DSSIPluginInstance::instantiate(unsigned long sampleRate)
+DSSIPluginInstance::instantiate(int sampleRate)
 {
     if (!m_descriptor) return;
 
 #ifdef DEBUG_DSSI
     cout << "DSSIPluginInstance::instantiate - plugin \"unique\" id = "

 
     if (m_instanceHandle) {
 
 	if (m_descriptor->get_midi_controller_for_port) {
 
-	    for (unsigned long i = 0; i < descriptor->PortCount; ++i) {
+	    for (int i = 0; i < (int)descriptor->PortCount; ++i) {
 
 		if (LADSPA_IS_PORT_CONTROL(descriptor->PortDescriptors[i]) &&
 		    LADSPA_IS_PORT_INPUT(descriptor->PortDescriptors[i])) {
 
 		    int controller = m_descriptor->get_midi_controller_for_port

     if (!m_descriptor || !m_descriptor->get_program) {
 	m_programCacheValid = true;
 	return;
     }
 
-    unsigned long index = 0;
+    int index = 0;
     const DSSI_Program_Descriptor *programDescriptor;
     while ((programDescriptor = m_descriptor->get_program(m_instanceHandle, index))) {
 	++index;
 	ProgramDescriptor d;
-	d.bank = programDescriptor->Bank;
-	d.program = programDescriptor->Program;
+	d.bank = (int)programDescriptor->Bank;
+	d.program = (int)programDescriptor->Program;
 	d.name = programDescriptor->Name;
 	m_cachedPrograms.push_back(d);
     }
 
 #ifdef DEBUG_DSSI

     }
 
     return std::string();
 }
 
-unsigned long
+int
 DSSIPluginInstance::getProgram(std::string name) const
 {
 #ifdef DEBUG_DSSI
     SVDEBUG << "DSSIPluginInstance::getProgram(" << name << ")" << endl;
 #endif
 
     if (!m_descriptor) return 0;
 
     checkProgramCache();
 
-    unsigned long rv;
+    int rv;
 
     for (std::vector<ProgramDescriptor>::iterator i = m_cachedPrograms.begin();
 	 i != m_cachedPrograms.end(); ++i) {
 	if (i->name == name) {
 	    rv = i->bank;

     checkProgramCache();
 
     if (!m_descriptor->select_program) return;
 
     bool found = false;
-    unsigned long bankNo = 0, programNo = 0;
+    int bankNo = 0, programNo = 0;
 
     for (std::vector<ProgramDescriptor>::iterator i = m_cachedPrograms.begin();
 	 i != m_cachedPrograms.end(); ++i) {
 
 	if (i->name == program) {

     assert(sizeof(sample_t) == sizeof(float));
     
     LADSPAPluginFactory *f = dynamic_cast<LADSPAPluginFactory *>(m_factory);
     int inbuf = 0, outbuf = 0;
 
-    for (unsigned int i = 0; i < m_audioPortsIn.size(); ++i) {
+    for (size_t i = 0; i < m_audioPortsIn.size(); ++i) {
 	m_descriptor->LADSPA_Plugin->connect_port
 	    (m_instanceHandle,
 	     m_audioPortsIn[i],
 	     (LADSPA_Data *)m_inputBuffers[inbuf]);
 	++inbuf;
     }
 
-    for (unsigned int i = 0; i < m_audioPortsOut.size(); ++i) {
+    for (size_t i = 0; i < m_audioPortsOut.size(); ++i) {
 	m_descriptor->LADSPA_Plugin->connect_port
 	    (m_instanceHandle,
 	     m_audioPortsOut[i],
 	     (LADSPA_Data *)m_outputBuffers[outbuf]);
 	++outbuf;
     }
 
-    for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i) {
+    for (size_t i = 0; i < m_controlPortsIn.size(); ++i) {
 	m_descriptor->LADSPA_Plugin->connect_port
 	    (m_instanceHandle,
 	     m_controlPortsIn[i].first,
 	     m_controlPortsIn[i].second);
 
         if (f) {
             float defaultValue = f->getPortDefault
-                (m_descriptor->LADSPA_Plugin, m_controlPortsIn[i].first);
+                (m_descriptor->LADSPA_Plugin, (int)m_controlPortsIn[i].first);
             *m_controlPortsIn[i].second = defaultValue;
             m_backupControlPortsIn[i] = defaultValue;
 #ifdef DEBUG_DSSI
             SVDEBUG << "DSSIPluginInstance::connectPorts: set control port " << i << " to default value " << defaultValue << endl;
 #endif
         }
     }
 
-    for (unsigned int i = 0; i < m_controlPortsOut.size(); ++i) {
+    for (size_t i = 0; i < m_controlPortsOut.size(); ++i) {
 	m_descriptor->LADSPA_Plugin->connect_port
 	    (m_instanceHandle,
 	     m_controlPortsOut[i].first,
 	     m_controlPortsOut[i].second);
     }
 }
 
-unsigned int
+int
 DSSIPluginInstance::getParameterCount() const
 {
-    return m_controlPortsIn.size();
-}
-
-void
-DSSIPluginInstance::setParameterValue(unsigned int parameter, float value)
+    return (int)m_controlPortsIn.size();
+}
+
+void
+DSSIPluginInstance::setParameterValue(int parameter, float value)
 {
 #ifdef DEBUG_DSSI
     SVDEBUG << "DSSIPluginInstance::setParameterValue(" << parameter << ") to " << value << endl;
 #endif
-    if (parameter >= m_controlPortsIn.size()) return;
-
-    unsigned int portNumber = m_controlPortsIn[parameter].first;
+    if (!in_range_for(m_controlPortsIn, parameter)) return;
+
+    int portNumber = m_controlPortsIn[parameter].first;
 
     LADSPAPluginFactory *f = dynamic_cast<LADSPAPluginFactory *>(m_factory);
     if (f) {
 	if (value < f->getPortMinimum(m_descriptor->LADSPA_Plugin, portNumber)) {
 	    value = f->getPortMinimum(m_descriptor->LADSPA_Plugin, portNumber);

     (*m_controlPortsIn[parameter].second) = value;
     m_backupControlPortsIn[parameter] = value;
 }
 
 void
-DSSIPluginInstance::setPortValueFromController(unsigned int port, int cv)
+DSSIPluginInstance::setPortValueFromController(int port, int cv)
 {
 #ifdef DEBUG_DSSI
     SVDEBUG << "DSSIPluginInstance::setPortValueFromController(" << port << ") to " << cv << endl;
 #endif
 

 	    /* XXX !!! todo: fill in logarithmic, sample rate &c */
 	    value = lb + ((ub - lb) * value / 127.0f);
 	}
     }
 
-    for (unsigned int i = 0; i < m_controlPortsIn.size(); ++i) {
+    for (int i = 0; in_range_for(m_controlPortsIn, i); ++i) {
 	if (m_controlPortsIn[i].first == port) {
 	    setParameterValue(i, value);
 	}
     }
 }
 
 float
 DSSIPluginInstance::getControlOutputValue(size_t output) const
 {
-    if (output > m_controlPortsOut.size()) return 0.0;
+    if (!in_range_for(m_controlPortsOut, output)) return 0.0;
     return (*m_controlPortsOut[output].second);
 }
 
 float
-DSSIPluginInstance::getParameterValue(unsigned int parameter) const
+DSSIPluginInstance::getParameterValue(int parameter) const
 {
 #ifdef DEBUG_DSSI
     SVDEBUG << "DSSIPluginInstance::getParameterValue(" << parameter << ")" << endl;
 #endif
-    if (parameter >= m_controlPortsIn.size()) return 0.0;
+    if (!in_range_for(m_controlPortsIn, parameter)) return 0.0;
     return (*m_controlPortsIn[parameter].second);
 }
 
 float
-DSSIPluginInstance::getParameterDefault(unsigned int parameter) const
-{
-    if (parameter >= m_controlPortsIn.size()) return 0.0;
+DSSIPluginInstance::getParameterDefault(int parameter) const
+{
+    if (!in_range_for(m_controlPortsIn, parameter)) return 0.0;
 
     LADSPAPluginFactory *f = dynamic_cast<LADSPAPluginFactory *>(m_factory);
     if (f) {
 	return f->getPortDefault(m_descriptor->LADSPA_Plugin,
 				 m_controlPortsIn[parameter].first);

 	return 0.0f;
     }
 }
 
 int
-DSSIPluginInstance::getParameterDisplayHint(unsigned int parameter) const
-{
-    if (parameter >= m_controlPortsIn.size()) return 0.0;
+DSSIPluginInstance::getParameterDisplayHint(int parameter) const
+{
+    if (!in_range_for(m_controlPortsIn, parameter)) return 0.0;
 
     LADSPAPluginFactory *f = dynamic_cast<LADSPAPluginFactory *>(m_factory);
     if (f) {
 	return f->getPortDisplayHint(m_descriptor->LADSPA_Plugin,
                                      m_controlPortsIn[parameter].first);

 	*ev = m_eventBuffer.peekOne();
 	bool accept = true;
 
 	Vamp::RealTime evTime(ev->time.time.tv_sec, ev->time.time.tv_nsec);
 
-	int frameOffset = 0;
+        long frameOffset = 0;
 	if (evTime > blockTime) {
-	    frameOffset = Vamp::RealTime::realTime2Frame(evTime - blockTime, m_sampleRate);
+	    frameOffset = Vamp::RealTime::realTime2Frame
+                (evTime - blockTime,
+                 (unsigned int)m_sampleRate);
 	}
 
 #ifdef DEBUG_DSSI_PROCESS
 	SVDEBUG << "DSSIPluginInstance::run: evTime " << evTime << ", blockTime " << blockTime << ", frameOffset " << frameOffset
 		  << ", blockSize " << m_blockSize << endl;
 	cerr << "Type: " << int(ev->type) << ", pitch: " << int(ev->data.note.note) << ", velocity: " << int(ev->data.note.velocity) << endl;
 #endif
 
-	if (frameOffset >= int(count)) break;
+	if (frameOffset >= (long)count) break;
 	if (frameOffset < 0) {
 	    frameOffset = 0;
 	    if (ev->type == SND_SEQ_EVENT_NOTEON) {
 		m_eventBuffer.skip(1);
 		continue;

 #ifdef DEBUG_DSSI_PROCESS
     SVDEBUG << "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));
+    int *counts = (int *)
+	alloca(m_groupLocalEventBufferCount * sizeof(int));
     LADSPA_Handle *instances = (LADSPA_Handle *)
 	alloca(m_groupLocalEventBufferCount * sizeof(LADSPA_Handle));
 
     for (PluginSet::iterator i = s.begin(); i != s.end(); ++i) {
 

 }
 
 void
 DSSIPluginInstance::midiSend(LADSPA_Handle /* instance */,
 			     snd_seq_event_t * /* events */,
-			     unsigned long /* eventCount */)
+			     unsignd long /* eventCount */)
 {
     // This is likely to be called from an RT context
 
     SVDEBUG << "DSSIPluginInstance::midiSend" << endl;
 }