comparison transform/FeatureExtractionModelTransformer.cpp @ 690:1424aa29ae95

Seems to be a bad idea to use plain DEBUG symbol on OS/X (system wants it)

     ModelTransformer(in, transform),
     m_plugin(0),
     m_descriptor(0),
     m_outputFeatureNo(0)
 {
-//    DEBUG << "FeatureExtractionModelTransformer::FeatureExtractionModelTransformer: plugin " << pluginId << ", outputName " << m_transform.getOutput() << endl;
+//    SVDEBUG << "FeatureExtractionModelTransformer::FeatureExtractionModelTransformer: plugin " << pluginId << ", outputName " << m_transform.getOutput() << endl;
 
     QString pluginId = transform.getPluginIdentifier();
 
     FeatureExtractionPluginFactory *factory =
 	FeatureExtractionPluginFactory::instanceFor(pluginId);

             .arg(m_plugin->getMaxChannelCount())
             .arg(input->getChannelCount());
 	return;
     }
 
-    DEBUG << "Initialising feature extraction plugin with channels = "
+    SVDEBUG << "Initialising feature extraction plugin with channels = "
               << channelCount << ", step = " << m_transform.getStepSize()
               << ", block = " << m_transform.getBlockSize() << endl;
 
     if (!m_plugin->initialise(channelCount,
                               m_transform.getStepSize(),

         m_message = tr("Plugin \"%1\" has no outputs").arg(pluginId);
 	return;
     }
     
     for (size_t i = 0; i < outputs.size(); ++i) {
-//        DEBUG << "comparing output " << i << " name \"" << outputs[i].identifier << "\" with expected \"" << m_transform.getOutput() << "\"" << endl;
+//        SVDEBUG << "comparing output " << i << " name \"" << outputs[i].identifier << "\" with expected \"" << m_transform.getOutput() << "\"" << endl;
 	if (m_transform.getOutput() == "" ||
             outputs[i].identifier == m_transform.getOutput().toStdString()) {
 	    m_outputFeatureNo = i;
 	    m_descriptor = new Vamp::Plugin::OutputDescriptor(outputs[i]);
 	    break;

     if (m_output) m_output->setSourceModel(input);
 }
 
 FeatureExtractionModelTransformer::~FeatureExtractionModelTransformer()
 {
-//    DEBUG << "FeatureExtractionModelTransformer::~FeatureExtractionModelTransformer()" << endl;
+//    SVDEBUG << "FeatureExtractionModelTransformer::~FeatureExtractionModelTransformer()" << endl;
     delete m_plugin;
     delete m_descriptor;
 }
 
 DenseTimeValueModel *
 FeatureExtractionModelTransformer::getConformingInput()
 {
-//    DEBUG << "FeatureExtractionModelTransformer::getConformingInput: input model is " << getInputModel() << endl;
+//    SVDEBUG << "FeatureExtractionModelTransformer::getConformingInput: input model is " << getInputModel() << endl;
 
     DenseTimeValueModel *dtvm =
 	dynamic_cast<DenseTimeValueModel *>(getInputModel());
     if (!dtvm) {
-	DEBUG << "FeatureExtractionModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << endl;
+	SVDEBUG << "FeatureExtractionModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << endl;
     }
     return dtvm;
 }
 
 void

     if (!input) return;
 
     if (!m_output) return;
 
     while (!input->isReady() && !m_abandoned) {
-        DEBUG << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
+        SVDEBUG << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
         usleep(500000);
     }
     if (m_abandoned) return;
 
     size_t sampleRate = input->getSampleRate();

         } else {
             if (blockFrame >= 
                 contextStart + contextDuration) break;
         }
 
-//	DEBUG << "FeatureExtractionModelTransformer::run: blockFrame "
+//	SVDEBUG << "FeatureExtractionModelTransformer::run: blockFrame "
 //		  << blockFrame << ", endFrame " << endFrame << ", blockSize "
 //                  << blockSize << endl;
 
 	long completion =
 	    (((blockFrame - contextStart) / stepSize) * 99) /

 FeatureExtractionModelTransformer::addFeature(size_t blockFrame,
 					     const Vamp::Plugin::Feature &feature)
 {
     size_t inputRate = m_input.getModel()->getSampleRate();
 
-//    DEBUG << "FeatureExtractionModelTransformer::addFeature("
+//    SVDEBUG << "FeatureExtractionModelTransformer::addFeature("
 //	      << blockFrame << ")" << endl;
 
     int binCount = 1;
     if (m_descriptor->hasFixedBinCount) {
 	binCount = m_descriptor->binCount;

 	if (!model) return;
 
 	model->setColumn(frame / model->getResolution(), values);
 
     } else {
-        DEBUG << "FeatureExtractionModelTransformer::addFeature: Unknown output model type!" << endl;
+        SVDEBUG << "FeatureExtractionModelTransformer::addFeature: Unknown output model type!" << endl;
     }
 }
 
 void
 FeatureExtractionModelTransformer::setCompletion(int completion)

     int binCount = 1;
     if (m_descriptor->hasFixedBinCount) {
 	binCount = m_descriptor->binCount;
     }
 
-//    DEBUG << "FeatureExtractionModelTransformer::setCompletion("
+//    SVDEBUG << "FeatureExtractionModelTransformer::setCompletion("
 //              << completion << ")" << endl;
 
     if (isOutput<SparseOneDimensionalModel>()) {
 
 	SparseOneDimensionalModel *model =