comparison transform/FeatureExtractionPluginTransform.cpp @ 61:963e3187d920

* Fix slowness in serving FFT values to feature extraction plugin transform
  (failure to call resume() on FFT model)
* Fix failure to update completion from time/value model

                             Vamp::Plugin::FrequencyDomain);
     std::vector<FFTModel *> fftModels;
 
     if (frequencyDomain) {
         for (size_t ch = 0; ch < channelCount; ++ch) {
-            fftModels.push_back(new FFTModel
+            FFTModel *model = new FFTModel
                                   (getInput(),
                                    channelCount == 1 ? m_context.channel : ch,
                                    m_context.windowType,
                                    m_context.blockSize,
                                    m_context.stepSize,
                                    m_context.blockSize,
-                                   false));
+                                   false);
+            model->resume();
+            fftModels.push_back(model);
         }
     }
 
     long startFrame = m_input->getStartFrame();
     long   endFrame = m_input->getEndFrame();

                 int column = (blockFrame - startFrame) / m_context.stepSize;
                 for (size_t i = 0; i < m_context.blockSize/2; ++i) {
                     fftModels[ch]->getValuesAt
                         (column, i, buffers[ch][i*2], buffers[ch][i*2+1]);
                 }
-/*!!!
-                float sum = 0.0;
-                for (size_t i = 0; i < m_context.blockSize/2; ++i) {
-                    sum += buffers[ch][i*2];
-                }
-                if (fabs(sum) < 0.0001) {
-                    std::cerr << "WARNING: small sum for column " << column << " (sum is " << sum << ")" << std::endl;
-                }
-*/
             } else {
                 getFrames(ch, channelCount, 
                           blockFrame, m_context.blockSize, buffers[ch]);
             }                
         }

 
     if (binCount == 0) {
 
 	SparseOneDimensionalModel *model = getOutput<SparseOneDimensionalModel>();
 	if (!model) return;
-        std::cerr << "setting on SparseOneDimensionalModel" << std::endl;
 	model->setCompletion(completion);
 
     } else if (binCount == 1) {
 
 	SparseTimeValueModel *model = getOutput<SparseTimeValueModel>();
 	if (!model) return;
-        std::cerr << "setting on SparseTimeValueModel" << std::endl;
 	model->setCompletion(completion);
 
     } else if (m_descriptor->sampleType ==
 	       Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
 
 	NoteModel *model = getOutput<NoteModel>();
 	if (!model) return;
-        std::cerr << "setting on NoteModel" << std::endl;
 	model->setCompletion(completion);
 
     } else {
 
 	EditableDenseThreeDimensionalModel *model =
             getOutput<EditableDenseThreeDimensionalModel>();
 	if (!model) return;
-        std::cerr << "setting on EditableDenseThreeDimensionalModel" << std::endl;
 	model->setCompletion(completion);
     }
 }