Move MIDI filters imprecise handling from 2nd pass to 1st

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

diff --git a/libs/ardour/export_handler.cc b/libs/ardour/export_handler.cc
index 1be2ad0682ad9f50beb6065b9fcf10517cf0fb51..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;
 }
@@ -355,24 +366,35 @@ ExportHandler::finish_timespan ()
 
                        std::stringstream track_number;
                        track_number << metadata.track_number ();
+                       std::stringstream total_tracks;
+                       total_tracks << metadata.total_tracks ();
                        std::stringstream year;
                        year << metadata.year ();
 
                        subs.insert (std::pair<char, std::string> ('a', metadata.artist ()));
                        subs.insert (std::pair<char, std::string> ('b', PBD::basename_nosuffix (filename)));
+                       subs.insert (std::pair<char, std::string> ('c', metadata.copyright ()));
                        subs.insert (std::pair<char, std::string> ('d', Glib::path_get_dirname (filename) + G_DIR_SEPARATOR));
                        subs.insert (std::pair<char, std::string> ('f', filename));
+                       subs.insert (std::pair<char, std::string> ('l', metadata.lyricist ()));
                        subs.insert (std::pair<char, std::string> ('n', session.name ()));
                        subs.insert (std::pair<char, std::string> ('s', session.path ()));
+                       subs.insert (std::pair<char, std::string> ('o', metadata.conductor ()));
                        subs.insert (std::pair<char, std::string> ('t', metadata.title ()));
+                       subs.insert (std::pair<char, std::string> ('z', metadata.organization ()));
                        subs.insert (std::pair<char, std::string> ('A', metadata.album ()));
                        subs.insert (std::pair<char, std::string> ('C', metadata.comment ()));
                        subs.insert (std::pair<char, std::string> ('E', metadata.engineer ()));
                        subs.insert (std::pair<char, std::string> ('G', metadata.genre ()));
+                       subs.insert (std::pair<char, std::string> ('L', total_tracks.str ()));
+                       subs.insert (std::pair<char, std::string> ('M', metadata.mixer ()));
                        subs.insert (std::pair<char, std::string> ('N', current_timespan->name())); // =?= config_map.begin()->first->name ()
+                       subs.insert (std::pair<char, std::string> ('O', metadata.composer ()));
                        subs.insert (std::pair<char, std::string> ('P', metadata.producer ()));
+                       subs.insert (std::pair<char, std::string> ('S', metadata.disc_subtitle ()));
                        subs.insert (std::pair<char, std::string> ('T', track_number.str ()));
                        subs.insert (std::pair<char, std::string> ('Y', year.str ()));
+                       subs.insert (std::pair<char, std::string> ('Z', metadata.country ()));
 
                        ARDOUR::SystemExec *se = new ARDOUR::SystemExec(fmt->command(), subs);
                        info << "Post-export command line : {" << se->to_s () << "}" << endmsg;
@@ -828,7 +850,7 @@ ExportHandler::toc_escape_cdtext (const std::string& txt)
        char buf[5];
 
        try {
-               latin1_txt = Glib::convert (txt, "ISO-8859-1", "UTF-8");
+               latin1_txt = Glib::convert_with_fallback (txt, "ISO-8859-1", "UTF-8", "_");
        } catch (Glib::ConvertError& err) {
                throw Glib::ConvertError (err.code(), string_compose (_("Cannot convert %1 to Latin-1 text"), txt));
        }