comparison transform/FeatureExtractionModelTransformer.cpp @ 930:06579b8ffb7b warnfix_no_size_t

More size_t evisceration and warning fixes

         (primaryTransform, m_plugin);
 
     TransformFactory::getInstance()->setPluginParameters
         (primaryTransform, m_plugin);
 
-    size_t channelCount = input->getChannelCount();
-    if (m_plugin->getMaxChannelCount() < channelCount) {
+    int channelCount = input->getChannelCount();
+    if ((int)m_plugin->getMaxChannelCount() < channelCount) {
 	channelCount = 1;
     }
-    if (m_plugin->getMinChannelCount() > channelCount) {
+    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());

 
     if (!m_plugin->initialise(channelCount,
                               primaryTransform.getStepSize(),
                               primaryTransform.getBlockSize())) {
 
-        size_t pstep = primaryTransform.getStepSize();
-        size_t pblock = primaryTransform.getBlockSize();
+        int pstep = primaryTransform.getStepSize();
+        int pblock = primaryTransform.getBlockSize();
 
 ///!!! hang on, this isn't right -- we're modifying a copy
         primaryTransform.setStepSize(0);
         primaryTransform.setBlockSize(0);
         TransformFactory::getInstance()->makeContextConsistentWithPlugin

                 m_fixedRateFeatureNos.push_back(-1); // we increment before use
                 break;
             }
         }
 
-        if (m_descriptors.size() <= j) {
+        if ((int)m_descriptors.size() <= j) {
             m_message = tr("Plugin \"%1\" has no output named \"%2\"")
                 .arg(pluginId)
                 .arg(m_transforms[j].getOutput());
             return false;
         }

 	minValue = m_descriptors[n]->minValue;
 	maxValue = m_descriptors[n]->maxValue;
         haveExtents = true;
     }
 
