comparison transform/FeatureExtractionModelTransformer.cpp @ 1558:73b3dd65e0b3

Some debug + tidying

 
 #include <iostream>
 
 #include <QSettings>
 
+//#define DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN 1
+
 FeatureExtractionModelTransformer::FeatureExtractionModelTransformer(Input in,
                                                                      const Transform &transform) :
     ModelTransformer(in, transform),
     m_plugin(0),
     m_haveOutputs(false)

     }
 
     Transform primaryTransform = m_transforms[0];
 
     while (!input->isReady() && !m_abandoned) {
-        cerr << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
+        SVDEBUG << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
         usleep(500000);
     }
+    SVDEBUG << "FeatureExtractionModelTransformer::run: Waited, ready = "
+            << input->isReady() << ", m_abandoned = " << m_abandoned << endl;
     if (m_abandoned) return;
 
     sv_samplerate_t sampleRate = input->getSampleRate();
 
     int channelCount = input->getChannelCount();

     int stepSize = primaryTransform.getStepSize();
     int blockSize = primaryTransform.getBlockSize();
 
     bool frequencyDomain = (m_plugin->getInputDomain() ==
                             Vamp::Plugin::FrequencyDomain);
+
     std::vector<FFTModel *> fftModels;
 
     if (frequencyDomain) {
         for (int ch = 0; ch < channelCount; ++ch) {
             FFTModel *model = new FFTModel

             } else {
                 if (blockFrame >= 
                     contextStart + contextDuration) break;
             }
 
-//        SVDEBUG << "FeatureExtractionModelTransformer::run: blockFrame "
-//                  << blockFrame << ", endFrame " << endFrame << ", blockSize "
-//                  << blockSize << endl;
-
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+            SVDEBUG << "FeatureExtractionModelTransformer::run: blockFrame "
+                    << blockFrame << ", endFrame " << endFrame << ", blockSize "
+                    << blockSize << endl;
+#endif
+        
             int completion = int
                 ((((blockFrame - contextStart) / stepSize) * 99) /
                  (contextDuration / stepSize + 1));
 
             // channelCount is either m_input.getModel()->channelCount or 1

                     } else {
                         for (int i = 0; i <= blockSize/2; ++i) {
                             buffers[ch][i*2] = 0.f;
                             buffers[ch][i*2+1] = 0.f;
                         }
-                    }                    
+                    }
+                        
                     error = fftModels[ch]->getError();
                     if (error != "") {
                         SVCERR << "FeatureExtractionModelTransformer::run: Abandoning, error is " << error << endl;
                         m_abandoned = true;
                         m_message = error;

             }
 
             if (m_abandoned) break;
 
             Vamp::Plugin::FeatureSet features = m_plugin->process
-                (buffers, RealTime::frame2RealTime(blockFrame, sampleRate).toVampRealTime());
-
+                (buffers,
+                 RealTime::frame2RealTime(blockFrame, sampleRate)
+                 .toVampRealTime());
+            
             if (m_abandoned) break;
 
             for (int j = 0; j < (int)m_outputNos.size(); ++j) {
                 for (int fi = 0; fi < (int)features[m_outputNos[j]].size(); ++fi) {
                     Vamp::Plugin::Feature feature = features[m_outputNos[j]][fi];

 }
 
 void
 FeatureExtractionModelTransformer::setCompletion(int n, int completion)
 {
-//    SVDEBUG << "FeatureExtractionModelTransformer::setCompletion("
-//              << completion << ")" << endl;
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+    SVDEBUG << "FeatureExtractionModelTransformer::setCompletion("
+              << completion << ")" << endl;
+#endif
 
     if (isOutput<SparseOneDimensionalModel>(n)) {
 
         SparseOneDimensionalModel *model =
             getConformingOutput<SparseOneDimensionalModel>(n);