X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fexport_handler.cc;h=5e3509167da50aee9ea27c8b8a3e4a0861d79ee0;hb=008eda2858efab4da5a0dc90c29977d56aa7eff2;hp=3ce07cf44d422ee47b529cc2a9cbaca22f6e96c2;hpb=dde0848a984e06cbc1d4117d9cffa75c191f3b39;p=ardour.git

diff --git a/libs/ardour/export_handler.cc b/libs/ardour/export_handler.cc
index 3ce07cf44d..5e3509167d 100644
--- a/libs/ardour/export_handler.cc
+++ b/libs/ardour/export_handler.cc
@@ -20,20 +20,27 @@
 
 #include "ardour/export_handler.h"
 
+#include "pbd/gstdio_compat.h"
 #include <glibmm.h>
+#include <glibmm/convert.h>
 
 #include "pbd/convert.h"
-#include "pbd/filesystem.h"
 
-#include "ardour/ardour.h"
-#include "ardour/configuration.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/export_failed.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"
 
 using namespace std;
 using namespace PBD;
@@ -54,46 +61,46 @@ ExportElementFactory::~ExportElementFactory ()
 
 }
 
-ExportElementFactory::TimespanPtr
+ExportTimespanPtr
 ExportElementFactory::add_timespan ()
 {
-	return TimespanPtr (new ExportTimespan (session.get_export_status(), session.frame_rate()));
+	return ExportTimespanPtr (new ExportTimespan (session.get_export_status(), session.frame_rate()));
 }
 
-ExportElementFactory::ChannelConfigPtr
+ExportChannelConfigPtr
 ExportElementFactory::add_channel_config ()
 {
-	return ChannelConfigPtr (new ExportChannelConfiguration (session));
+	return ExportChannelConfigPtr (new ExportChannelConfiguration (session));
 }
 
-ExportElementFactory::FormatPtr
+ExportFormatSpecPtr
 ExportElementFactory::add_format ()
 {
-	return FormatPtr (new ExportFormatSpecification (session));
+	return ExportFormatSpecPtr (new ExportFormatSpecification (session));
 }
 
-ExportElementFactory::FormatPtr
+ExportFormatSpecPtr
 ExportElementFactory::add_format (XMLNode const & state)
 {
-	return FormatPtr (new ExportFormatSpecification (session, state));
+	return ExportFormatSpecPtr (new ExportFormatSpecification (session, state));
 }
 
-ExportElementFactory::FormatPtr
-ExportElementFactory::add_format_copy (FormatPtr other)
+ExportFormatSpecPtr
+ExportElementFactory::add_format_copy (ExportFormatSpecPtr other)
 {
-	return FormatPtr (new ExportFormatSpecification (*other));
+	return ExportFormatSpecPtr (new ExportFormatSpecification (*other));
 }
 
-ExportElementFactory::FilenamePtr
+ExportFilenamePtr
 ExportElementFactory::add_filename ()
 {
-	return FilenamePtr (new ExportFilename (session));
+	return ExportFilenamePtr (new ExportFilename (session));
 }
 
-ExportElementFactory::FilenamePtr
-ExportElementFactory::add_filename_copy (FilenamePtr other)
+ExportFilenamePtr
+ExportElementFactory::add_filename_copy (ExportFilenamePtr other)
 {
-	return FilenamePtr (new ExportFilename (*other));
+	return ExportFilenamePtr (new ExportFilename (*other));
 }
 
 /*** ExportHandler ***/
@@ -103,43 +110,55 @@ 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)
 {
 }
 
 ExportHandler::~ExportHandler ()
 {
-	// TODO remove files that were written but not finsihed
+	graph_builder->cleanup (export_status->aborted () );
 }
 
+/** Add an export to the `to-do' list */
 bool
