comparison transform/RealTimeEffectModelTransformer.cpp @ 1429:48e9f538e6e9

Untabify

     QString pluginId = transform.getPluginIdentifier();
 
 //    SVDEBUG << "RealTimeEffectModelTransformer::RealTimeEffectModelTransformer: plugin " << pluginId << ", output " << output << endl;
 
     RealTimePluginFactory *factory =
-	RealTimePluginFactory::instanceFor(pluginId);
+        RealTimePluginFactory::instanceFor(pluginId);
 
     if (!factory) {
-	cerr << "RealTimeEffectModelTransformer: No factory available for plugin id \""
-		  << pluginId << "\"" << endl;
-	return;
+        cerr << "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 \""
+        cerr << "RealTimeEffectModelTransformer: Failed to instantiate plugin \""
              << pluginId << "\"" << endl;
-	return;
+        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

     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);