Merge branch 'mingw-updates' of https://github.com/mojofunk/ardour into cairocanvas
[ardour.git] / libs / ardour / export_handler.cc
index fb65cebff0795db394866796912e32e4a892d019..c9f20d182e7bc4dce63a82be58d39f4d8cdd2bcd 100644 (file)
 
 #include "ardour/export_handler.h"
 
+#include <glib/gstdio.h>
 #include <glibmm.h>
 #include <glibmm/convert.h>
 
 #include "pbd/convert.h"
-#include "pbd/filesystem.h"
 
+#include "ardour/audiofile_tagger.h"
 #include "ardour/export_graph_builder.h"
 #include "ardour/export_timespan.h"
 #include "ardour/export_channel_configuration.h"
 #include "ardour/export_status.h"
 #include "ardour/export_format_specification.h"
 #include "ardour/export_filename.h"
+#include "ardour/soundcloud_upload.h"
+#include "ardour/system_exec.h"
+#include "pbd/openuri.h"
+#include "pbd/basename.h"
+#include "ardour/session_metadata.h"
 
 #include "i18n.h"
 
@@ -103,7 +109,6 @@ ExportHandler::ExportHandler (Session & session)
   , session (session)
   , graph_builder (new ExportGraphBuilder (session))
   , export_status (session.get_export_status ())
-  , realtime (false)
   , normalizing (false)
   , cue_tracknum (0)
   , cue_indexnum (0)
@@ -112,23 +117,23 @@ ExportHandler::ExportHandler (Session & session)
 
 ExportHandler::~ExportHandler ()
 {
-       // TODO remove files that were written but not finsihed
+       // TODO remove files that were written but not finished
 }
 
+/** Add an export to the `to-do' list */
 bool
 ExportHandler::add_export_config (ExportTimespanPtr timespan, ExportChannelConfigPtr channel_config,
                                   ExportFormatSpecPtr format, ExportFilenamePtr filename,
                                   BroadcastInfoPtr broadcast_info)
 {
        FileSpec spec (channel_config, format, filename, broadcast_info);
-       ConfigPair pair (timespan, spec);
-       config_map.insert (pair);
+       config_map.insert (make_pair (timespan, spec));
 
        return true;
 }
 
 void
-ExportHandler::do_export (bool rt)
+ExportHandler::do_export ()
 {
        /* Count timespans */
 
@@ -144,7 +149,6 @@ ExportHandler::do_export (bool rt)
 
        /* Start export */
 
-       realtime = rt;
        start_timespan ();
 }
 
@@ -159,16 +163,22 @@ ExportHandler::start_timespan ()
                return;
        }
 
+       /* finish_timespan pops the config_map entry that has been done, so
+          this is the timespan to do this time
+       */
        current_timespan = config_map.begin()->first;
+       
        export_status->total_frames_current_timespan = current_timespan->get_length();
        export_status->timespan_name = current_timespan->name();
        export_status->processed_frames_current_timespan = 0;
 
        /* Register file configurations to graph builder */
 
+       /* Here's the config_map entries that use this timespan */
        timespan_bounds = config_map.equal_range (current_timespan);
        graph_builder->reset ();
        graph_builder->set_current_timespan (current_timespan);
+       handle_duplicate_format_extensions();
        for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
                // Filenames can be shared across timespans
                FileSpec & spec = it->second;
@@ -181,7 +191,28 @@ ExportHandler::start_timespan ()
        normalizing = 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, realtime);
+       session.start_audio_export (process_position);
+}
+
+void
+ExportHandler::handle_duplicate_format_extensions()
+{
+       typedef std::map<std::string, int> ExtCountMap;
+
+       ExtCountMap counts;
+       for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
+               counts[it->second.format->extension()]++;
+       }
+
+       bool duplicates_found = false;
+       for (ExtCountMap::iterator it = counts.begin(); it != counts.end(); ++it) {
+               if (it->second > 1) { duplicates_found = true; }
+       }
+
+       // Set this always, as the filenames are shared...
+       for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
+               it->second.filename->include_format_name = duplicates_found;
+       }
 }
 
 int
@@ -250,28 +281,104 @@ ExportHandler::process_normalize ()
        return 0;
 }
 
