#include "ardour/export_handler.h"
-#include <glib/gstdio.h>
+#include "pbd/gstdio_compat.h"
#include <glibmm.h>
#include <glibmm/convert.h>
#include "pbd/convert.h"
+#include "ardour/audioengine.h"
+#include "ardour/audiofile_tagger.h"
+#include "ardour/debug.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"
+#include "pbd/i18n.h"
using namespace std;
using namespace PBD;
, session (session)
, graph_builder (new ExportGraphBuilder (session))
, export_status (session.get_export_status ())
- , normalizing (false)
+ , post_processing (false)
, cue_tracknum (0)
, cue_indexnum (0)
{
ExportHandler::~ExportHandler ()
{
- // TODO remove files that were written but not finished
+ graph_builder->cleanup (export_status->aborted () );
}
/** Add an export to the `to-do' list */
}
export_status->total_timespans = timespan_set.size();
+ if (export_status->total_timespans > 1) {
+ // always include timespan if there's more than one.
+ for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) {
+ FileSpec & spec = it->second;
+ spec.filename->include_timespan = true;
+ }
+ }
+
/* Start export */
+ Glib::Threads::Mutex::Lock l (export_status->lock());
start_timespan ();
}
if (config_map.empty()) {
// freewheeling has to be stopped from outside the process cycle
- export_status->running = false;
+ export_status->set_running (false);
return;
}
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;
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
int
ExportHandler::process (framecnt_t frames)
{
- if (!export_status->running) {
+ if (!export_status->running ()) {
return 0;
- } else if (normalizing) {
- return process_normalize ();
+ } else if (post_processing) {
+ Glib::Threads::Mutex::Lock l (export_status->lock());
+ 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);
}
}
int
ExportHandler::process_timespan (framecnt_t frames)
{
+ export_status->active_job = ExportStatus::Exporting;
/* update position */
framecnt_t frames_to_read = 0;
/* 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;
}
int
-ExportHandler::process_normalize ()
+ExportHandler::post_process ()
{
- if (graph_builder->process_normalize ()) {
+ if (graph_builder->post_process ()) {
finish_timespan ();
- export_status->normalizing = false;
+ export_status->active_job = ExportStatus::Exporting;
} else {
- export_status->normalizing = true;
+ 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;
}
+void
+ExportHandler::command_output(std::string output, size_t size)
+{
+ std::cerr << "command: " << size << ", " << output << std::endl;
+ info << output << endmsg;
+}
+
void
ExportHandler::finish_timespan ()
{
+ graph_builder->get_analysis_results (export_status->result_map);
+
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->with_mp4chaps()) {
+ export_cd_marker_file (current_timespan, fmt, filename, MP4Chaps);
+ }
+
+ Session::Exported (current_timespan->name(), filename); /* EMIT SIGNAL */
+
+ /* close file first, otherwise TagLib enounters an ERROR_SHARING_VIOLATION
+ * The process cannot access the file because it is being used.
+ * ditto for post-export and upload.
+ */
+ graph_builder->reset ();
+
+ if (fmt->tag()) {
+ /* TODO: check Umlauts and encoding in filename.
+ * TagLib eventually calls CreateFileA(),
+ */
+ export_status->active_job = ExportStatus::Tagging;
+ AudiofileTagger::tag_file(filename, *SessionMetadata::Metadata());
+ }
+
+ if (!fmt->command().empty()) {
+ SessionMetadata const & metadata (*SessionMetadata::Metadata());
+
+#if 0 // would be nicer with C++11 initialiser...
+ std::map<char, std::string> subs {
+ { 'f', filename },
+ { 'd', Glib::path_get_dirname(filename) + G_DIR_SEPARATOR },
+ { 'b', PBD::basename_nosuffix(filename) },
+ ...
+ };
+#endif
+ export_status->active_job = ExportStatus::Command;
+ PBD::ScopedConnection command_connection;
+ std::map<char, std::string> subs;
+
+ 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;
+ se->ReadStdout.connect_same_thread(command_connection, boost::bind(&ExportHandler::command_output, this, _1, _2));
+ int ret = se->start (2);
+ if (ret == 0) {
+ // successfully started
+ while (se->is_running ()) {
+ // wait for system exec to terminate
+ Glib::usleep (1000);
+ }
+ } else {
+ error << "Post-export command FAILED with Error: " << ret << endmsg;
+ }
+ delete (se);
}
+ if (fmt->soundcloud_upload()) {
+ SoundcloudUploader *soundcloud_uploader = new SoundcloudUploader;
+ std::string token = soundcloud_uploader->Get_Auth_Token(soundcloud_username, soundcloud_password);
+ DEBUG_TRACE (DEBUG::Soundcloud, string_compose(
+ "uploading %1 - username=%2, password=%3, token=%4",
+ filename, soundcloud_username, soundcloud_password, token) );
+ std::string path = soundcloud_uploader->Upload (
+ filename,
+ PBD::basename_nosuffix(filename), // title
+ token,
+ soundcloud_make_public,
+ soundcloud_downloadable,
+ this);
+
+ if (path.length() != 0) {
+ info << string_compose ( _("File %1 uploaded to %2"), filename, path) << endmsg;
+ if (soundcloud_open_page) {
+ DEBUG_TRACE (DEBUG::Soundcloud, string_compose ("opening %1", path) );
+ 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) {
track_func = &ExportHandler::write_track_info_cue;
index_func = &ExportHandler::write_index_info_cue;
break;
+ case MP4Chaps:
+ header_func = &ExportHandler::write_mp4ch_header;
+ track_func = &ExportHandler::write_track_info_mp4ch;
+ index_func = &ExportHandler::write_index_info_mp4ch;
+ break;
default:
return;
}
CDMarkerStatus status (filepath, timespan, file_format, filename);
- if (!status.out) {
- error << string_compose(_("Editor: cannot open \"%1\" as export file for CD marker file"), filepath) << endmsg;
- return;
- }
-
(this->*header_func) (status);
/* Get locations and sort */
/* Start actual marker stuff */
- framepos_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
- status.track_position = last_start_time - timespan->get_start();
+ framepos_t last_end_time = timespan->get_start();
+ status.track_position = 0;
for (i = temp.begin(); i != temp.end(); ++i) {
if (nexti != temp.end()) {
status.track_duration = (*nexti)->start() - last_end_time;
- last_start_time = (*i)->start();
last_end_time = (*nexti)->start();
} else {
// this was the last marker, use timespan end
status.track_duration = timespan->get_end() - last_end_time;
- last_start_time = (*i)->start();
last_end_time = timespan->get_end();
}
} else {
// range
status.track_duration = (*i)->end() - last_end_time;
- last_start_time = (*i)->start();
last_end_time = (*i)->end();
}
}
} catch (std::exception& e) {
- error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
+ error << string_compose (_("an error occurred while writing a TOC/CUE file: %1"), e.what()) << endmsg;
::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;
+ error << string_compose (_("an error occurred while writing a TOC/CUE file: %1"), e.what()) << endmsg;
::g_unlink (filepath.c_str());
}
}
string
ExportHandler::get_cd_marker_filename(std::string filename, CDMarkerFormat format)
{
- /* do not strip file suffix because there may be more than one format,
+ /* do not strip file suffix because there may be more than one format,
and we do not want the CD marker file from one format to overwrite
another (e.g. foo.wav.cue > foo.aiff.cue)
*/
switch (format) {
- case CDMarkerTOC:
+ case CDMarkerTOC:
return filename + ".toc";
- case CDMarkerCUE:
+ case CDMarkerCUE:
return filename + ".cue";
- default:
+ case MP4Chaps:
+ {
+ unsigned lastdot = filename.find_last_of('.');
+ return filename.substr(0,lastdot) + ".chapters.txt";
+ }
+ default:
return filename + ".marker"; // Should not be reached when actually creating a file
}
}
{
string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
+ // Album metadata
+ string barcode = SessionMetadata::Metadata()->barcode();
+ string album_artist = SessionMetadata::Metadata()->album_artist();
+ string album_title = SessionMetadata::Metadata()->album();
+
status.out << "REM Cue file generated by " << PROGRAM_NAME << endl;
+
+ if (barcode != "")
+ status.out << "CATALOG " << barcode << endl;
+
+ if (album_artist != "")
+ status.out << "PERFORMER " << cue_escape_cdtext (album_artist) << endl;
+
+ if (album_title != "")
+ title = album_title;
+
status.out << "TITLE " << cue_escape_cdtext (title) << endl;
- /* The original cue sheet sepc metions five file types
+ /* The original cue sheet spec mentions five file types
WAVE, AIFF,
BINARY = "header-less" audio (44.1 kHz, 16 Bit, little endian),
MOTOROLA = "header-less" audio (44.1 kHz, 16 Bit, big endian),
and MP3
-
- We try to use these file types whenever appropriate and
+
+ We try to use these file types whenever appropriate and
default to our own names otherwise.
*/
status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
{
string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
+ // Album metadata
+ string barcode = SessionMetadata::Metadata()->barcode();
+ string album_artist = SessionMetadata::Metadata()->album_artist();
+ string album_title = SessionMetadata::Metadata()->album();
+
+ if (barcode != "")
+ status.out << "CATALOG \"" << barcode << "\"" << endl;
+
+ if (album_title != "")
+ title = album_title;
+
status.out << "CD_DA" << endl;
status.out << "CD_TEXT {" << endl << " LANGUAGE_MAP {" << endl << " 0 : EN" << endl << " }" << endl;
status.out << " LANGUAGE 0 {" << endl << " TITLE " << toc_escape_cdtext (title) << endl ;
- status.out << " PERFORMER \"\"" << endl << " }" << endl << "}" << endl;
+ status.out << " PERFORMER " << toc_escape_cdtext (album_artist) << endl;
+ status.out << " }" << endl << "}" << endl;
+}
+
+void
+ExportHandler::write_mp4ch_header (CDMarkerStatus & status)
+{
+ status.out << "00:00:00.000 Intro" << endl;
}
void
status.out << "CD_TEXT {" << endl << " LANGUAGE 0 {" << endl;
status.out << " TITLE " << toc_escape_cdtext (status.marker->name()) << endl;
-
+
status.out << " PERFORMER ";
if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) {
status.out << toc_escape_cdtext (status.marker->cd_info["performer"]) << endl;
} else {
status.out << "\"\"" << endl;
}
-
+
if (status.marker->cd_info.find("composer") != status.marker->cd_info.end()) {
status.out << " SONGWRITER " << toc_escape_cdtext (status.marker->cd_info["composer"]) << endl;
}
status.out << "START" << buf << endl;
}
+void ExportHandler::write_track_info_mp4ch (CDMarkerStatus & status)
+{
+ gchar buf[18];
+
+ frames_to_chapter_marks_string(buf, status.track_start_frame);
+ status.out << buf << " " << status.marker->name() << endl;
+}
+
void
ExportHandler::write_index_info_cue (CDMarkerStatus & status)
{
status.out << "INDEX" << buf << endl;
}
+void
+ExportHandler::write_index_info_mp4ch (CDMarkerStatus & status)
+{
+}
+
void
ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when)
{
sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
}
+void
+ExportHandler::frames_to_chapter_marks_string (char* buf, framepos_t when)
+{
+ framecnt_t remainder;
+ framecnt_t fr = session.nominal_frame_rate();
+ int hours, mins, secs, msecs;
+
+ hours = when / (3600 * fr);
+ remainder = when - (hours * 3600 * fr);
+ mins = remainder / (60 * fr);
+ remainder -= mins * 60 * fr;
+ secs = remainder / fr;
+ remainder -= secs * fr;
+ msecs = (remainder * 1000) / fr;
+ sprintf (buf, "%02d:%02d:%02d.%03d", hours, mins, secs, msecs);
+}
+
std::string
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));
}
out += buf;
}
}
-
+
out += '"';
return out;
out += *c;
}
}
-
+
out += '"';
return out;
{
std::string latin1_txt;
std::string out;
-
+
try {
latin1_txt = Glib::convert (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));
}
-
+
// does not do much mor than UTF-8 to Latin1 translation yet, but
- // that may have to change if cue parsers in burning programs change
+ // that may have to change if cue parsers in burning programs change
out = '"' + latin1_txt + '"';
return out;
projects / ardour.git / blobdiff