-ExportHandler::add_export_config (TimespanPtr timespan, ChannelConfigPtr channel_config, FormatPtr format, FilenamePtr filename)
+ExportHandler::add_export_config (ExportTimespanPtr timespan, ExportChannelConfigPtr channel_config,
+                                  ExportFormatSpecPtr format, ExportFilenamePtr filename,
+                                  BroadcastInfoPtr broadcast_info)
 {
-	FileSpec spec (channel_config, format, filename);
-	ConfigPair pair (timespan, spec);
-	config_map.insert (pair);
+	FileSpec spec (channel_config, format, filename, broadcast_info);
+	config_map.insert (make_pair (timespan, spec));
 
 	return true;
 }
 
 void
-ExportHandler::do_export (bool rt)
+ExportHandler::do_export ()
 {
 	/* Count timespans */
 
 	export_status->init();
-	std::set<TimespanPtr> timespan_set;
+	std::set<ExportTimespanPtr> timespan_set;
 	for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) {
-		timespan_set.insert (it->first);
+		bool new_timespan = timespan_set.insert (it->first).second;
+		if (new_timespan) {
+			export_status->total_frames += it->first->get_length();
+		}
 	}
 	export_status->total_timespans = timespan_set.size();
 
-	/* Start export */
+	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;
+		}
+	}
 
-	realtime = rt;
+	/* Start export */
 
-	session.ExportReadFinished.connect_same_thread (export_read_finished_connection, boost::bind (&ExportHandler::finish_timespan, this));
+	Glib::Threads::Mutex::Lock l (export_status->lock());
 	start_timespan ();
 }
 
@@ -149,36 +168,86 @@ ExportHandler::start_timespan ()
 	export_status->timespan++;
 
 	if (config_map.empty()) {
-		export_status->running = false;
+		// freewheeling has to be stopped from outside the process cycle
+		export_status->set_running (false);
 		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) {
-		graph_builder->add_config (it->second);
+		// Filenames can be shared across timespans
+		FileSpec & spec = it->second;
+		spec.filename->set_timespan (it->first);
+		graph_builder->add_config (spec);
 	}
 
 	/* start export */
 
-	session.ProcessExport.connect_same_thread (process_connection, boost::bind (&ExportHandler::process_timespan, this, _1));
+	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
+ExportHandler::process (framecnt_t frames)
+{
+	if (!export_status->running ()) {
+		return 0;
+	} else if (normalizing) {
+		Glib::Threads::Mutex::Lock l (export_status->lock());
+		return process_normalize ();
+	} else {
+		Glib::Threads::Mutex::Lock l (export_status->lock());
+		return process_timespan (frames);
+	}
 }
 
 int
