comparison data/model/AlignmentModel.cpp @ 339:ba30f4a3e3be

* Some work on correct alignment when moving panes during playback
* Overhaul alignment for playback frame values (view manager now always
  refers to reference-timeline values, only the play source deals in
  playback model timeline values)
* When making a selection, ensure the selection regions shown in other
  panes (and used for playback constraints if appropriate) are aligned
  correctly.  This may be the coolest feature ever implemented in any
  program ever.

 
 size_t
 AlignmentModel::toReference(size_t frame) const
 {
 //    std::cerr << "AlignmentModel::toReference(" << frame << ")" << std::endl;
+    if (!m_path) constructPath();
+    return align(m_path, frame);
+}
+
+size_t
+AlignmentModel::fromReference(size_t frame) const
+{
+//    std::cerr << "AlignmentModel::fromReference(" << frame << ")" << std::endl;
     if (!m_reversePath) constructReversePath();
     return align(m_reversePath, frame);
 }
 
-size_t
-AlignmentModel::fromReference(size_t frame) const
-{
-//    std::cerr << "AlignmentModel::fromReference(" << frame << ")" << std::endl;
-    if (!m_path) constructPath();
-    return align(m_path, frame);
-}
-
 void
 AlignmentModel::pathChanged()
 {
+    if (m_pathComplete) {
+        std::cerr << "AlignmentModel: deleting raw path model" << std::endl;
+        delete m_rawPath;
+        m_rawPath = 0;
+    }
 }
 
 void
 AlignmentModel::pathChanged(size_t, size_t)
 {

 }    
 
 void
 AlignmentModel::pathCompletionChanged()
 {
+    if (!m_rawPath) return;
     m_pathBegun = true;
 
     if (!m_pathComplete) {
 
         int completion = 0;

 
         if (m_pathComplete) {
 
             constructPath();
             constructReversePath();
-
-            delete m_rawPath;
-            m_rawPath = 0;
 
             delete m_inputModel;
             m_inputModel = 0;
         }
     }

         float value = i->value;
         long rframe = lrintf(value * m_aligned->getSampleRate());
         m_path->addPoint(PathPoint(frame, rframe));
     }
 
-    std::cerr << "AlignmentModel::constructPath: " << m_path->getPointCount() << " points, at least " << (2 * m_path->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
+//    std::cerr << "AlignmentModel::constructPath: " << m_path->getPointCount() << " points, at least " << (2 * m_path->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
 }
 
 void
 AlignmentModel::constructReversePath() const
 {

         float value = i->value;
         long rframe = lrintf(value * m_aligned->getSampleRate());
         m_reversePath->addPoint(PathPoint(rframe, frame));
     }
 
-    std::cerr << "AlignmentModel::constructReversePath: " << m_reversePath->getPointCount() << " points, at least " << (2 * m_reversePath->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
+//    std::cerr << "AlignmentModel::constructReversePath: " << m_reversePath->getPointCount() << " points, at least " << (2 * m_reversePath->getPointCount() * (3 * sizeof(void *) + sizeof(int) + sizeof(PathPoint))) << " bytes" << std::endl;
 }
 
 size_t
 AlignmentModel::align(PathModel *path, size_t frame) const
 {
+    if (!path) return frame;
+
     // The path consists of a series of points, each with frame equal
     // to the frame on the source model and mapframe equal to the
     // frame on the target model.  Both should be monotonically
     // increasing.
 

             float(frame - foundFrame) /
             float(followingFrame - foundFrame);
         resultFrame += lrintf((followingMapFrame - foundMapFrame) * interp);
     }
 
-    std::cerr << "AlignmentModel::align: resultFrame = " << resultFrame << std::endl;
+//    std::cerr << "AlignmentModel::align: resultFrame = " << resultFrame << std::endl;
 
     return resultFrame;
 }