comparison transform/FeatureExtractionModelTransformer.cpp @ 1429:48e9f538e6e9

Untabify

         FeatureExtractionPluginFactory::instance();
 
     if (!factory) {
         m_message = tr("No factory available for feature extraction plugin id \"%1\" (unknown plugin type, or internal error?)").arg(pluginId);
         SVCERR << m_message << endl;
-	return false;
+        return false;
     }
 
     DenseTimeValueModel *input = getConformingInput();
     if (!input) {
         m_message = tr("Input model for feature extraction plugin \"%1\" is of wrong type (internal error?)").arg(pluginId);

     
     m_plugin = factory->instantiatePlugin(pluginId, input->getSampleRate());
     if (!m_plugin) {
         m_message = tr("Failed to instantiate plugin \"%1\"").arg(pluginId);
         SVCERR << m_message << endl;
-	return false;
+        return false;
     }
 
     TransformFactory::getInstance()->makeContextConsistentWithPlugin
         (primaryTransform, m_plugin);
     
     TransformFactory::getInstance()->setPluginParameters
         (primaryTransform, m_plugin);
     
     int channelCount = input->getChannelCount();
     if ((int)m_plugin->getMaxChannelCount() < channelCount) {
-	channelCount = 1;
+        channelCount = 1;
     }
     if ((int)m_plugin->getMinChannelCount() > channelCount) {
         m_message = tr("Cannot provide enough channels to feature extraction plugin \"%1\" (plugin min is %2, max %3; input model has %4)")
             .arg(pluginId)
             .arg(m_plugin->getMinChannelCount())
             .arg(m_plugin->getMaxChannelCount())
             .arg(input->getChannelCount());
         SVCERR << m_message << endl;
-	return false;
+        return false;
     }
 
     int step = primaryTransform.getStepSize();
     int block = primaryTransform.getBlockSize();
     

     Vamp::Plugin::OutputList outputs = m_plugin->getOutputDescriptors();
 
     if (outputs.empty()) {
         m_message = tr("Plugin \"%1\" has no outputs").arg(pluginId);
         SVCERR << m_message << endl;
-	return false;
+        return false;
     }
 
     for (int j = 0; j < (int)m_transforms.size(); ++j) {
 
         for (int i = 0; i < (int)outputs.size(); ++i) {

     float minValue = 0.0, maxValue = 0.0;
     bool haveExtents = false;
     bool haveBinCount = m_descriptors[n]->hasFixedBinCount;
 
     if (haveBinCount) {
-	binCount = (int)m_descriptors[n]->binCount;
+        binCount = (int)m_descriptors[n]->binCount;
     }
 
     m_needAdditionalModels[n] = false;
 
 //    cerr << "FeatureExtractionModelTransformer: output bin count "
-//	      << binCount << endl;
+//              << binCount << endl;
 
     if (binCount > 0 && m_descriptors[n]->hasKnownExtents) {
-	minValue = m_descriptors[n]->minValue;
-	maxValue = m_descriptors[n]->maxValue;
+        minValue = m_descriptors[n]->minValue;
+        maxValue = m_descriptors[n]->maxValue;
         haveExtents = true;
     }
 
     sv_samplerate_t modelRate = input->getSampleRate();
     sv_samplerate_t outputRate = modelRate;

     }
 
     switch (m_descriptors[n]->sampleType) {
 
     case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
-	if (outputRate != 0.0) {
-	    modelResolution = int(round(modelRate / outputRate));
-	}
-	break;
+        if (outputRate != 0.0) {
+            modelResolution = int(round(modelRate / outputRate));
+        }
+        break;
 
     case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
-	modelResolution = m_transforms[n].getStepSize();
-	break;
+        modelResolution = m_transforms[n].getStepSize();
+        break;
 
     case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
         if (outputRate <= 0.0) {
             SVDEBUG << "WARNING: Fixed sample-rate plugin reports invalid sample rate " << m_descriptors[n]->sampleRate << "; defaulting to input rate of " << input->getSampleRate() << endl;
             modelResolution = 1;
         } else {
             modelResolution = int(round(modelRate / outputRate));
 //            cerr << "modelRate = " << modelRate << ", descriptor rate = " << outputRate << ", modelResolution = " << modelResolution << endl;
         }
-	break;
+        break;
     }
 
     bool preDurationPlugin = (m_plugin->getVampApiVersion() < 2);
 
     Model *out = 0;

             new EditableDenseThreeDimensionalModel
             (modelRate, modelResolution, binCount,
              EditableDenseThreeDimensionalModel::BasicMultirateCompression,
              false);
 
-	if (!m_descriptors[n]->binNames.empty()) {
-	    std::vector<QString> names;
-	    for (int i = 0; i < (int)m_descriptors[n]->binNames.size(); ++i) {
-		names.push_back(m_descriptors[n]->binNames[i].c_str());
-	    }
-	    model->setBinNames(names);
-	}
+        if (!m_descriptors[n]->binNames.empty()) {
+            std::vector<QString> names;
+            for (int i = 0; i < (int)m_descriptors[n]->binNames.size(); ++i) {
+                names.push_back(m_descriptors[n]->binNames[i].c_str());
+            }
+            model->setBinNames(names);
+        }
         
         out = model;
 
         QString outputSignalTypeURI = description.getOutputSignalTypeURI(outputId);
         out->setRDFTypeURI(outputSignalTypeURI);

 FeatureExtractionModelTransformer::getConformingInput()
 {
 //    SVDEBUG << "FeatureExtractionModelTransformer::getConformingInput: input model is " << getInputModel() << endl;
 
     DenseTimeValueModel *dtvm =
-	dynamic_cast<DenseTimeValueModel *>(getInputModel());
+        dynamic_cast<DenseTimeValueModel *>(getInputModel());
     if (!dtvm) {
-	SVDEBUG << "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

 
     sv_samplerate_t sampleRate = input->getSampleRate();
 
     int channelCount = input->getChannelCount();
     if ((int)m_plugin->getMaxChannelCount() < channelCount) {
-	channelCount = 1;
+        channelCount = 1;
     }
 
     float **buffers = new float*[channelCount];
     for (int ch = 0; ch < channelCount; ++ch) {
-	buffers[ch] = new float[primaryTransform.getBlockSize() + 2];
+        buffers[ch] = new float[primaryTransform.getBlockSize() + 2];
     }
 
     int stepSize = primaryTransform.getStepSize();
     int blockSize = primaryTransform.getBlockSize();
 

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

 //              << endl;
 
     sv_frame_t frame = blockFrame;
 
     if (m_descriptors[n]->sampleType ==
-	Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
-
-	if (!feature.hasTimestamp) {
-	    SVDEBUG
-		<< "WARNING: FeatureExtractionModelTransformer::addFeature: "
-		<< "Feature has variable sample rate but no timestamp!"
-		<< endl;
-	    return;
-	} else {
-	    frame = RealTime::realTime2Frame(feature.timestamp, inputRate);
-	}
+        Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
+
+        if (!feature.hasTimestamp) {
+            SVDEBUG
+                << "WARNING: FeatureExtractionModelTransformer::addFeature: "
+                << "Feature has variable sample rate but no timestamp!"
+                << endl;
+            return;
+        } else {
+            frame = RealTime::realTime2Frame(feature.timestamp, inputRate);
+        }
 
 //        cerr << "variable sample rate: timestamp = " << feature.timestamp
 //             << " at input rate " << inputRate << " -> " << frame << endl;
         
     } else if (m_descriptors[n]->sampleType ==
-	       Vamp::Plugin::OutputDescriptor::FixedSampleRate) {
+               Vamp::Plugin::OutputDescriptor::FixedSampleRate) {
 
         sv_samplerate_t rate = m_descriptors[n]->sampleRate;
         if (rate <= 0.0) {
             rate = inputRate;
         }

 
     if (isOutput<SparseOneDimensionalModel>(n)) {
 
         SparseOneDimensionalModel *model =
             getConformingOutput<SparseOneDimensionalModel>(n);
-	if (!model) return;
+        if (!model) return;
 
         model->addPoint(SparseOneDimensionalModel::Point
                        (frame, feature.label.c_str()));
-	
+        
     } else if (isOutput<SparseTimeValueModel>(n)) {
 
-	SparseTimeValueModel *model =
+        SparseTimeValueModel *model =
             getConformingOutput<SparseTimeValueModel>(n);
-	if (!model) return;
+        if (!model) return;
 
         for (int i = 0; i < (int)feature.values.size(); ++i) {
 
             float value = feature.values[i];
 

             model->addPoint(FlexiNoteModel::Point(frame,
                                                   value, // value is pitch
                                                   duration,
                                                   velocity / 127.f,
                                                   feature.label.c_str()));
-			// GF: end -- added for flexi note model
+                        // GF: end -- added for flexi note model
         } else  if (isOutput<NoteModel>(n)) {
 
             float velocity = 100;
             if ((int)feature.values.size() > index) {
                 velocity = feature.values[index++];

                                                    value,
                                                    duration,
                                                    feature.label.c_str()));
             }
         }
-	
+        
     } else if (isOutput<EditableDenseThreeDimensionalModel>(n)) {
-	
-	DenseThreeDimensionalModel::Column values = feature.values;
-	
-	EditableDenseThreeDimensionalModel *model =
+        
+        DenseThreeDimensionalModel::Column values = feature.values;
+        
+        EditableDenseThreeDimensionalModel *model =
             getConformingOutput<EditableDenseThreeDimensionalModel>(n);
-	if (!model) return;
+        if (!model) return;
 
 //        cerr << "(note: model resolution = " << model->getResolution() << ")"
 //             << endl;
 
         if (!feature.hasTimestamp && m_fixedRateFeatureNos[n] >= 0) {

 //    SVDEBUG << "FeatureExtractionModelTransformer::setCompletion("
 //              << completion << ")" << endl;
 
     if (isOutput<SparseOneDimensionalModel>(n)) {
 
-	SparseOneDimensionalModel *model =
+        SparseOneDimensionalModel *model =
             getConformingOutput<SparseOneDimensionalModel>(n);
-	if (!model) return;
+        if (!model) return;
         if (model->isAbandoning()) abandon();
-	model->setCompletion(completion, true);
+        model->setCompletion(completion, true);
 
     } else if (isOutput<SparseTimeValueModel>(n)) {
 
-	SparseTimeValueModel *model =
+        SparseTimeValueModel *model =
             getConformingOutput<SparseTimeValueModel>(n);
-	if (!model) return;
+        if (!model) return;
         if (model->isAbandoning()) abandon();
-	model->setCompletion(completion, true);
+        model->setCompletion(completion, true);
 
     } else if (isOutput<NoteModel>(n)) {
 
-	NoteModel *model = getConformingOutput<NoteModel>(n);
-	if (!model) return;
+        NoteModel *model = getConformingOutput<NoteModel>(n);
+        if (!model) return;
         if (model->isAbandoning()) abandon();
-	model->setCompletion(completion, true);
-	
+        model->setCompletion(completion, true);
+        
     } else if (isOutput<FlexiNoteModel>(n)) {
 
-	FlexiNoteModel *model = getConformingOutput<FlexiNoteModel>(n);
-	if (!model) return;
+        FlexiNoteModel *model = getConformingOutput<FlexiNoteModel>(n);
+        if (!model) return;
         if (model->isAbandoning()) abandon();
-	model->setCompletion(completion, true);
+        model->setCompletion(completion, true);
 
     } else if (isOutput<RegionModel>(n)) {
 
-	RegionModel *model = getConformingOutput<RegionModel>(n);
-	if (!model) return;
+        RegionModel *model = getConformingOutput<RegionModel>(n);
+        if (!model) return;
         if (model->isAbandoning()) abandon();
-	model->setCompletion(completion, true);
+        model->setCompletion(completion, true);
 
     } else if (isOutput<EditableDenseThreeDimensionalModel>(n)) {
 
-	EditableDenseThreeDimensionalModel *model =
+        EditableDenseThreeDimensionalModel *model =
             getConformingOutput<EditableDenseThreeDimensionalModel>(n);
-	if (!model) return;
+        if (!model) return;
         if (model->isAbandoning()) abandon();
-	model->setCompletion(completion, true); //!!!m_context.updates);
-    }
-}
-
+        model->setCompletion(completion, true); //!!!m_context.updates);
+    }
+}
+