comparison transform/FeatureExtractionModelTransformer.cpp @ 1766:85b9b466a59f

Merge from branch by-id

     // All transforms must use the same plugin, parameters, and
     // inputs: they can differ only in choice of plugin output. So we
     // initialise based purely on the first transform in the list (but
     // first check that they are actually similar as promised)
 
-    for (int j = 1; j < (int)m_transforms.size(); ++j) {
+    for (int j = 1; in_range_for(m_transforms, j); ++j) {
         if (!areTransformsSimilar(m_transforms[0], m_transforms[j])) {
             m_message = tr("Transforms supplied to a single FeatureExtractionModelTransformer instance must be similar in every respect except plugin output");
             SVCERR << m_message << endl;
             return false;
         }

         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;
     }
 
-    DenseTimeValueModel *input = getConformingInput();
+    auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
     if (!input) {
         m_message = tr("Input model for feature extraction plugin \"%1\" is of wrong type (internal error?)").arg(pluginId);
         SVCERR << m_message << endl;
         return false;
     }

         if (step != preferredStep || block != preferredBlock) {
 
             SVDEBUG << "Initialisation failed, trying again with preferred step = "
                     << preferredStep << ", block = " << preferredBlock << endl;
             
-            if (!m_plugin->initialise(channelCount, preferredStep, preferredBlock)) {
+            if (!m_plugin->initialise(channelCount,
+                                      preferredStep,
+                                      preferredBlock)) {
 
                 SVDEBUG << "Initialisation failed again" << endl;
                 
                 m_message = tr("Failed to initialise feature extraction plugin \"%1\"").arg(pluginId);
                 SVCERR << m_message << endl;

         m_message = tr("Plugin \"%1\" has no outputs").arg(pluginId);
         SVCERR << m_message << endl;
         return false;
     }
 
-    for (int j = 0; j < (int)m_transforms.size(); ++j) {
-
-        for (int i = 0; i < (int)outputs.size(); ++i) {
-//        SVDEBUG << "comparing output " << i << " name \"" << outputs[i].identifier << "\" with expected \"" << m_transform.getOutput() << "\"" << endl;
+    for (int j = 0; in_range_for(m_transforms, j); ++j) {
+
+        for (int i = 0; in_range_for(outputs, i); ++i) {
+
             if (m_transforms[j].getOutput() == "" ||
-                outputs[i].identifier == m_transforms[j].getOutput().toStdString()) {
+                outputs[i].identifier ==
+                m_transforms[j].getOutput().toStdString()) {
+                
                 m_outputNos.push_back(i);
-                m_descriptors.push_back(new Vamp::Plugin::OutputDescriptor(outputs[i]));
+                m_descriptors.push_back(outputs[i]);
                 m_fixedRateFeatureNos.push_back(-1); // we increment before use
                 break;
             }
         }
 
-        if ((int)m_descriptors.size() <= j) {
+        if (!in_range_for(m_descriptors, j)) {
             m_message = tr("Plugin \"%1\" has no output named \"%2\"")
                 .arg(pluginId)
                 .arg(m_transforms[j].getOutput());
             SVCERR << m_message << endl;
             return false;
         }
     }
 
-    for (int j = 0; j < (int)m_transforms.size(); ++j) {
+    for (int j = 0; in_range_for(m_transforms, j); ++j) {
         createOutputModels(j);
     }
 
     m_outputMutex.lock();
     m_haveOutputs = true;

         // accidentally done so, so just in case:
         SVCERR << "FeatureExtractionModelTransformer: caught exception while deleting plugin: " << e.what() << endl;
         m_message = e.what();
     }
     m_plugin = nullptr;
-        
-    for (int j = 0; j < (int)m_descriptors.size(); ++j) {
-        delete m_descriptors[j];
-    }
+
+    m_descriptors.clear();
 }
 
 void
 FeatureExtractionModelTransformer::createOutputModels(int n)
 {
-    DenseTimeValueModel *input = getConformingInput();
+    auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
+    if (!input) return;
     
     PluginRDFDescription description(m_transforms[n].getPluginIdentifier());
     QString outputId = m_transforms[n].getOutput();
 
     int binCount = 1;
     float minValue = 0.0, maxValue = 0.0;
     bool haveExtents = false;
-    bool haveBinCount = m_descriptors[n]->hasFixedBinCount;
+    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;
-
-    if (binCount > 0 && m_descriptors[n]->hasKnownExtents) {
-        minValue = m_descriptors[n]->minValue;
-        maxValue = m_descriptors[n]->maxValue;
+    if (binCount > 0 && m_descriptors[n].hasKnownExtents) {
+        minValue = m_descriptors[n].minValue;
+        maxValue = m_descriptors[n].maxValue;
         haveExtents = true;
     }
 
     sv_samplerate_t modelRate = input->getSampleRate();
     sv_samplerate_t outputRate = modelRate;
     int modelResolution = 1;
 
-    if (m_descriptors[n]->sampleType != 
+    if (m_descriptors[n].sampleType != 
         Vamp::Plugin::OutputDescriptor::OneSamplePerStep) {
 
-        outputRate = m_descriptors[n]->sampleRate;
+        outputRate = m_descriptors[n].sampleRate;
 
         //!!! SV doesn't actually support display of models that have
         //!!! different underlying rates together -- so we always set
         //!!! the model rate to be the input model's rate, and adjust
         //!!! the resolution appropriately.  We can't properly display

                     << modelRate << ")" << endl;
             outputRate = modelRate;
         }
     }
 
-    switch (m_descriptors[n]->sampleType) {
+    switch (m_descriptors[n].sampleType) {
 
     case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
         if (outputRate != 0.0) {
             modelResolution = int(round(modelRate / outputRate));
         }

         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;
+            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;
     }
 
     bool preDurationPlugin = (m_plugin->getVampApiVersion() < 2);
 
-    Model *out = nullptr;
+    std::shared_ptr<Model> out;
 
     if (binCount == 0 &&
-        (preDurationPlugin || !m_descriptors[n]->hasDuration)) {
+        (preDurationPlugin || !m_descriptors[n].hasDuration)) {
 
         // Anything with no value and no duration is an instant
 
-        out = new SparseOneDimensionalModel(modelRate, modelResolution, false);
+        out = std::make_shared<SparseOneDimensionalModel>
+            (modelRate, modelResolution, false);
+
         QString outputEventTypeURI = description.getOutputEventTypeURI(outputId);
         out->setRDFTypeURI(outputEventTypeURI);
 
     } else if ((preDurationPlugin && binCount > 1 &&
-                (m_descriptors[n]->sampleType ==
+                (m_descriptors[n].sampleType ==
                  Vamp::Plugin::OutputDescriptor::VariableSampleRate)) ||
-               (!preDurationPlugin && m_descriptors[n]->hasDuration)) {
+               (!preDurationPlugin && m_descriptors[n].hasDuration)) {
 
         // For plugins using the old v1 API without explicit duration,
         // we treat anything that has multiple bins (i.e. that has the
         // potential to have value and duration) and a variable sample
         // rate as a note model, taking its values as pitch, duration

         // duration)
         if (binCount > 1) isNoteModel = true;
 
         // Regions do not have units of Hz or MIDI things (a sweeping
         // assumption!)
-        if (m_descriptors[n]->unit == "Hz" ||
-            m_descriptors[n]->unit.find("MIDI") != std::string::npos ||
-            m_descriptors[n]->unit.find("midi") != std::string::npos) {
+        if (m_descriptors[n].unit == "Hz" ||
+            m_descriptors[n].unit.find("MIDI") != std::string::npos ||
+            m_descriptors[n].unit.find("midi") != std::string::npos) {
             isNoteModel = true;
         }
 
         // If we had a "sparse 3D model", we would have the additional
         // problem of determining whether to use that here (if bin

                     (modelRate, modelResolution, minValue, maxValue, false);
             } else {
                 model = new NoteModel
                     (modelRate, modelResolution, false);
             }
-            model->setScaleUnits(m_descriptors[n]->unit.c_str());
-            out = model;
+            model->setScaleUnits(m_descriptors[n].unit.c_str());
+            out.reset(model);
 
         } else {
 
             RegionModel *model;
             if (haveExtents) {

                     (modelRate, modelResolution, minValue, maxValue, false);
             } else {
                 model = new RegionModel
                     (modelRate, modelResolution, false);
             }
-            model->setScaleUnits(m_descriptors[n]->unit.c_str());
-            out = model;
+            model->setScaleUnits(m_descriptors[n].unit.c_str());
+            out.reset(model);
         }
 
         QString outputEventTypeURI = description.getOutputEventTypeURI(outputId);
         out->setRDFTypeURI(outputEventTypeURI);
 
     } else if (binCount == 1 ||
-               (m_descriptors[n]->sampleType == 
+               (m_descriptors[n].sampleType == 
                 Vamp::Plugin::OutputDescriptor::VariableSampleRate)) {
 
         // Anything that is not a 1D, note, or interval model and that
         // has only one value per result must be a sparse time value
         // model.

         }
 
         Vamp::Plugin::OutputList outputs = m_plugin->getOutputDescriptors();
         model->setScaleUnits(outputs[m_outputNos[n]].unit.c_str());
 
-        out = model;
+        out.reset(model);
 
         QString outputEventTypeURI = description.getOutputEventTypeURI(outputId);
         out->setRDFTypeURI(outputEventTypeURI);
 
     } else {

             new EditableDenseThreeDimensionalModel
             (modelRate, modelResolution, binCount,
              EditableDenseThreeDimensionalModel::BasicMultirateCompression,
              false);
 
-        if (!m_descriptors[n]->binNames.empty()) {
+        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());
+            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;
+        out.reset(model);
 
         QString outputSignalTypeURI = description.getOutputSignalTypeURI(outputId);
         out->setRDFTypeURI(outputSignalTypeURI);
     }
 
     if (out) {
-        out->setSourceModel(input);
-        m_outputs.push_back(out);
+        out->setSourceModel(getInputModel());
+        m_outputs.push_back(ModelById::add(out));
     }
 }
 
 void
 FeatureExtractionModelTransformer::awaitOutputModels()

 
 FeatureExtractionModelTransformer::Models
 FeatureExtractionModelTransformer::getAdditionalOutputModels()
 {
     Models mm;
-    for (AdditionalModelMap::iterator i = m_additionalModels.begin();
-         i != m_additionalModels.end(); ++i) {
-        for (std::map<int, SparseTimeValueModel *>::iterator j =
-                 i->second.begin();
-             j != i->second.end(); ++j) {
-            SparseTimeValueModel *m = j->second;
-            if (m) mm.push_back(m);
+    for (auto mp : m_additionalModels) {
+        for (auto m: mp.second) {
+            mm.push_back(m.second);
         }
     }
     return mm;
 }
 
 bool
 FeatureExtractionModelTransformer::willHaveAdditionalOutputModels()
 {
-    for (std::map<int, bool>::const_iterator i =
-             m_needAdditionalModels.begin(); 
-         i != m_needAdditionalModels.end(); ++i) {
-        if (i->second) return true;
+    for (auto p : m_needAdditionalModels) {
+        if (p.second) return true;
     }
     return false;
 }
 
-SparseTimeValueModel *
+ModelId
 FeatureExtractionModelTransformer::getAdditionalModel(int n, int binNo)
 {
-//    std::cerr << "getAdditionalModel(" << n << ", " << binNo << ")" << std::endl;
-
     if (binNo == 0) {
-        std::cerr << "Internal error: binNo == 0 in getAdditionalModel (should be using primary model)" << std::endl;
-        return nullptr;
-    }
-
-    if (!m_needAdditionalModels[n]) return nullptr;
-    if (!isOutput<SparseTimeValueModel>(n)) return nullptr;
-    if (m_additionalModels[n][binNo]) return m_additionalModels[n][binNo];
-
-    std::cerr << "getAdditionalModel(" << n << ", " << binNo << "): creating" << std::endl;
-
-    SparseTimeValueModel *baseModel = getConformingOutput<SparseTimeValueModel>(n);
-    if (!baseModel) return nullptr;
-
-    std::cerr << "getAdditionalModel(" << n << ", " << binNo << "): (from " << baseModel << ")" << std::endl;
+        SVCERR << "Internal error: binNo == 0 in getAdditionalModel (should be using primary model, not calling getAdditionalModel)" << endl;
+        return {};
+    }
+
+    if (!in_range_for(m_outputs, n)) {
+        SVCERR << "getAdditionalModel: Output " << n << " out of range" << endl;
+        return {};
+    }
+
+    if (!in_range_for(m_needAdditionalModels, n) ||
+        !m_needAdditionalModels[n]) {
+        return {};
+    }
+    
+    if (!m_additionalModels[n][binNo].isNone()) {
+        return m_additionalModels[n][binNo];
+    }
+
+    SVDEBUG << "getAdditionalModel(" << n << ", " << binNo
+            << "): creating" << endl;
+
+    auto baseModel = ModelById::getAs<SparseTimeValueModel>(m_outputs[n]);
+    if (!baseModel) {
+        SVCERR << "getAdditionalModel: Output model not conformable, or has vanished" << endl;
+        return {};
+    }
+    
+    SVDEBUG << "getAdditionalModel(" << n << ", " << binNo
+            << "): (from " << baseModel << ")" << endl;
 
     SparseTimeValueModel *additional =
         new SparseTimeValueModel(baseModel->getSampleRate(),
                                  baseModel->getResolution(),
                                  baseModel->getValueMinimum(),

                                  false);
 
     additional->setScaleUnits(baseModel->getScaleUnits());
     additional->setRDFTypeURI(baseModel->getRDFTypeURI());
 
-    m_additionalModels[n][binNo] = additional;
-    return additional;
-}
-
-DenseTimeValueModel *
-FeatureExtractionModelTransformer::getConformingInput()
-{
-//    SVDEBUG << "FeatureExtractionModelTransformer::getConformingInput: input model is " << getInputModel() << endl;
-
-    DenseTimeValueModel *dtvm =
-        dynamic_cast<DenseTimeValueModel *>(getInputModel());
-    if (!dtvm) {
-        SVDEBUG << "FeatureExtractionModelTransformer::getConformingInput: WARNING: Input model is not conformable to DenseTimeValueModel" << endl;
-    }
-    return dtvm;
+    ModelId additionalId = ModelById::add
+        (std::shared_ptr<SparseTimeValueModel>(additional));
+    m_additionalModels[n][binNo] = additionalId;
+    return additionalId;
 }
 
 void
 FeatureExtractionModelTransformer::run()
 {

     } catch (const std::exception &e) {
         abandon();
         m_message = e.what();
         return;
     }
-    
-    DenseTimeValueModel *input = getConformingInput();
-    if (!input) {
-        abandon();
-        return;
-    }
 
     if (m_outputs.empty()) {
         abandon();
         return;
     }
 
     Transform primaryTransform = m_transforms[0];
 
-    while (!input->isReady() && !m_abandoned) {
-        SVDEBUG << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
-        usleep(500000);
-    }
-    SVDEBUG << "FeatureExtractionModelTransformer::run: Waited, ready = "
-            << input->isReady() << ", m_abandoned = " << m_abandoned << endl;
+    bool ready = false;
+    while (!ready && !m_abandoned) {
+        { // scope so as to release input shared_ptr before sleeping
+            auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
+            if (!input) {
+                abandon();
+                return;
+            }
+            ready = input->isReady();
+        }
+        if (!ready) {
+            SVDEBUG << "FeatureExtractionModelTransformer::run: Waiting for input model to be ready..." << endl;
+            usleep(500000);
+        }
+    }
     if (m_abandoned) return;
 
-    sv_samplerate_t sampleRate = input->getSampleRate();
-
-    int channelCount = input->getChannelCount();
-    if ((int)m_plugin->getMaxChannelCount() < channelCount) {
-        channelCount = 1;
+    ModelId inputId = getInputModel();
+
+    sv_samplerate_t sampleRate;
+    int channelCount;
+    sv_frame_t startFrame;
+    sv_frame_t endFrame;
+    
+    { // scope so as not to have this borrowed pointer retained around
+      // the edges of the process loop
+        auto input = ModelById::getAs<DenseTimeValueModel>(inputId);
+        if (!input) {
+            abandon();
+            return;
+        }
+
+        sampleRate = input->getSampleRate();
+
+        channelCount = input->getChannelCount();
+        if ((int)m_plugin->getMaxChannelCount() < channelCount) {
+            channelCount = 1;
+        }
+
+        startFrame = input->getStartFrame();
+        endFrame = input->getEndFrame();
     }
 
     float **buffers = new float*[channelCount];
     for (int ch = 0; ch < channelCount; ++ch) {
         buffers[ch] = new float[primaryTransform.getBlockSize() + 2];

     std::vector<FFTModel *> fftModels;
 
     if (frequencyDomain) {
         for (int ch = 0; ch < channelCount; ++ch) {
             FFTModel *model = new FFTModel
-                                  (getConformingInput(),
-                                   channelCount == 1 ? m_input.getChannel() : ch,
-                                   primaryTransform.getWindowType(),
-                                   blockSize,
-                                   stepSize,
-                                   blockSize);
+                (inputId,
+                 channelCount == 1 ? m_input.getChannel() : ch,
+                 primaryTransform.getWindowType(),
+                 blockSize,
+                 stepSize,
+                 blockSize);
             if (!model->isOK() || model->getError() != "") {
                 QString err = model->getError();
                 delete model;
-                for (int j = 0; j < (int)m_outputNos.size(); ++j) {
+                for (int j = 0; in_range_for(m_outputNos, j); ++j) {
                     setCompletion(j, 100);
                 }
                 //!!! need a better way to handle this -- previously we were using a QMessageBox but that isn't an appropriate thing to do here either
                 throw AllocationFailed("Failed to create the FFT model for this feature extraction model transformer: error is: " + err);
             }
             fftModels.push_back(model);
-            cerr << "created model for channel " << ch << endl;
-        }
-    }
-
-    sv_frame_t startFrame = m_input.getModel()->getStartFrame();
-    sv_frame_t endFrame = m_input.getModel()->getEndFrame();
+        }
+    }
 
     RealTime contextStartRT = primaryTransform.getStartTime();
     RealTime contextDurationRT = primaryTransform.getDuration();
 
     sv_frame_t contextStart =

 
     sv_frame_t blockFrame = contextStart;
 
     long prevCompletion = 0;
 
-    for (int j = 0; j < (int)m_outputNos.size(); ++j) {
+    for (int j = 0; in_range_for(m_outputNos, j); ++j) {
         setCompletion(j, 0);
     }
 
     float *reals = nullptr;
     float *imaginaries = nullptr;

     try {
         while (!m_abandoned) {
 
             if (frequencyDomain) {
                 if (blockFrame - int(blockSize)/2 >
-                    contextStart + contextDuration) break;
+                    contextStart + contextDuration) {
+                    break;
+                }
             } else {
                 if (blockFrame >= 
-                    contextStart + contextDuration) break;
+                    contextStart + contextDuration) {
+                    break;
+                }
             }
 
 #ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
             SVDEBUG << "FeatureExtractionModelTransformer::run: blockFrame "
                     << blockFrame << ", endFrame " << endFrame << ", blockSize "

         
             int completion = int
                 ((((blockFrame - contextStart) / stepSize) * 99) /
                  (contextDuration / stepSize + 1));
 
-            // channelCount is either m_input.getModel()->channelCount or 1
+            bool haveAllModels = true;
+            if (!ModelById::get(inputId)) {
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+                SVDEBUG << "FeatureExtractionModelTransformer::run: Input model " << inputId << " no longer exists" << endl;
+#endif
+                haveAllModels = false;
+            } else {
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+                SVDEBUG << "Input model " << inputId << " still exists" << endl;
+#endif
+            }
+            for (auto mid: m_outputs) {
+                if (!ModelById::get(mid)) {
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+                    SVDEBUG << "FeatureExtractionModelTransformer::run: Output model " << mid << " no longer exists" << endl;
+#endif
+                    haveAllModels = false;
+                } else {
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+                    SVDEBUG << "Output model " << mid << " still exists" << endl;
+#endif
+                }
+            }
+            if (!haveAllModels) {
+                abandon();
+                break;
+            }
+            
+#ifdef DEBUG_FEATURE_EXTRACTION_TRANSFORMER_RUN
+            SVDEBUG << "FeatureExtractionModelTransformer::run: All models still exist" << endl;
+#endif
+
+            // channelCount is either input->channelCount or 1
 
             if (frequencyDomain) {
                 for (int ch = 0; ch < channelCount; ++ch) {
                     int column = int((blockFrame - startFrame) / stepSize);
                     if (fftModels[ch]->getValuesAt(column, reals, imaginaries)) {

                 getFrames(channelCount, blockFrame, blockSize, buffers);
             }
 
             if (m_abandoned) break;
 
-            Vamp::Plugin::FeatureSet features = m_plugin->process
+            auto features = m_plugin->process
                 (buffers,
                  RealTime::frame2RealTime(blockFrame, sampleRate)
                  .toVampRealTime());
             
             if (m_abandoned) break;
 
-            for (int j = 0; j < (int)m_outputNos.size(); ++j) {
-                for (int fi = 0; fi < (int)features[m_outputNos[j]].size(); ++fi) {
-                    Vamp::Plugin::Feature feature = features[m_outputNos[j]][fi];
+            for (int j = 0; in_range_for(m_outputNos, j); ++j) {
+                for (int fi = 0; in_range_for(features[m_outputNos[j]], fi); ++fi) {
+                    auto feature = features[m_outputNos[j]][fi];
                     addFeature(j, blockFrame, feature);
                 }
             }
 
             if (blockFrame == contextStart || completion > prevCompletion) {
-                for (int j = 0; j < (int)m_outputNos.size(); ++j) {
+                for (int j = 0; in_range_for(m_outputNos, j); ++j) {
                     setCompletion(j, completion);
                 }
                 prevCompletion = completion;
             }
 
             blockFrame += stepSize;
 
         }
 
         if (!m_abandoned) {
-            Vamp::Plugin::FeatureSet features = m_plugin->getRemainingFeatures();
-
-            for (int j = 0; j < (int)m_outputNos.size(); ++j) {
-                for (int fi = 0; fi < (int)features[m_outputNos[j]].size(); ++fi) {
-                    Vamp::Plugin::Feature feature = features[m_outputNos[j]][fi];
+            auto features = m_plugin->getRemainingFeatures();
+
+            for (int j = 0; in_range_for(m_outputNos, j); ++j) {
+                for (int fi = 0; in_range_for(features[m_outputNos[j]], fi); ++fi) {
+                    auto feature = features[m_outputNos[j]][fi];
                     addFeature(j, blockFrame, feature);
+                    if (m_abandoned) {
+                        break;
+                    }
                 }
             }
         }
     } catch (const std::exception &e) {
         SVCERR << "FeatureExtractionModelTransformer::run: Exception caught: "

         size -= offset;
         if (size <= 0) return;
         startFrame = 0;
     }
 
-    DenseTimeValueModel *input = getConformingInput();
-    if (!input) return;
+    auto input = ModelById::getAs<DenseTimeValueModel>(getInputModel());
+    if (!input) {
+        return;
+    }
     
     sv_frame_t got = 0;
 
     if (channelCount == 1) {
 

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

         }
 
 //        cerr << "variable sample rate: timestamp = " << feature.timestamp
 //             << " at input rate " << inputRate << " -> " << frame << endl;
         
-    } else if (m_descriptors[n]->sampleType ==
+    } else if (m_descriptors[n].sampleType ==
                Vamp::Plugin::OutputDescriptor::FixedSampleRate) {
 
-        sv_samplerate_t rate = m_descriptors[n]->sampleRate;
+        sv_samplerate_t rate = m_descriptors[n].sampleRate;
         if (rate <= 0.0) {
             rate = inputRate;
         }
         
         if (!feature.hasTimestamp) {

             RealTime ts(feature.timestamp.sec, feature.timestamp.nsec);
             m_fixedRateFeatureNos[n] = (int)lrint(ts.toDouble() * rate);
         }
 
 //        cerr << "m_fixedRateFeatureNo = " << m_fixedRateFeatureNos[n]
-//             << ", m_descriptor->sampleRate = " << m_descriptors[n]->sampleRate
+//             << ", m_descriptor->sampleRate = " << m_descriptors[n].sampleRate
 //             << ", inputRate = " << inputRate
 //             << " giving frame = ";
         frame = lrint((double(m_fixedRateFeatureNos[n]) / rate) * inputRate);
 //        cerr << frame << endl;
     }

     // Rather than repeat the complicated tests from the constructor
     // to determine what sort of model we must be adding the features
     // to, we instead test what sort of model the constructor decided
     // to create.
 
-    if (isOutput<SparseOneDimensionalModel>(n)) {
-
-        SparseOneDimensionalModel *model =
-            getConformingOutput<SparseOneDimensionalModel>(n);
+    ModelId outputId = m_outputs[n];
+
+    if (isOutputType<SparseOneDimensionalModel>(n)) {
+
+        auto model = ModelById::getAs<SparseOneDimensionalModel>(outputId);
         if (!model) return;
-
         model->add(Event(frame, feature.label.c_str()));
         
-    } else if (isOutput<SparseTimeValueModel>(n)) {
-
-        SparseTimeValueModel *model =
-            getConformingOutput<SparseTimeValueModel>(n);
+    } else if (isOutputType<SparseTimeValueModel>(n)) {
+
+        auto model = ModelById::getAs<SparseTimeValueModel>(outputId);
         if (!model) return;
 
-        for (int i = 0; i < (int)feature.values.size(); ++i) {
+        for (int i = 0; in_range_for(feature.values, i); ++i) {
 
             float value = feature.values[i];
 
             QString label = feature.label.c_str();
             if (feature.values.size() > 1) {
                 label = QString("[%1] %2").arg(i+1).arg(label);
             }
 
-            SparseTimeValueModel *targetModel = model;
+            auto targetModel = model;
 
             if (m_needAdditionalModels[n] && i > 0) {
-                targetModel = getAdditionalModel(n, i);
+                targetModel = ModelById::getAs<SparseTimeValueModel>
+                    (getAdditionalModel(n, i));
                 if (!targetModel) targetModel = model;
-//                std::cerr << "adding point to model " << targetModel
-//                          << " for output " << n << " bin " << i << std::endl;
             }
 
             targetModel->add(Event(frame, value, label));
         }
 
-    } else if (isOutput<NoteModel>(n) || isOutput<RegionModel>(n)) {
-
+    } else if (isOutputType<NoteModel>(n) || isOutputType<RegionModel>(n)) {
+    
         int index = 0;
 
         float value = 0.0;
         if ((int)feature.values.size() > index) {
             value = feature.values[index++];

             if (in_range_for(feature.values, index)) {
                 duration = lrintf(feature.values[index++]);
             }
         }
 
-        if (isOutput<NoteModel>(n)) {
+        auto noteModel = ModelById::getAs<NoteModel>(outputId);
+        if (noteModel) {
 
             float velocity = 100;
             if ((int)feature.values.size() > index) {
                 velocity = feature.values[index++];
             }
             if (velocity < 0) velocity = 127;
             if (velocity > 127) velocity = 127;
-
-            NoteModel *model = getConformingOutput<NoteModel>(n);
-            if (!model) return;
-            model->add(Event(frame, value, // value is pitch
-                             duration,
-                             velocity / 127.f,
-                             feature.label.c_str()));
-        } else {
-
-            RegionModel *model = getConformingOutput<RegionModel>(n);
-            if (!model) return;
-
+            
+            noteModel->add(Event(frame, value, // value is pitch
+                                 duration,
+                                 velocity / 127.f,
+                                 feature.label.c_str()));
+        }
+
+        auto regionModel = ModelById::getAs<RegionModel>(outputId);
+        if (regionModel) {
+            
             if (feature.hasDuration && !feature.values.empty()) {
-
-                for (int i = 0; i < (int)feature.values.size(); ++i) {
-
+                
+                for (int i = 0; in_range_for(feature.values, i); ++i) {
+                    
                     float value = feature.values[i];
-
+                    
                     QString label = feature.label.c_str();
                     if (feature.values.size() > 1) {
                         label = QString("[%1] %2").arg(i+1).arg(label);
                     }
-
-                    model->add(Event(frame,
-                                     value,
-                                     duration,
-                                     label));
+                    
+                    regionModel->add(Event(frame,
+                                           value,
+                                           duration,
+                                           label));
                 }
             } else {
-            
-                model->add(Event(frame,
-                                 value,
-                                 duration,
-                                 feature.label.c_str()));
-            }
-        }
-        
-    } else if (isOutput<EditableDenseThreeDimensionalModel>(n)) {
+                
+                regionModel->add(Event(frame,
+                                       value,
+                                       duration,
+                                       feature.label.c_str()));
+            }
+        }
+
+    } else if (isOutputType<EditableDenseThreeDimensionalModel>(n)) {
+
+        auto model = ModelById::getAs
+            <EditableDenseThreeDimensionalModel>(outputId);
+        if (!model) return;
         
         DenseThreeDimensionalModel::Column values = feature.values;
         
-        EditableDenseThreeDimensionalModel *model =
-            getConformingOutput<EditableDenseThreeDimensionalModel>(n);
-        if (!model) return;
-
-//        cerr << "(note: model resolution = " << model->getResolution() << ")"
-//             << endl;
-
         if (!feature.hasTimestamp && m_fixedRateFeatureNos[n] >= 0) {
             model->setColumn(m_fixedRateFeatureNos[n], values);
         } else {
             model->setColumn(int(frame / model->getResolution()), values);
         }
-
     } else {
-        SVDEBUG << "FeatureExtractionModelTransformer::addFeature: Unknown output model type!" << endl;
+        
+        SVDEBUG << "FeatureExtractionModelTransformer::addFeature: Unknown output model type - possibly a deleted model" << endl;
+        abandon();
     }
 }
 
 void
 FeatureExtractionModelTransformer::setCompletion(int n, int completion)

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