Allow -ve framepos handling in TempoMap::framepos_plus_beats()

[ardour.git] / libs / ardour / export_handler.cc

diff --git a/libs/ardour/export_handler.cc b/libs/ardour/export_handler.cc
index 2dddd5240123e0629def5996f95fea5b8d7e5bad..ac2f7b0bd37ac1718219eb46666938fcdf6cfbcc 100644 (file)
--- a/libs/ardour/export_handler.cc
+++ b/libs/ardour/export_handler.cc
@@ -26,6 +26,7 @@
 
 #include "pbd/convert.h"
 
+#include "ardour/audioengine.h"
 #include "ardour/audiofile_tagger.h"
 #include "ardour/debug.h"
 #include "ardour/export_graph_builder.h"
@@ -40,7 +41,7 @@
 #include "pbd/basename.h"
 #include "ardour/session_metadata.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace PBD;
@@ -110,7 +111,7 @@ ExportHandler::ExportHandler (Session & session)
   , session (session)
   , graph_builder (new ExportGraphBuilder (session))
   , export_status (session.get_export_status ())
-  , normalizing (false)
+  , post_processing (false)
   , cue_tracknum (0)
   , cue_indexnum (0)
 {
@@ -189,19 +190,20 @@ ExportHandler::start_timespan ()
        graph_builder->reset ();
        graph_builder->set_current_timespan (current_timespan);
        handle_duplicate_format_extensions();
+       bool realtime = current_timespan->realtime ();
        for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
                // Filenames can be shared across timespans
                FileSpec & spec = it->second;
                spec.filename->set_timespan (it->first);
-               graph_builder->add_config (spec);
+               graph_builder->add_config (spec, realtime);
        }
 
        /* start export */
 
-       normalizing = false;
+       post_processing = false;
        session.ProcessExport.connect_same_thread (process_connection, boost::bind (&ExportHandler::process, this, _1));
        process_position = current_timespan->get_start();
-       session.start_audio_export (process_position);
+       session.start_audio_export (process_position, realtime);
 }
 
 void
@@ -230,9 +232,14 @@ ExportHandler::process (framecnt_t frames)
 {
        if (!export_status->running ()) {
                return 0;
-       } else if (normalizing) {
+       } else if (post_processing) {
                Glib::Threads::Mutex::Lock l (export_status->lock());
-               return process_normalize ();
+               if (AudioEngine::instance()->freewheeling ()) {
+                       return post_process ();
+               } else {
+                       // wait until we're freewheeling
+                       return 0;
+               }
        } else {
                Glib::Threads::Mutex::Lock l (export_status->lock());
                return process_timespan (frames);
@@ -264,12 +271,12 @@ ExportHandler::process_timespan (framecnt_t frames)
        /* Do actual processing */
        int ret = graph_builder->process (frames_to_read, last_cycle);
 
-       /* Start normalizing if necessary */
+       /* Start post-processing/normalizing if necessary */
        if (last_cycle) {
-               normalizing = graph_builder->will_normalize();
-               if (normalizing) {
-                       export_status->total_normalize_cycles = graph_builder->get_normalize_cycle_count();
-                       export_status->current_normalize_cycle = 0;
+               post_processing = graph_builder->need_postprocessing ();
+               if (post_processing) {
+                       export_status->total_postprocessing_cycles = graph_builder->get_postprocessing_cycle_count();
+                       export_status->current_postprocessing_cycle = 0;
                } else {
                        finish_timespan ();
                        return 0;
@@ -280,16 +287,20 @@ ExportHandler::process_timespan (framecnt_t frames)
 }
 
 int
-ExportHandler::process_normalize ()
+ExportHandler::post_process ()
 {
-       if (graph_builder->process_normalize ()) {
+       if (graph_builder->post_process ()) {
                finish_timespan ();
                export_status->active_job = ExportStatus::Exporting;
        } else {
-               export_status->active_job = ExportStatus::Normalizing;
+               if (graph_builder->realtime ()) {
+                       export_status->active_job = ExportStatus::Encoding;
+               } else {
+                       export_status->active_job = ExportStatus::Normalizing;
+               }
        }
 
-       export_status->current_normalize_cycle++;
+       export_status->current_postprocessing_cycle++;
 
        return 0;
 }