comparison transform/FeatureExtractionModelTransformer.cpp @ 1039:b14064bd1f97 cxx11

This code now compiles. Main problem: sample rate types

     if (!input) {
         m_message = tr("Input model for feature extraction plugin \"%1\" is of wrong type (internal error?)").arg(pluginId);
         return false;
     }
 
-    m_plugin = factory->instantiatePlugin(pluginId, input->getSampleRate());
+    m_plugin = factory->instantiatePlugin(pluginId, float(input->getSampleRate()));
     if (!m_plugin) {
         m_message = tr("Failed to instantiate plugin \"%1\"").arg(pluginId);
 	return false;
     }
 

     float minValue = 0.0, maxValue = 0.0;
     bool haveExtents = false;
     bool haveBinCount = m_descriptors[n]->hasFixedBinCount;
 
     if (haveBinCount) {
-	binCount = m_descriptors[n]->binCount;
+	binCount = (int)m_descriptors[n]->binCount;
     }
 
     m_needAdditionalModels[n] = false;
 
 //    cerr << "FeatureExtractionModelTransformer: output bin count "

 
     switch (m_descriptors[n]->sampleType) {
 
     case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
 	if (m_descriptors[n]->sampleRate != 0.0) {
-	    modelResolution = int(modelRate / m_descriptors[n]->sampleRate + 0.001);
+	    modelResolution = int(round(float(modelRate) /
+                                        m_descriptors[n]->sampleRate));
 	}
 	break;
 
     case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
 	modelResolution = m_transforms[n].getStepSize();

         //!!! the resolution appropriately.  We can't properly display
         //!!! data with a higher resolution than the base model at all
         if (m_descriptors[n]->sampleRate > input->getSampleRate()) {
             modelResolution = 1;
         } else {
-            modelResolution = int(round(input->getSampleRate() /
-                                           m_descriptors[n]->sampleRate));
+            modelResolution = int(round(float(modelRate) /
+                                        m_descriptors[n]->sampleRate));
         }
 	break;
     }
 
     bool preDurationPlugin = (m_plugin->getVampApiVersion() < 2);

     }
     if (contextStart + contextDuration > endFrame) {
         contextDuration = endFrame - contextStart;
     }
 