-    size_t modelRate = input->getSampleRate();
-    size_t modelResolution = 1;
+    int modelRate = input->getSampleRate();
+    int modelResolution = 1;
 
     if (m_descriptors[n]->sampleType != 
         Vamp::Plugin::OutputDescriptor::OneSamplePerStep) {
         if (m_descriptors[n]->sampleRate > input->getSampleRate()) {
             cerr << "WARNING: plugin reports output sample rate as "

 
     switch (m_descriptors[n]->sampleType) {
 
     case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
 	if (m_descriptors[n]->sampleRate != 0.0) {
-	    modelResolution = size_t(modelRate / m_descriptors[n]->sampleRate + 0.001);
+	    modelResolution = int(modelRate / m_descriptors[n]->sampleRate + 0.001);
 	}
 	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 = size_t(round(input->getSampleRate() /
+            modelResolution = int(round(input->getSampleRate() /
                                            m_descriptors[n]->sampleRate));
         }
 	break;
     }
 

              EditableDenseThreeDimensionalModel::BasicMultirateCompression,
              false);
 
 	if (!m_descriptors[n]->binNames.empty()) {
 	    std::vector<QString> names;
-	    for (size_t i = 0; i < m_descriptors[n]->binNames.size(); ++i) {
+	    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);
 	}
         

 
 FeatureExtractionModelTransformer::~FeatureExtractionModelTransformer()
 {
 //    SVDEBUG << "FeatureExtractionModelTransformer::~FeatureExtractionModelTransformer()" << endl;
     delete m_plugin;
-    for (int j = 0; j < m_descriptors.size(); ++j) {
+    for (int j = 0; j < (int)m_descriptors.size(); ++j) {
         delete m_descriptors[j];
     }
 }
 
 FeatureExtractionModelTransformer::Models

         cerr << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
         usleep(500000);
     }
     if (m_abandoned) return;
 
-    size_t sampleRate = input->getSampleRate();
-
-    size_t channelCount = input->getChannelCount();
-    if (m_plugin->getMaxChannelCount() < channelCount) {
+    int sampleRate = input->getSampleRate();
+
+    int channelCount = input->getChannelCount();
+    if ((int)m_plugin->getMaxChannelCount() < channelCount) {
 	channelCount = 1;
     }
 
     float **buffers = new float*[channelCount];
-    for (size_t ch = 0; ch < channelCount; ++ch) {
+    for (int ch = 0; ch < channelCount; ++ch) {
 	buffers[ch] = new float[primaryTransform.getBlockSize() + 2];
     }
 
-    size_t stepSize = primaryTransform.getStepSize();
-    size_t blockSize = primaryTransform.getBlockSize();
+    int stepSize = primaryTransform.getStepSize();
+    int blockSize = primaryTransform.getBlockSize();
 
     bool frequencyDomain = (m_plugin->getInputDomain() ==
                             Vamp::Plugin::FrequencyDomain);
     std::vector<FFTModel *> fftModels;
 
     if (frequencyDomain) {
-        for (size_t ch = 0; ch < channelCount; ++ch) {
+        for (int ch = 0; ch < channelCount; ++ch) {
             FFTModel *model = new FFTModel
                                   (getConformingInput(),
                                    channelCount == 1 ? m_input.getChannel() : ch,
                                    primaryTransform.getWindowType(),
                                    blockSize,

 	    (contextDuration / stepSize + 1);
 
 	// channelCount is either m_input.getModel()->channelCount or 1
 
         if (frequencyDomain) {
-            for (size_t ch = 0; ch < channelCount; ++ch) {
+            for (int ch = 0; ch < channelCount; ++ch) {
                 int column = (blockFrame - startFrame) / stepSize;
                 fftModels[ch]->getValuesAt(column, reals, imaginaries);
-                for (size_t i = 0; i <= blockSize/2; ++i) {
+                for (int i = 0; i <= blockSize/2; ++i) {
                     buffers[ch][i*2] = reals[i];
                     buffers[ch][i*2+1] = imaginaries[i];
                 }
                 error = fftModels[ch]->getError();
                 if (error != "") {

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

 
     if (!m_abandoned) {
         Vamp::Plugin::FeatureSet features = m_plugin->getRemainingFeatures();
 
         for (int j = 0; j < (int)m_outputNos.size(); ++j) {
-            for (size_t fi = 0; fi < features[m_outputNos[j]].size(); ++fi) {
+            for (int fi = 0; fi < (int)features[m_outputNos[j]].size(); ++fi) {
                 Vamp::Plugin::Feature feature = features[m_outputNos[j]][fi];
                 addFeature(j, blockFrame, feature);
             }
         }
     }

     for (int j = 0; j < (int)m_outputNos.size(); ++j) {
         setCompletion(j, 100);
     }
 
     if (frequencyDomain) {
-        for (size_t ch = 0; ch < channelCount; ++ch) {
+        for (int ch = 0; ch < channelCount; ++ch) {
             delete fftModels[ch];
         }
         delete[] reals;
         delete[] imaginaries;
     }

     }
 }
 
 void
 FeatureExtractionModelTransformer::addFeature(int n,
-                                              size_t blockFrame,
+                                              int blockFrame,
                                               const Vamp::Plugin::Feature &feature)
 {
-    size_t inputRate = m_input.getModel()->getSampleRate();
+    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 binCount = 1;
-    if (m_descriptors[n]->hasFixedBinCount) {
-	binCount = m_descriptors[n]->binCount;
-    }
 
     int frame = blockFrame;
 
     if (m_descriptors[n]->sampleType ==
 	Vamp::Plugin::OutputDescriptor::VariableSampleRate) {

 
 	SparseTimeValueModel *model =
             getConformingOutput<SparseTimeValueModel>(n);
 	if (!model) return;
 
-        for (int i = 0; i < feature.values.size(); ++i) {
+        for (int i = 0; i < (int)feature.values.size(); ++i) {
 
             float value = feature.values[i];
 
             QString label = feature.label.c_str();
             if (feature.values.size() > 1) {

     } else if (isOutput<FlexiNoteModel>(n) || isOutput<NoteModel>(n) || isOutput<RegionModel>(n)) { //GF: Added Note Model
 
         int index = 0;
 
         float value = 0.0;
-        if (feature.values.size() > index) {
+        if ((int)feature.values.size() > index) {
             value = feature.values[index++];
         }
 
         float duration = 1;
         if (feature.hasDuration) {
             duration = Vamp::RealTime::realTime2Frame(feature.duration, inputRate);
         } else {
-            if (feature.values.size() > index) {
+            if ((int)feature.values.size() > index) {
                 duration = feature.values[index++];
             }
         }
 
         if (isOutput<FlexiNoteModel>(n)) { // GF: added for flexi note model
 
             float velocity = 100;
-            if (feature.values.size() > index) {
+            if ((int)feature.values.size() > index) {
                 velocity = feature.values[index++];
             }
             if (velocity < 0) velocity = 127;
             if (velocity > 127) velocity = 127;
 

                                              feature.label.c_str()));
 			// GF: end -- added for flexi note model
         } else  if (isOutput<NoteModel>(n)) {
 
             float velocity = 100;
-            if (feature.values.size() > index) {
+            if ((int)feature.values.size() > index) {
                 velocity = feature.values[index++];
             }
             if (velocity < 0) velocity = 127;
             if (velocity > 127) velocity = 127;
 

             RegionModel *model = getConformingOutput<RegionModel>(n);
             if (!model) return;
 
             if (feature.hasDuration && !feature.values.empty()) {
 
-                for (int i = 0; i < feature.values.size(); ++i) {
+                for (int i = 0; i < (int)feature.values.size(); ++i) {
 
                     float value = feature.values[i];
 
                     QString label = feature.label.c_str();
                     if (feature.values.size() > 1) {