comparison framework/Align.cpp @ 671:b6cafe05017d tuning-difference

Make a completion figure available to alignment, + a couple of other fixes

     QSettings settings;
     settings.beginGroup("Alignment");
     bool performPitchCompensation =
         settings.value("align-pitch-aware", false).toBool();
     QString id = "";
-//!!!    if (performPitchCompensation) {
+    if (performPitchCompensation) {
         id = settings.value
             ("tuning-difference-transform-id",
              "vamp:tuning-difference:tuning-difference:tuningfreq")
             .toString();
-//    }
+    }
     settings.endGroup();
     return id;
 }
 
 bool

     doc->addAggregateModel(aggregateModel);
 
     AlignmentModel *alignmentModel =
         new AlignmentModel(reference, other, nullptr);
 
-    connect(alignmentModel, SIGNAL(completionChanged()),
-            this, SLOT(alignmentCompletionChanged()));
-
     TransformId tdId = getTuningDifferenceTransformName();
 
     if (tdId == "") {
         
         if (beginTransformDrivenAlignment(aggregateModel, alignmentModel)) {

         TransformFactory *tf = TransformFactory::getInstance();
 
         Transform transform = tf->getDefaultTransformFor
             (tdId, aggregateModel->getSampleRate());
 
+        transform.setParameter("maxduration", 50);
+        transform.setParameter("maxrange", 5);
+    
         SVDEBUG << "Align::alignModel: Tuning difference transform step size " << transform.getStepSize() << ", block size " << transform.getBlockSize() << endl;
 
         ModelTransformerFactory *mtf = ModelTransformerFactory::getInstance();
 
         QString message;

         rm->setAlignment(alignmentModel);
     
         connect(tdout, SIGNAL(completionChanged()),
                 this, SLOT(tuningDifferenceCompletionChanged()));
 
-        m_pendingTuningDiffs[tdout] =
-            std::pair<AggregateWaveModel *, AlignmentModel *>
-            (aggregateModel, alignmentModel);
-    }
-
-    return true;
-}
-
-bool
-Align::beginTransformDrivenAlignment(AggregateWaveModel *aggregateModel,
-                                     AlignmentModel *alignmentModel,
-                                     float tuningFrequency)
-{
-    TransformId id = getAlignmentTransformName();
-    
-    TransformFactory *tf = TransformFactory::getInstance();
-
-    Transform transform = tf->getDefaultTransformFor
-        (id, aggregateModel->getSampleRate());
-
-    transform.setStepSize(transform.getBlockSize()/2);
-    transform.setParameter("serialise", 1);
-    transform.setParameter("smooth", 0);
-
-    if (tuningFrequency != 0.f) {
-        transform.setParameter("freq2", tuningFrequency);
-    }
-
-    SVDEBUG << "Align::alignModel: Alignment transform step size " << transform.getStepSize() << ", block size " << transform.getBlockSize() << endl;
-
-    ModelTransformerFactory *mtf = ModelTransformerFactory::getInstance();
-
-    QString message;
-    Model *transformOutput = mtf->transform
-        (transform, aggregateModel, message);
-
-    if (!transformOutput) {
-        transform.setStepSize(0);
-        transformOutput = mtf->transform
-            (transform, aggregateModel, message);
-    }
-
-    SparseTimeValueModel *path = dynamic_cast<SparseTimeValueModel *>
-        (transformOutput);
-
-    //!!! callers will need to be updated to get error from
-    //!!! alignment model after initial call
-        
-    if (!path) {
-        SVCERR << "Align::alignModel: ERROR: Failed to create alignment path (no MATCH plugin?)" << endl;
-        delete transformOutput;
-        alignmentModel->setError(message);
-        return false;
-    }
-
-    path->setCompletion(0);
-    alignmentModel->setPathFrom(path);
-
-    connect(alignmentModel, SIGNAL(completionChanged()),
-            this, SLOT(alignmentCompletionChanged()));
+        TuningDiffRec rec;
+        rec.input = aggregateModel;
+        rec.alignment = alignmentModel;
+
+        // This model exists only so that the AlignmentModel can get a
+        // completion value from somewhere while the tuning difference
+        // calculation is going on
+        rec.preparatory = new SparseTimeValueModel
+            (aggregateModel->getSampleRate(), 1);;
+        rec.preparatory->setCompletion(0);
+        alignmentModel->setPathFrom(rec.preparatory);
+        
+        m_pendingTuningDiffs[tdout] = rec;
+    }
 
     return true;
 }
 
 void

 {
     QMutexLocker locker (&m_mutex);
     
     SparseTimeValueModel *td = qobject_cast<SparseTimeValueModel *>(sender());
     if (!td) return;
-    if (!td->isReady()) return;
-    
-    disconnect(td, SIGNAL(completionChanged()),
-               this, SLOT(alignmentCompletionChanged()));
 
     if (m_pendingTuningDiffs.find(td) == m_pendingTuningDiffs.end()) {
         SVCERR << "ERROR: Align::tuningDifferenceCompletionChanged: Model "
                << td << " not found in pending tuning diff map!" << endl;
         return;
     }
 
-    std::pair<AggregateWaveModel *, AlignmentModel *> models =
-        m_pendingTuningDiffs[td];
+    TuningDiffRec rec = m_pendingTuningDiffs[td];
+
+    int completion = 0;
+    bool done = td->isReady(&completion);
+
+    SVCERR << "Align::tuningDifferenceCompletionChanged: done = " << done << ", completion = " << completion << endl;
+
+    if (!done) {
+        // This will be the completion the alignment model reports,
+        // before the alignment actually begins. It goes up from 0 to
+        // 99 (not 100!) and then back to 0 again when we start
+        // calculating the actual path in the following phase
+        int clamped = (completion == 100 ? 99 : completion);
+        SVCERR << "Align::tuningDifferenceCompletionChanged: setting rec.preparatory completion to " << clamped << endl;
+        rec.preparatory->setCompletion(clamped);
+        return;
+    }
 
     float tuningFrequency = 440.f;
     
     if (!td->isEmpty()) {
         tuningFrequency = td->getAllEvents()[0].getValue();

     } else {
         SVCERR << "Align::tuningDifferenceCompletionChanged: No tuning frequency reported" << endl;
     }    
 
     m_pendingTuningDiffs.erase(td);
+    td->aboutToDelete();
+    delete td;
+
+    rec.alignment->setPathFrom(nullptr);
     
     beginTransformDrivenAlignment
-        (models.first, models.second, tuningFrequency);
+        (rec.input, rec.alignment, tuningFrequency);
+}
+
+bool
+Align::beginTransformDrivenAlignment(AggregateWaveModel *aggregateModel,
+                                     AlignmentModel *alignmentModel,
+                                     float tuningFrequency)
+{
+    TransformId id = getAlignmentTransformName();
+    
+    TransformFactory *tf = TransformFactory::getInstance();
+
+    Transform transform = tf->getDefaultTransformFor
+        (id, aggregateModel->getSampleRate());
+
+    transform.setStepSize(transform.getBlockSize()/2);
+    transform.setParameter("serialise", 1);
+    transform.setParameter("smooth", 0);
+
+    if (tuningFrequency != 0.f) {
+        transform.setParameter("freq2", tuningFrequency);
+    }
+
+    SVDEBUG << "Align::alignModel: Alignment transform step size " << transform.getStepSize() << ", block size " << transform.getBlockSize() << endl;
+
+    ModelTransformerFactory *mtf = ModelTransformerFactory::getInstance();
+
+    QString message;
+    Model *transformOutput = mtf->transform
+        (transform, aggregateModel, message);
+
+    if (!transformOutput) {
+        transform.setStepSize(0);
+        transformOutput = mtf->transform
+            (transform, aggregateModel, message);
+    }
+
+    SparseTimeValueModel *path = dynamic_cast<SparseTimeValueModel *>
+        (transformOutput);
+
+    //!!! callers will need to be updated to get error from
+    //!!! alignment model after initial call
+        
+    if (!path) {
+        SVCERR << "Align::alignModel: ERROR: Failed to create alignment path (no MATCH plugin?)" << endl;
+        delete transformOutput;
+        alignmentModel->setError(message);
+        return false;
+    }
+
+    path->setCompletion(0);
+    alignmentModel->setPathFrom(path);
+
+    connect(alignmentModel, SIGNAL(completionChanged()),
+            this, SLOT(alignmentCompletionChanged()));
+
+    return true;
 }
 
 void
 Align::alignmentCompletionChanged()
 {