-ExportHandler::process_timespan (nframes_t frames)
+ExportHandler::process_timespan (framecnt_t frames)
 {
+	export_status->active_job = ExportStatus::Exporting;
 	/* update position */
 
-	nframes_t frames_to_read = 0;
-	sframes_t const start = current_timespan->get_start();
-	sframes_t const end = current_timespan->get_end();
-	
+	framecnt_t frames_to_read = 0;
+	framepos_t const end = current_timespan->get_end();
+
 	bool const last_cycle = (process_position + frames >= end);
 
 	if (last_cycle) {
@@ -189,26 +258,153 @@ ExportHandler::process_timespan (nframes_t frames)
 	}
 
 	process_position += frames_to_read;
-	export_status->progress = (float) (process_position - start) / (end - start);
+	export_status->processed_frames += frames_to_read;
+	export_status->processed_frames_current_timespan += frames_to_read;
 
 	/* Do actual processing */
+	int ret = graph_builder->process (frames_to_read, last_cycle);
 
-	return graph_builder->process (frames_to_read, last_cycle);
+	/* Start 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;
+		} else {
+			finish_timespan ();
+			return 0;
+		}
+	}
+
+	return ret;
+}
+
+int
+ExportHandler::process_normalize ()
+{
+	if (graph_builder->process_normalize ()) {
+		finish_timespan ();
+		export_status->active_job = ExportStatus::Exporting;
+	} else {
+		export_status->active_job = ExportStatus::Normalizing;
+	}
+
+	export_status->current_normalize_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 ()
 {
-	process_connection.disconnect ();
-	
+	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, filename, CDMarkerCUE);
+		}
+
+		if (fmt->with_toc()) {
+			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()) {
+
+#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;
+			subs.insert (std::pair<char, std::string> ('f', filename));
+			subs.insert (std::pair<char, std::string> ('d', Glib::path_get_dirname (filename) + G_DIR_SEPARATOR));
+			subs.insert (std::pair<char, std::string> ('b', PBD::basename_nosuffix (filename)));
+			subs.insert (std::pair<char, std::string> ('s', session.path ()));
+			subs.insert (std::pair<char, std::string> ('n', session.name ()));
+
+			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) {
@@ -217,150 +413,180 @@ struct LocationSortByStart {
 };
 
 void
-ExportHandler::export_cd_marker_file (TimespanPtr timespan, FormatPtr file_format, std::string filename, CDMarkerFormat format)
+ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSpecPtr file_format,
+                                      std::string filename, CDMarkerFormat format)
 {
-	string filepath;
-	string basename = Glib::path_get_basename(filename);
-
-	size_t ext_pos = basename.rfind('.');
-	if (ext_pos != string::npos) {
-		basename = basename.substr(0, ext_pos); /* strip file extension, if there is one */
-	}
-
-	void (ExportHandler::*header_func) (CDMarkerStatus &);
-	void (ExportHandler::*track_func) (CDMarkerStatus &);
-	void (ExportHandler::*index_func) (CDMarkerStatus &);
-
-	switch (format) {
-	  case CDMarkerTOC:
-		filepath = Glib::build_filename(Glib::path_get_dirname(filename), basename + ".toc");
-		header_func = &ExportHandler::write_toc_header;
-		track_func = &ExportHandler::write_track_info_toc;
-		index_func = &ExportHandler::write_index_info_toc;
-		break;
-	  case CDMarkerCUE:
-		filepath = Glib::build_filename(Glib::path_get_dirname(filename), basename + ".cue");
-		header_func = &ExportHandler::write_cue_header;
-		track_func = &ExportHandler::write_track_info_cue;
-		index_func = &ExportHandler::write_index_info_cue;
-		break;
-	  default:
-		return;
-	}
+	string filepath = get_cd_marker_filename(filename, format);
+
+	try {
+		void (ExportHandler::*header_func) (CDMarkerStatus &);
+		void (ExportHandler::*track_func) (CDMarkerStatus &);
+		void (ExportHandler::*index_func) (CDMarkerStatus &);
+
+		switch (format) {
+		case CDMarkerTOC:
+			header_func = &ExportHandler::write_toc_header;
+			track_func = &ExportHandler::write_track_info_toc;
+			index_func = &ExportHandler::write_index_info_toc;
+			break;
+		case CDMarkerCUE:
+			header_func = &ExportHandler::write_cue_header;
+			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);
+		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);
 
-	(this->*header_func) (status);
+		/* Get locations and sort */
 
-	/* Get locations and sort */
+		Locations::LocationList const & locations (session.locations()->list());
+		Locations::LocationList::const_iterator i;
+		Locations::LocationList temp;
 
-	Locations::LocationList const & locations (session.locations()->list());
-	Locations::LocationList::const_iterator i;
-	Locations::LocationList temp;
+		for (i = locations.begin(); i != locations.end(); ++i) {
+			if ((*i)->start() >= timespan->get_start() && (*i)->end() <= timespan->get_end() && (*i)->is_cd_marker() && !(*i)->is_session_range()) {
+				temp.push_back (*i);
+			}
+		}
 
