comparison transform/RealTimeEffectModelTransformer.cpp @ 1527:710e6250a401 zoom

Merge from default branch

     m_outputNo =
         (transform.getOutput() == "A") ? -1 : transform.getOutput().toInt();
 
     QString pluginId = transform.getPluginIdentifier();
 
-//    SVDEBUG << "RealTimeEffectModelTransformer::RealTimeEffectModelTransformer: plugin " << pluginId << ", output " << output << endl;
+    SVDEBUG << "RealTimeEffectModelTransformer::RealTimeEffectModelTransformer: plugin " << pluginId << ", output " << transform.getOutput() << endl;
 
     RealTimePluginFactory *factory =
-	RealTimePluginFactory::instanceFor(pluginId);
+        RealTimePluginFactory::instanceFor(pluginId);
 
     if (!factory) {
-	cerr << "RealTimeEffectModelTransformer: No factory available for plugin id \""
-		  << pluginId << "\"" << endl;
-	return;
+        SVCERR << "RealTimeEffectModelTransformer: No factory available for plugin id \""
+               << pluginId << "\"" << endl;
+        return;
     }
 
     DenseTimeValueModel *input = getConformingInput();
     if (!input) return;
 

                                           input->getSampleRate(),
                                           transform.getBlockSize(),
                                           input->getChannelCount());
 
     if (!m_plugin) {
-	cerr << "RealTimeEffectModelTransformer: Failed to instantiate plugin \""
-             << pluginId << "\"" << endl;
-	return;
+        SVCERR << "RealTimeEffectModelTransformer: Failed to instantiate plugin \""
+               << pluginId << "\"" << endl;
+        return;
     }
 
     TransformFactory::getInstance()->setPluginParameters(transform, m_plugin);
 
     if (m_outputNo >= 0 &&

             (input->getSampleRate(), outputChannels);
 
         m_outputs.push_back(model);
 
     } else {
-	
+        
         SparseTimeValueModel *model = new SparseTimeValueModel
             (input->getSampleRate(), transform.getBlockSize(), 0.0, 0.0, false);
 
         if (m_units != "") model->setScaleUnits(m_units);
 

 
 DenseTimeValueModel *
 RealTimeEffectModelTransformer::getConformingInput()
 {
     DenseTimeValueModel *dtvm =
-	dynamic_cast<DenseTimeValueModel *>(getInputModel());
+        dynamic_cast<DenseTimeValueModel *>(getInputModel());
     if (!dtvm) {
-	SVDEBUG << "RealTimeEffectModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << endl;
+        SVDEBUG << "RealTimeEffectModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << endl;
     }
     return dtvm;
 }
 
 void

 
     while (!input->isReady() && !m_abandoned) {
         SVDEBUG << "RealTimeEffectModelTransformer::run: Waiting for input model to be ready..." << endl;
         usleep(500000);
     }
-    if (m_abandoned) return;
-
-    SparseTimeValueModel *stvm = dynamic_cast<SparseTimeValueModel *>(m_outputs[0]);
-    WritableWaveFileModel *wwfm = dynamic_cast<WritableWaveFileModel *>(m_outputs[0]);
-    if (!stvm && !wwfm) return;
-
-    if (stvm && (m_outputNo >= int(m_plugin->getControlOutputCount()))) return;
+    if (m_abandoned) {
+        return;
+    }
+    if (m_outputs.empty()) {
+        return;
+    }
+    
+    SparseTimeValueModel *stvm =
+        dynamic_cast<SparseTimeValueModel *>(m_outputs[0]);
+    WritableWaveFileModel *wwfm =
+        dynamic_cast<WritableWaveFileModel *>(m_outputs[0]);
+
+    if (!stvm && !wwfm) {
+        return;
+    }
+
+    if (stvm && (m_outputNo >= int(m_plugin->getControlOutputCount()))) {
+        return;
+    }
 
     sv_samplerate_t sampleRate = input->getSampleRate();
     int channelCount = input->getChannelCount();
     if (!wwfm && m_input.getChannel() != -1) channelCount = 1;
 

     sv_frame_t latency = m_plugin->getLatency();
 
     while (blockFrame < contextStart + contextDuration + latency &&
            !m_abandoned) {
 
-	int completion = int
-	    ((((blockFrame - contextStart) / blockSize) * 99) /
+        int completion = int
+            ((((blockFrame - contextStart) / blockSize) * 99) /
              (1 + ((contextDuration) / blockSize)));
 
-	sv_frame_t got = 0;
-
-	if (channelCount == 1) {
+        sv_frame_t got = 0;
+
+        if (channelCount == 1) {
             if (inbufs && inbufs[0]) {
                 auto data = input->getData
                     (m_input.getChannel(), blockFrame, blockSize);
                 got = data.size();
                 for (sv_frame_t i = 0; i < got; ++i) {

                     for (sv_frame_t i = 0; i < blockSize; ++i) {
                         inbufs[ch][i] = inbufs[0][i];
                     }
                 }
             }
-	} else {
+        } else {
             if (inbufs && inbufs[0]) {
                 auto data = input->getMultiChannelData
                     (0, channelCount - 1, blockFrame, blockSize);
                 if (!data.empty()) got = data[0].size();
                 for (int ch = 0; ch < channelCount; ++ch) {

                     for (sv_frame_t i = 0; i < blockSize; ++i) {
                         inbufs[ch][i] = inbufs[ch % channelCount][i];
                     }
                 }
             }
-	}
+        }
 
 /*
         cerr << "Input for plugin: " << m_plugin->getAudioInputCount() << " channels "<< endl;
 
         for (int ch = 0; ch < m_plugin->getAudioInputCount(); ++ch) {

                     delete[] tmp;
                 }
             }
         }
 
-	if (blockFrame == contextStart || completion > prevCompletion) {
+        if (blockFrame == contextStart || completion > prevCompletion) {
             // This setCompletion is probably misusing the completion
             // terminology, just as it was for WritableWaveFileModel
-	    if (stvm) stvm->setCompletion(completion);
-	    if (wwfm) wwfm->setWriteProportion(completion);
-	    prevCompletion = completion;
-	}
+            if (stvm) stvm->setCompletion(completion);
+            if (wwfm) wwfm->setWriteProportion(completion);
+            prevCompletion = completion;
+        }
         
-	blockFrame += blockSize;
+        blockFrame += blockSize;
     }
 
     if (m_abandoned) return;
     
     if (stvm) stvm->setCompletion(100);