-    long blockFrame = contextStart;
+    sv_frame_t blockFrame = contextStart;
 
     long prevCompletion = 0;
 
     for (int j = 0; j < (int)m_outputNos.size(); ++j) {
         setCompletion(j, 0);

 
 //	SVDEBUG << "FeatureExtractionModelTransformer::run: blockFrame "
 //		  << blockFrame << ", endFrame " << endFrame << ", blockSize "
 //                  << blockSize << endl;
 
-	long completion =
-	    (((blockFrame - contextStart) / stepSize) * 99) /
-	    (contextDuration / stepSize + 1);
+	int completion = int
+	    ((((blockFrame - contextStart) / stepSize) * 99) /
+             (contextDuration / stepSize + 1));
 
 	// channelCount is either m_input.getModel()->channelCount or 1
 
         if (frequencyDomain) {
             for (int ch = 0; ch < channelCount; ++ch) {
-                int column = (blockFrame - startFrame) / stepSize;
+                int column = int((blockFrame - startFrame) / stepSize);
                 if (fftModels[ch]->getValuesAt(column, reals, imaginaries)) {
                     for (int i = 0; i <= blockSize/2; ++i) {
                         buffers[ch][i*2] = reals[i];
                         buffers[ch][i*2+1] = imaginaries[i];
                     }

     delete[] buffers;
 }
 
 void
 FeatureExtractionModelTransformer::getFrames(int channelCount,
-                                             long startFrame, long size,
+                                             sv_frame_t startFrame,
+                                             sv_frame_t size,
                                              float **buffers)
 {
-    long offset = 0;
+    sv_frame_t offset = 0;
 
     if (startFrame < 0) {
         for (int c = 0; c < channelCount; ++c) {
-            for (int i = 0; i < size && startFrame + i < 0; ++i) {
+            for (sv_frame_t i = 0; i < size && startFrame + i < 0; ++i) {
                 buffers[c][i] = 0.0f;
             }
         }
         offset = -startFrame;
         size -= offset;

     }
 
     DenseTimeValueModel *input = getConformingInput();
     if (!input) return;
     
-    long got = 0;
+    sv_frame_t got = 0;
 
     if (channelCount == 1) {
 
         got = input->getData(m_input.getChannel(), startFrame, size,
                              buffers[0] + offset);
 
         if (m_input.getChannel() == -1 && input->getChannelCount() > 1) {
             // use mean instead of sum, as plugin input
             float cc = float(input->getChannelCount());
-            for (long i = 0; i < size; ++i) {
+            for (sv_frame_t i = 0; i < size; ++i) {
                 buffers[0][i + offset] /= cc;
             }
         }
 
     } else {

     }
 }
 
 void
 FeatureExtractionModelTransformer::addFeature(int n,
-                                              int blockFrame,
+                                              sv_frame_t blockFrame,
                                               const Vamp::Plugin::Feature &feature)
 {
     int inputRate = m_input.getModel()->getSampleRate();
 
 //    cerr << "FeatureExtractionModelTransformer::addFeature: blockFrame = "
 //              << blockFrame << ", hasTimestamp = " << feature.hasTimestamp
 //              << ", timestamp = " << feature.timestamp << ", hasDuration = "
 //              << feature.hasDuration << ", duration = " << feature.duration
 //              << endl;
 
-    int frame = blockFrame;
+    sv_frame_t frame = blockFrame;
 
     if (m_descriptors[n]->sampleType ==
 	Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
 
 	if (!feature.hasTimestamp) {

 
         if (!feature.hasTimestamp) {
             ++m_fixedRateFeatureNos[n];
         } else {
             RealTime ts(feature.timestamp.sec, feature.timestamp.nsec);
-            m_fixedRateFeatureNos[n] =
+            m_fixedRateFeatureNos[n] = (int)
                 lrint(ts.toDouble() * m_descriptors[n]->sampleRate);
         }
 
 //        cerr << "m_fixedRateFeatureNo = " << m_fixedRateFeatureNo 
 //             << ", m_descriptor->sampleRate = " << m_descriptor->sampleRate
 //             << ", inputRate = " << inputRate
 //             << " giving frame = ";
-        frame = lrintf((m_fixedRateFeatureNos[n] / m_descriptors[n]->sampleRate)
-                       * int(inputRate));
+        frame = lrint((double(m_fixedRateFeatureNos[n])
+                       / m_descriptors[n]->sampleRate)
+                      * inputRate);
     }
 
     if (frame < 0) {
         cerr
             << "WARNING: FeatureExtractionModelTransformer::addFeature: "

         float value = 0.0;
         if ((int)feature.values.size() > index) {
             value = feature.values[index++];
         }
 
-        float duration = 1;
+        sv_frame_t duration = 1;
         if (feature.hasDuration) {
             duration = Vamp::RealTime::realTime2Frame(feature.duration, inputRate);
         } else {
-            if ((int)feature.values.size() > index) {
-                duration = feature.values[index++];
+            if (in_range_for(feature.values, index)) {
+                duration = lrintf(feature.values[index++]);
             }
         }
 
         if (isOutput<FlexiNoteModel>(n)) { // GF: added for flexi note model
 

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

             if (velocity > 127) velocity = 127;
 
             NoteModel *model = getConformingOutput<NoteModel>(n);
             if (!model) return;
             model->addPoint(NoteModel::Point(frame, value, // value is pitch
-                                             lrintf(duration),
+                                             duration,
                                              velocity / 127.f,
                                              feature.label.c_str()));
         } else {
 
             RegionModel *model = getConformingOutput<RegionModel>(n);

                     QString label = feature.label.c_str();
                     if (feature.values.size() > 1) {
                         label = QString("[%1] %2").arg(i+1).arg(label);
                     }
 
-                    model->addPoint(RegionModel::Point(frame, value,
-                                                       lrintf(duration),
+                    model->addPoint(RegionModel::Point(frame,
+                                                       value,
+                                                       duration,
                                                        label));
                 }
             } else {
             
-                model->addPoint(RegionModel::Point(frame, value,
-                                                   lrintf(duration),
+                model->addPoint(RegionModel::Point(frame,
+                                                   value,
+                                                   duration,
                                                    feature.label.c_str()));
             }
         }
 	
     } else if (isOutput<EditableDenseThreeDimensionalModel>(n)) {

 //             << endl;
 
         if (!feature.hasTimestamp && m_fixedRateFeatureNos[n] >= 0) {
             model->setColumn(m_fixedRateFeatureNos[n], values);
         } else {
-            model->setColumn(frame / model->getResolution(), values);
+            model->setColumn(int(frame / model->getResolution()), values);
         }
 
     } else {
         SVDEBUG << "FeatureExtractionModelTransformer::addFeature: Unknown output model type!" << endl;
     }