+void
+ExportHandler::command_output(std::string output, size_t size)
+{
+       std::cerr << "command: " << size << ", " << output << std::endl;
+       info << output << endmsg;
+}
+
 void
 ExportHandler::finish_timespan ()
 {
        while (config_map.begin() != timespan_bounds.second) {
 
                ExportFormatSpecPtr fmt = config_map.begin()->second.format;
+               std::string filename = config_map.begin()->second.filename->get_path(fmt);
 
                if (fmt->with_cue()) {
-                       export_cd_marker_file (current_timespan, fmt, config_map.begin()->second.filename->get_path(fmt), CDMarkerCUE);
-               } 
+                       export_cd_marker_file (current_timespan, fmt, filename, CDMarkerCUE);
+               }
 
                if (fmt->with_toc()) {
-                       export_cd_marker_file (current_timespan, fmt, config_map.begin()->second.filename->get_path(fmt), CDMarkerTOC);
+                       export_cd_marker_file (current_timespan, fmt, filename, CDMarkerTOC);
+               }
+
+               if (fmt->tag()) {
+                       AudiofileTagger::tag_file(filename, *SessionMetadata::Metadata());
+               }
+
+               if (!fmt->command().empty()) {
+
+#if 0                  // would be nicer with C++11 initialiser...
+                       std::map<char, std::string> subs {
+                               { 'f', filename },
+                               { 'd', Glib::path_get_dirname(filename) },
+                               { 'b', PBD::basename_nosuffix(filename) },
+                               { 'u', upload_username },
+                               { 'p', upload_password}
+                       };
+#endif
+
+                       PBD::ScopedConnection command_connection;
+                       std::map<char, std::string> subs;
+                       subs.insert (std::pair<char, std::string> ('f', filename));
+                       subs.insert (std::pair<char, std::string> ('d', Glib::path_get_dirname(filename)));
+                       subs.insert (std::pair<char, std::string> ('b', PBD::basename_nosuffix(filename)));
+                       subs.insert (std::pair<char, std::string> ('u', upload_username));
+                       subs.insert (std::pair<char, std::string> ('p', upload_password));
+
+
+                       std::cerr << "running command: " << fmt->command() << "..." << std::endl;
+                       ARDOUR::SystemExec *se = new ARDOUR::SystemExec(fmt->command(), subs);
+                       se->ReadStdout.connect_same_thread(command_connection, boost::bind(&ExportHandler::command_output, this, _1, _2));
+                       if (se->start (2) == 0) {
+                               // successfully started
+                               std::cerr << "started!" << std::endl;
+                               while (se->is_running ()) {
+                                       // wait for system exec to terminate
+                                       // std::cerr << "waiting..." << std::endl;
+                                       usleep (1000);
+                               }
+                       }
+                       std::cerr << "done! deleting..." << std::endl;
+                       delete (se);
                }
 
+               if (fmt->upload()) {
+                       SoundcloudUploader *soundcloud_uploader = new SoundcloudUploader;
+                       std::string token = soundcloud_uploader->Get_Auth_Token(upload_username, upload_password);
+                       std::cerr
+                               << "uploading "
+                               << filename << std::endl
+                               << "username = " << upload_username
+                               << ", password = " << upload_password
+                               << " - token = " << token << " ..."
+                               << std::endl;
+                       std::string path = soundcloud_uploader->Upload (
+                                       filename,
+                                       PBD::basename_nosuffix(filename), // title
+                                       token,
+                                       upload_public,
+                                       this);
+
+                       if (path.length() != 0) {
+                               if (upload_open) {
+                               std::cerr << "opening " << path << " ..." << std::endl;
+                               open_uri(path.c_str());  // open the soundcloud website to the new file
+                               }
+                       } else {
+                               error << _("upload to Soundcloud failed.  Perhaps your email or password are incorrect?\n") << endmsg;
+                       }
+                       delete soundcloud_uploader;
+               }
                config_map.erase (config_map.begin());
        }
 
        start_timespan ();
 }
 
-/*** CD Marker sutff ***/
+/*** CD Marker stuff ***/
 
 struct LocationSortByStart {
     bool operator() (Location *a, Location *b) {
@@ -391,10 +498,10 @@ ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSp
 
        } catch (std::exception& e) {
                error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
-               ::unlink (filepath.c_str());
+               ::g_unlink (filepath.c_str());
        } catch (Glib::Exception& e) {
                error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
-               ::unlink (filepath.c_str());
+               ::g_unlink (filepath.c_str());
        }
 }