comparison plugin/LADSPAPluginInstance.cpp @ 1057:5c5d4863b428 tonioni

Merge from cxx11 branch

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

                 lrdf_get_scale_values(m_descriptor->UniqueID, pn);
 
             if (defaults) {
                 if (defaults->count > 0) {
                     std::map<int, std::string> values;
-                    size_t v = 0;
+                    int v = 0;
                     for (size_t i = 0; i < defaults->count; ++i) {
-                        v = size_t(lrintf(fabsf(defaults->items[i].value)));
+                        v = int(lrintf(fabsf(defaults->items[i].value)));
                         values[v] = defaults->items[i].label;
                     }
-                    for (size_t i = 0; i <= v; ++i) {
+                    for (int i = 0; i <= v; ++i) {
                         pd.valueNames.push_back(values[i]);
                     }
                     haveLabels = true;
                 }
                 lrdf_free_setting_values(defaults);

 	      << m_descriptor->PortCount << " ports" << endl;
 #endif
 
     // Discover ports numbers and identities
     //
-    for (unsigned long i = 0; i < m_descriptor->PortCount; ++i) {
+    for (int i = 0; i < (int)m_descriptor->PortCount; ++i) {
 
         if (LADSPA_IS_PORT_AUDIO(m_descriptor->PortDescriptors[i])) {
 
             if (LADSPA_IS_PORT_INPUT(m_descriptor->PortDescriptors[i])) {
 #ifdef DEBUG_LADSPA

 	    m_instanceCount = idealChannelCount;
 	}
     }
 }
 
-size_t
+sv_frame_t
 LADSPAPluginInstance::getLatency()
 {
     if (m_latencyPort) {
 	if (!m_run) {
-            for (size_t i = 0; i < getAudioInputCount(); ++i) {
-                for (size_t j = 0; j < m_blockSize; ++j) {
+            for (int i = 0; i < getAudioInputCount(); ++i) {
+                for (int j = 0; j < m_blockSize; ++j) {
                     m_inputBuffers[i][j] = 0.f;
                 }
             }
             run(Vamp::RealTime::zeroTime);
         }
-	if (*m_latencyPort > 0) return (size_t)*m_latencyPort;
+	if (*m_latencyPort > 0) return (sv_frame_t)*m_latencyPort;
     }
     return 0;
 }
 
 void

 	activate();
     }
 }
 
 void
-LADSPAPluginInstance::setIdealChannelCount(size_t channels)
+LADSPAPluginInstance::setIdealChannelCount(int channels)
 {
     if (m_audioPortsIn.size() != 1 || channels == m_instanceCount) {
 	silence();
 	return;
     }

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

 		  << ":" << m_descriptor->Label
 		  << " has no instantiate method!" << endl;
 	return;
     }
 
-    for (size_t i = 0; i < m_instanceCount; ++i) {
+    unsigned long pluginRate = (unsigned long)(sampleRate);
+    if (sampleRate != sv_samplerate_t(pluginRate)) {
+        cerr << "LADSPAPluginInstance: WARNING: Non-integer sample rate "
+             << sampleRate << " presented, rounding to " << pluginRate
+             << endl;
+    }
+    
+    for (int i = 0; i < m_instanceCount; ++i) {
 	m_instanceHandles.push_back
-	    (m_descriptor->instantiate(m_descriptor, sampleRate));
+	    (m_descriptor->instantiate(m_descriptor, pluginRate));
     }
 }
 
 void
 LADSPAPluginInstance::activate()

 				       m_controlPortsOut[i].second);
 	}
     }
 }
 
-unsigned int
+int
 LADSPAPluginInstance::getParameterCount() const
 {
-    return m_controlPortsIn.size();
-}
-
-void
-LADSPAPluginInstance::setParameterValue(unsigned int parameter, float value)
-{
-    if (parameter >= m_controlPortsIn.size()) return;
+    return (int)m_controlPortsIn.size();
+}
+
+void
+LADSPAPluginInstance::setParameterValue(int parameter, float value)
+{
+    if (!in_range_for(m_controlPortsIn, parameter)) return;
 
     unsigned int portNumber = m_controlPortsIn[parameter].first;
 
     LADSPAPluginFactory *f = dynamic_cast<LADSPAPluginFactory *>(m_factory);
     if (f) {

 
     (*m_controlPortsIn[parameter].second) = value;
 }
 
 float
-LADSPAPluginInstance::getControlOutputValue(size_t output) const
-{
-    if (output > m_controlPortsOut.size()) return 0.0;
+LADSPAPluginInstance::getControlOutputValue(int output) const
+{
+    if (!in_range_for(m_controlPortsOut, output)) return 0.0;
     return (*m_controlPortsOut[output].second);
 }
 
 float
-LADSPAPluginInstance::getParameterValue(unsigned int parameter) const
-{
-    if (parameter >= m_controlPortsIn.size()) return 0.0;
+LADSPAPluginInstance::getParameterValue(int parameter) const
+{
+    if (!in_range_for(m_controlPortsIn, parameter)) return 0.0;
     return (*m_controlPortsIn[parameter].second);
 }
 
 float
-LADSPAPluginInstance::getParameterDefault(unsigned int parameter) const
-{
-    if (parameter >= m_controlPortsIn.size()) return 0.0;
+LADSPAPluginInstance::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, m_controlPortsIn[parameter].first);
     } else {
 	return 0.0f;
     }
 }
 
 int
-LADSPAPluginInstance::getParameterDisplayHint(unsigned int parameter) const
-{
-    if (parameter >= m_controlPortsIn.size()) return 0.0;
+LADSPAPluginInstance::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, m_controlPortsIn[parameter].first);
     } else {
 	return PortHint::NoHint;
     }
 }
 
 void
-LADSPAPluginInstance::run(const Vamp::RealTime &, size_t count)
+LADSPAPluginInstance::run(const RealTime &, int count)
 {
     if (!m_descriptor || !m_descriptor->run) return;
 
     if (count == 0) count = m_blockSize;