-	for (i = locations.begin(); i != locations.end(); ++i) {
-		if ((*i)->start() >= timespan->get_start() && (*i)->end() <= timespan->get_end() && (*i)->is_cd_marker() && !(*i)->is_end()) {
-			temp.push_back (*i);
+		if (temp.empty()) {
+			// TODO One index marker for whole thing
+			return;
 		}
-	}
 
-	if (temp.empty()) {
-		// TODO One index marker for whole thing
-		return;
-	}
+		LocationSortByStart cmp;
+		temp.sort (cmp);
+		Locations::LocationList::const_iterator nexti;
 
-	LocationSortByStart cmp;
-	temp.sort (cmp);
-	Locations::LocationList::const_iterator nexti;
+		/* Start actual marker stuff */
 
-	/* Start actual marker stuff */
+		framepos_t last_end_time = timespan->get_start();
+		status.track_position = 0;
 
-	sframes_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
-	status.track_position = last_start_time - timespan->get_start();
+		for (i = temp.begin(); i != temp.end(); ++i) {
 
-	for (i = temp.begin(); i != temp.end(); ++i) {
+			status.marker = *i;
 
-		status.marker = *i;
+			if ((*i)->start() < last_end_time) {
+				if ((*i)->is_mark()) {
+					/* Index within track */
 
-		if ((*i)->start() < last_end_time) {
-			if ((*i)->is_mark()) {
-				/* Index within track */
+					status.index_position = (*i)->start() - timespan->get_start();
+					(this->*index_func) (status);
+				}
 
-				status.index_position = (*i)->start() - timespan->get_start();
-				(this->*index_func) (status);
+				continue;
 			}
 
-			continue;
-		}
+			/* A track, defined by a cd range marker or a cd location marker outside of a cd range */
 
-		/* A track, defined by a cd range marker or a cd location marker outside of a cd range */
+			status.track_position = last_end_time - timespan->get_start();
+			status.track_start_frame = (*i)->start() - timespan->get_start();  // everything before this is the pregap
+			status.track_duration = 0;
 
-		status.track_position = last_end_time - timespan->get_start();
-		status.track_start_frame = (*i)->start() - timespan->get_start();  // everything before this is the pregap
-		status.track_duration = 0;
+			if ((*i)->is_mark()) {
+				// a mark track location needs to look ahead to the next marker's start to determine length
+				nexti = i;
+				++nexti;
 
-		if ((*i)->is_mark()) {
-			// a mark track location needs to look ahead to the next marker's start to determine length
-			nexti = i;
-			++nexti;
+				if (nexti != temp.end()) {
+					status.track_duration = (*nexti)->start() - last_end_time;
 
-			if (nexti != temp.end()) {
-				status.track_duration = (*nexti)->start() - last_end_time;
+					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 = (*nexti)->start();
+					last_end_time = timespan->get_end();
+				}
 			} else {
-				// this was the last marker, use timespan end
-				status.track_duration = timespan->get_end() - last_end_time;
+				// range
+				status.track_duration = (*i)->end() - last_end_time;
 
-				last_start_time = (*i)->start();
-				last_end_time = timespan->get_end();
+				last_end_time = (*i)->end();
 			}
-		} else {
-			// range
-			status.track_duration = (*i)->end() - last_end_time;
 
-			last_start_time = (*i)->start();
-			last_end_time = (*i)->end();
+			(this->*track_func) (status);
 		}
 
-		(this->*track_func) (status);
+	} catch (std::exception& e) {
+		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 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,
+	   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:
+		return filename + ".toc";
+	case CDMarkerCUE:
+		return filename + ".cue";
+	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
 	}
 }
 
 void
 ExportHandler::write_cue_header (CDMarkerStatus & status)
 {
-	Glib::ustring title = status.timespan->name().compare ("Session") ? status.timespan->name() : (Glib::ustring) session.name();
+	string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
 
-	status.out << "REM Cue file generated by Ardour" << endl;
-	status.out << "TITLE \"" << title << "\"" << endl;
+	// Album metadata
+	string barcode      = SessionMetadata::Metadata()->barcode();
+	string album_artist = SessionMetadata::Metadata()->album_artist();
+	string album_title  = SessionMetadata::Metadata()->album();
 
-	/*  The cue sheet syntax has originally five file types:
-		WAVE     : 44.1 kHz, 16 Bit (little endian)
-		AIFF     : 44.1 kHz, 16 Bit (big endian)
-		BINARY   : 44.1 kHz, 16 Bit (little endian)
-		MOTOROLA : 44.1 kHz, 16 Bit (big endian)
-		MP3
+	status.out << "REM Cue file generated by " << PROGRAM_NAME << endl;
 
-		We want to use cue sheets not only as CD images but also as general playlyist
-		format, thus for WAVE and AIFF we don't care if it's really 44.1 kHz/16 Bit, the
-		soundfile's header shows it anyway.  But for the raw formats, i.e. BINARY
-		and MOTOROLA we do care, because no header would tell us about a different format.
+	if (barcode != "")
+		status.out << "CATALOG " << barcode << endl;
 
-		For all other formats we just make up our own file type.  MP3 is not supported
-		at the moment.
-	*/
+	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 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
+		default to our own names otherwise.
+	*/
 	status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
-	if (!status.format->format_name().compare ("WAV")) {
+	if (!status.format->format_name().compare ("WAV")  || !status.format->format_name().compare ("BWF")) {
 		status.out  << "WAVE";
-	} else if (status.format->format_name() == ExportFormatBase::F_RAW &&
+	} else if (status.format->format_id() == ExportFormatBase::F_RAW &&
 	           status.format->sample_format() == ExportFormatBase::SF_16 &&
 	           status.format->sample_rate() == ExportFormatBase::SR_44_1) {
 		// Format is RAW 16bit 44.1kHz
@@ -370,7 +596,7 @@ ExportHandler::write_cue_header (CDMarkerStatus & status)
 			status.out << "MOTOROLA";
 		}
 	} else {
-		// AIFF should return "AIFF"
+		// no special case for AIFF format it's name is already "AIFF"
 		status.out << status.format->format_name();
 	}
 	status.out << endl;
@@ -379,11 +605,30 @@ ExportHandler::write_cue_header (CDMarkerStatus & status)
 void
 ExportHandler::write_toc_header (CDMarkerStatus & status)
 {
-	Glib::ustring title = status.timespan->name().compare ("Session") ? status.timespan->name() : (Glib::ustring) session.name();
+	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 \"" << title << "\"" << endl << "  }" << endl << "}" << endl;
+	status.out << "  LANGUAGE 0 {" << endl << "    TITLE " << toc_escape_cdtext (title) << 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
@@ -408,18 +653,18 @@ ExportHandler::write_track_info_cue (CDMarkerStatus & status)
 
 	if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end())  {
 		status.out << "    ISRC " << status.marker->cd_info["isrc"] << endl;
-
 	}
+
 	if (status.marker->name() != "") {
-		status.out << "    TITLE \"" << status.marker->name() << "\"" << endl;
+		status.out << "    TITLE " << cue_escape_cdtext (status.marker->name()) << endl;
 	}
 
 	if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) {
-		status.out << "    PERFORMER \"" <<  status.marker->cd_info["performer"] << "\"" << endl;
+		status.out <<  "    PERFORMER " << cue_escape_cdtext (status.marker->cd_info["performer"]) << endl;
 	}
 
-	if (status.marker->cd_info.find("string_composer") != status.marker->cd_info.end()) {
-		status.out << "    SONGWRITER \"" << status.marker->cd_info["string_composer"]  << "\"" << endl;
+	if (status.marker->cd_info.find("composer") != status.marker->cd_info.end()) {
+		status.out << "    SONGWRITER " << cue_escape_cdtext (status.marker->cd_info["composer"]) << endl;
 	}
 
 	if (status.track_position != status.track_start_frame) {
@@ -456,12 +701,18 @@ ExportHandler::write_track_info_toc (CDMarkerStatus & status)
 		status.out << "ISRC \"" << status.marker->cd_info["isrc"] << "\"" << endl;
 	}
 
-	status.out << "CD_TEXT {" << endl << "  LANGUAGE 0 {" << endl << "     TITLE \"" << status.marker->name() << "\"" << endl;
+	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 << "     PERFORMER \"" << status.marker->cd_info["performer"]  << "\"" << endl;
+		status.out << toc_escape_cdtext (status.marker->cd_info["performer"]) << endl;
+	} else {
+		status.out << "\"\"" << endl;
 	}
-	if (status.marker->cd_info.find("string_composer") != status.marker->cd_info.end()) {
-		status.out  << "     COMPOSER \"" << status.marker->cd_info["string_composer"] << "\"" << 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;
 	}
 
 	if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
@@ -475,7 +726,7 @@ ExportHandler::write_track_info_toc (CDMarkerStatus & status)
 	status.out << "  }" << endl << "}" << endl;
 
 	frames_to_cd_frames_string (buf, status.track_position);
-	status.out << "FILE \"" << status.filename << "\" " << buf;
+	status.out << "FILE " << toc_escape_filename (status.filename) << ' ' << buf;
 
 	frames_to_cd_frames_string (buf, status.track_duration);
 	status.out << buf << endl;
@@ -484,6 +735,14 @@ ExportHandler::write_track_info_toc (CDMarkerStatus & status)
 	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)
 {
@@ -507,10 +766,15 @@ ExportHandler::write_index_info_toc (CDMarkerStatus & status)
 }
 
 void
-ExportHandler::frames_to_cd_frames_string (char* buf, sframes_t when)
+ExportHandler::write_index_info_mp4ch (CDMarkerStatus & status)
 {
-	sframes_t remainder;
-	nframes_t fr = session.nominal_frame_rate();
+}
+
+void
+ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when)
+{
+	framecnt_t remainder;
+	framecnt_t fr = session.nominal_frame_rate();
 	int mins, secs, frames;
 
 	mins = when / (60 * fr);
@@ -521,4 +785,100 @@ ExportHandler::frames_to_cd_frames_string (char* buf, sframes_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)
+{
+	Glib::ustring check (txt);
+	std::string out;
+	std::string latin1_txt;
+	char buf[5];
+
+	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));
+	}
+
+	out = '"';
+
+	for (std::string::const_iterator c = latin1_txt.begin(); c != latin1_txt.end(); ++c) {
+
+		if ((*c) == '"') {
+			out += "\\\"";
+		} else if ((*c) == '\\') {
+			out += "\\134";
+		} else if (isprint (*c)) {
+			out += *c;
+		} else {
+			snprintf (buf, sizeof (buf), "\\%03o", (int) (unsigned char) *c);
+			out += buf;
+		}
+	}
+
+	out += '"';
+
+	return out;
+}
+
+std::string
+ExportHandler::toc_escape_filename (const std::string& txt)
+{
+	std::string out;
+
+	out = '"';
+
+	// We iterate byte-wise not character-wise over a UTF-8 string here,
+	// because we only want to translate backslashes and double quotes
+	for (std::string::const_iterator c = txt.begin(); c != txt.end(); ++c) {
+
+		if (*c == '"') {
+			out += "\\\"";
+		} else if (*c == '\\') {
+			out += "\\134";
+		} else {
+			out += *c;
+		}
+	}
+
+	out += '"';
+
+	return out;
+}
+
+std::string
+ExportHandler::cue_escape_cdtext (const std::string& txt)
+{
+	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
+	out = '"' + latin1_txt + '"';
+
+	return out;
+}
+
 } // namespace ARDOUR