comparison framework/Align.h @ 670:0960e27c3232 tuning-difference

Experiment with optionally taking tuning difference into account for alignment

 #define ALIGN_H
 
 #include <QString>
 #include <QObject>
 #include <QProcess>
+#include <QMutex>
 #include <set>
 
 class Model;
 class AlignmentModel;
+class SparseTimeValueModel;
+class AggregateWaveModel;
 class Document;
 
 class Align : public QObject
 {
     Q_OBJECT
     
 public:
-    Align() : m_error("") { }
+    Align() { }
 
     /**
      * Align the "other" model to the reference, attaching an
      * AlignmentModel to it. Alignment is carried out by the method
      * configured in the user preferences (either a plugin transform
      * or an external process) and is done asynchronously. 
+     *
+     * The return value indicates whether the alignment procedure
+     * started successfully. If it is true, then an AlignmentModel has
+     * been constructed and attached to the toAlign model, and you can
+     * query that model to discover the alignment progress, eventual
+     * outcome, and any error message generated during alignment. (The
+     * AlignmentModel is subsequently owned by the toAlign model.)
+     * Conversely if alignModel returns false, no AlignmentModel has
+     * been created, and the error return argument will contain an
+     * error report about whatever problem prevented this from
+     * happening.
      *
      * A single Align object may carry out many simultanous alignment
      * calls -- you do not need to create a new Align object each
      * time, nor to wait for an alignment to be complete before
      * starting a new one.

      * Align object will simply share the process or document
      * lifespan.
      */
     bool alignModel(Document *doc,
                     Model *reference,
-                    Model *other); // via user preference
+                    Model *toAlign,
+                    QString &error);
     
     bool alignModelViaTransform(Document *doc,
                                 Model *reference,
-                                Model *other);
+                                Model *toAlign,
+                                QString &error);
 
     bool alignModelViaProgram(Document *doc,
                               Model *reference,
-                              Model *other,
-                              QString program);
+                              Model *toAlign,
+                              QString program,
+                              QString &error);
 
     /**
      * Return true if the alignment facility is available (relevant
      * plugin installed, etc).
      */
     static bool canAlign();
-    
-    QString getError() const { return m_error; }
 
 signals:
     /**
      * Emitted when an alignment is successfully completed. The
      * reference and other models can be queried from the alignment

      */
     void alignmentComplete(AlignmentModel *alignment);
 
 private slots:
     void alignmentCompletionChanged();
+    void tuningDifferenceCompletionChanged();
     void alignmentProgramFinished(int, QProcess::ExitStatus);
     
 private:
     static QString getAlignmentTransformName();
-    
-    QString m_error;
-    std::map<QProcess *, AlignmentModel *> m_processModels;
+    static QString getTuningDifferenceTransformName();
+
+    bool beginTransformDrivenAlignment(AggregateWaveModel *,
+                                       AlignmentModel *,
+                                       float tuningFrequency = 0.f);
+
+    QMutex m_mutex;
+    std::map<QProcess *, AlignmentModel *> m_pendingProcesses;
+    std::map<SparseTimeValueModel *,
+             std::pair<AggregateWaveModel *,
+                       AlignmentModel *>> m_pendingTuningDiffs;
 };
 
 #endif