X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fexport_handler.cc;h=5710ecc45213624d2749bff190b5c41903cb3608;hb=fb45fdc052b23f4b2210c71a03a14bdb5986098a;hp=a85e41d40a64482380dac699aba1e427267bb83f;hpb=aae367b63c9b619db1e40f27dc334c6987219481;p=ardour.git

diff --git a/libs/ardour/export_handler.cc b/libs/ardour/export_handler.cc
index a85e41d40a..5710ecc452 100644
--- a/libs/ardour/export_handler.cc
+++ b/libs/ardour/export_handler.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2008 Paul Davis
+    Copyright (C) 2008-2009 Paul Davis
     Author: Sakari Bergen
 
     This program is free software; you can redistribute it and/or modify
@@ -20,20 +20,20 @@
 
 #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/ardour.h"
-#include "ardour/configuration.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_processor.h"
-#include "ardour/export_failed.h"
+
+#include "i18n.h"
 
 using namespace std;
 using namespace PBD;
@@ -54,275 +54,414 @@ 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 ***/
 
-ExportHandler::ExportHandler (Session & session) 
-	: ExportElementFactory (session)
-	, session (session)
-	, export_status (session.get_export_status ())
-	, realtime (false)
+ExportHandler::ExportHandler (Session & session)
+  : ExportElementFactory (session)
+  , session (session)
+  , graph_builder (new ExportGraphBuilder (session))
+  , export_status (session.get_export_status ())
+  , normalizing (false)
+  , cue_tracknum (0)
+  , cue_indexnum (0)
 {
-	processor.reset (new ExportProcessor (session));
-
-	ExportProcessor::WritingFile.connect (files_written_connection, boost::bind (&ExportHandler::add_file, this, _1));
 }
 
 ExportHandler::~ExportHandler ()
 {
-	if (export_status->aborted()) {
-		for (std::list<Glib::ustring>::iterator it = files_written.begin(); it != files_written.end(); ++it) {
-			sys::remove (sys::path (*it));
-		}
-	}
-
-	channel_config_connection.disconnect();
-	files_written_connection.disconnect();
-}
-
-void
-ExportHandler::add_file (const Glib::ustring& str)
-{
-	files_written.push_back (str);
+	// TODO remove files that were written but not finished
 }
 
+/** 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;
 }
 
-/// Starts exporting the registered configurations
-/** The following happens, when do_export is called:
- * 1. Session is prepared in do_export
- * 2. start_timespan is called, which then registers all necessary channel configs to a timespan
- * 3. The timespan reads each unique channel into a tempfile and calls Session::stop_export when the end is reached
- * 4. stop_export emits ExportReadFinished after stopping the transport, this ends up calling finish_timespan
- * 5. finish_timespan registers all the relevant formats and filenames to relevant channel configurations
- * 6. finish_timespan does a manual call to timespan_thread_finished, which gets the next channel configuration
- *    for the current timespan, calling write_files for it
- * 7. write_files writes the actual export files, composing them from the individual channels from tempfiles and
- *    emits FilesWritten when it is done, which ends up calling timespan_thread_finished
- * 8. Once all channel configs are written, a new timespan is started by calling start_timespan
- * 9. When all timespans are written the session is taken out of export.
- */
-
 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 */
 
-	realtime = rt;
-
-	session.ExportReadFinished.connect (export_read_finished_connection, boost::bind (&ExportHandler::finish_timespan, this));
 	start_timespan ();
 }
 
-struct LocationSortByStart {
-    bool operator() (Location *a, Location *b) {
-	    return a->start() < b->start();
-    }
-};
-
 void
-ExportHandler::export_cd_marker_file (TimespanPtr timespan, FormatPtr file_format, std::string filename, CDMarkerFormat format)
+ExportHandler::start_timespan ()
 {
-	string filepath;
-	string basename = Glib::path_get_basename(filename);
+	export_status->timespan++;
 
-	size_t ext_pos = basename.rfind('.');
-	if (ext_pos != string::npos) {
-		basename = basename.substr(0, ext_pos); /* strip file extension, if there is one */
+	if (config_map.empty()) {
+		// freewheeling has to be stopped from outside the process cycle
+		export_status->running = false;
+		return;
 	}
 
-	void (ExportHandler::*header_func) (CDMarkerStatus &);
-	void (ExportHandler::*track_func) (CDMarkerStatus &);
-	void (ExportHandler::*index_func) (CDMarkerStatus &);
+	/* 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;
 
-	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;
+	/* 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;
+		spec.filename->set_timespan (it->first);
+		graph_builder->add_config (spec);
 	}
 
-	CDMarkerStatus status (filepath, timespan, file_format, filename);
+	/* start export */
 
-	if (!status.out) {
-		error << string_compose(_("Editor: cannot open \"%1\" as export file for CD marker file"), filepath) << endmsg;
-		return;
+	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);
+}
+
+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; }
 	}
 
-	(this->*header_func) (status);
+	// 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;
+	}
+}
 
-	/* Get locations and sort */
+int
+ExportHandler::process (framecnt_t frames)
+{
+	if (!export_status->running) {
+		return 0;
+	} else if (normalizing) {
+		return process_normalize ();
+	} else {
+		return process_timespan (frames);
+	}
+}
+
+int
+ExportHandler::process_timespan (framecnt_t frames)
+{
+	/* update position */
 
-	Locations::LocationList const & locations (session.locations()->list());
-	Locations::LocationList::const_iterator i;
-	Locations::LocationList temp;
+	framecnt_t frames_to_read = 0;
+	framepos_t const end = current_timespan->get_end();
 
-	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);
+	bool const last_cycle = (process_position + frames >= end);
+
+	if (last_cycle) {
+		frames_to_read = end - process_position;
+		export_status->stop = true;
+	} else {
+		frames_to_read = frames;
+	}
+
+	process_position += frames_to_read;
+	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);
+
+	/* 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;
 		}
 	}
 
-	if (temp.empty()) {
-		// TODO One index marker for whole thing
-		return;
+	return ret;
+}
+
+int
+ExportHandler::process_normalize ()
+{
+	if (graph_builder->process_normalize ()) {
+		finish_timespan ();
+		export_status->normalizing = false;
+	} else {
+		export_status->normalizing = true;
 	}
 
-	LocationSortByStart cmp;
-	temp.sort (cmp);
-	Locations::LocationList::const_iterator nexti;
+	export_status->current_normalize_cycle++;
 
-	/* Start actual marker stuff */
+	return 0;
+}
 
-	nframes_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
-	status.track_position = last_start_time - timespan->get_start();
+void
+ExportHandler::finish_timespan ()
+{
+	while (config_map.begin() != timespan_bounds.second) {
 
-	for (i = temp.begin(); i != temp.end(); ++i) {
+		ExportFormatSpecPtr fmt = config_map.begin()->second.format;
 
-		status.marker = *i;
+		if (fmt->with_cue()) {
+			export_cd_marker_file (current_timespan, fmt, config_map.begin()->second.filename->get_path(fmt), CDMarkerCUE);
+		} 
 
-		if ((*i)->start() < last_end_time) {
-			if ((*i)->is_mark()) {
-				/* Index within track */
+		if (fmt->with_toc()) {
+			export_cd_marker_file (current_timespan, fmt, config_map.begin()->second.filename->get_path(fmt), CDMarkerTOC);
+		}
+
+		config_map.erase (config_map.begin());
+	}
+
+	start_timespan ();
+}
+
+/*** CD Marker sutff ***/
+
+struct LocationSortByStart {
+    bool operator() (Location *a, Location *b) {
+	    return a->start() < b->start();
+    }
+};
+
+void
+ExportHandler::export_cd_marker_file (ExportTimespanPtr timespan, ExportFormatSpecPtr file_format,
+                                      std::string filename, CDMarkerFormat format)
+{
+	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;
+		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);
 
-				status.index_position = (*i)->start() - timespan->get_start();
-				(this->*index_func) (status);
+		/* Get locations and sort */
+
+		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);
 			}
+		}
 
-			continue;
+		if (temp.empty()) {
+			// TODO One index marker for whole thing
+			return;
 		}
 
-		/* A track, defined by a cd range marker or a cd location marker outside of a cd range */
+		LocationSortByStart cmp;
+		temp.sort (cmp);
+		Locations::LocationList::const_iterator nexti;
 
-		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;
+		/* Start actual marker stuff */
 
-		if ((*i)->is_mark()) {
-			// a mark track location needs to look ahead to the next marker's start to determine length
-			nexti = i;
-			++nexti;
+		framepos_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
+		status.track_position = last_start_time - timespan->get_start();
 
-			if (nexti != temp.end()) {
-				status.track_duration = (*nexti)->start() - last_end_time;
+		for (i = temp.begin(); i != temp.end(); ++i) {
 
-				last_start_time = (*i)->start();
-				last_end_time = (*nexti)->start();
+			status.marker = *i;
+
+			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);
+				}
+
+				continue;
+			}
+
+			/* 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;
+
+			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;
+
+					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 {
-				// 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 occured 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;
+		::g_unlink (filepath.c_str());
 	}
 }
 
-void
-ExportHandler::write_cue_header (CDMarkerStatus & status)
+string
+ExportHandler::get_cd_marker_filename(std::string filename, CDMarkerFormat format)
 {
-	Glib::ustring title = status.timespan->name().compare ("Session") ? status.timespan->name() : (Glib::ustring) session.name();
-
-	status.out << "REM Cue file generated by Ardour" << endl;
-	status.out << "TITLE \"" << title << "\"" << endl;
-
-	/*  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
+	/* 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)
+	*/
 
-		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.
+	switch (format) {
+	  case CDMarkerTOC:
+		return filename + ".toc";
+	  case CDMarkerCUE:
+		return filename + ".cue";
+	  default:
+		return filename + ".marker"; // Should not be reached when actually creating a file
+	}
+}
 
-		For all other formats we just make up our own file type.  MP3 is not supported
-		at the moment.
+void
+ExportHandler::write_cue_header (CDMarkerStatus & status)
+{
+	string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
+
+	status.out << "REM Cue file generated by " << PROGRAM_NAME << endl;
+	status.out << "TITLE " << cue_escape_cdtext (title) << endl;
+
+	/*  The original cue sheet sepc metions 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
@@ -332,7 +471,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;
@@ -341,11 +480,12 @@ 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();
 
 	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 \"\"" << endl << "  }" << endl << "}" << endl;
 }
 
 void
@@ -370,18 +510,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) {
@@ -418,12 +558,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()) {
@@ -437,7 +583,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;
@@ -469,10 +615,10 @@ ExportHandler::write_index_info_toc (CDMarkerStatus & status)
 }
 
 void
-ExportHandler::frames_to_cd_frames_string (char* buf, nframes_t when)
+ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when)
 {
-	nframes_t remainder;
-	nframes_t fr = session.nominal_frame_rate();
+	framecnt_t remainder;
+	framecnt_t fr = session.nominal_frame_rate();
 	int mins, secs, frames;
 
 	mins = when / (60 * fr);
@@ -483,109 +629,83 @@ ExportHandler::frames_to_cd_frames_string (char* buf, nframes_t when)
 	sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
 }
 
-void
-ExportHandler::start_timespan ()
+std::string
+ExportHandler::toc_escape_cdtext (const std::string& txt)
 {
-	export_status->timespan++;
-
-	if (config_map.empty()) {
-		export_status->finish ();
-		return;
+	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));
 	}
 
-	current_timespan = config_map.begin()->first;
-
-	/* Register channel configs with timespan */
+	out = '"';
 
-	timespan_bounds = config_map.equal_range (current_timespan);
+	for (std::string::const_iterator c = latin1_txt.begin(); c != latin1_txt.end(); ++c) {
 
-	for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
-		it->second.channel_config->register_with_timespan (current_timespan);
+		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 += '"';
 
-	/* connect stuff and start export */
-
-	session.ProcessExport.connect (current_timespan->process_connection, boost::bind (&ExportTimespan::process, current_timespan, _1));
-	session.start_audio_export (current_timespan->get_start(), realtime);
+	return out;
 }
 
-void
-ExportHandler::finish_timespan ()
+std::string
+ExportHandler::toc_escape_filename (const std::string& txt)
 {
-	current_timespan->process_connection.disconnect ();
+	std::string out;
 
-	/* Register formats and filenames to relevant channel configs */
+	out = '"';
 
-	export_status->total_formats = 0;
-	export_status->format = 0;
+	// 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) {
 
-	for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
-
-		export_status->total_formats++;
-
-		/* Setup filename */
-
-		it->second.filename->set_timespan (current_timespan);
-		it->second.filename->set_channel_config (it->second.channel_config);
-
-		/* Do actual registration */
-
-		ChannelConfigPtr chan_config = it->second.channel_config;
-		chan_config->register_file_config (it->second.format, it->second.filename);
+		if (*c == '"') {
+			out += "\\\"";
+		} else if (*c == '\\') {
+			out += "\\134";
+		} else {
+			out += *c;
+		}
 	}
+	
+	out += '"';
 
-	/* Start writing files by doing a manual call to timespan_thread_finished */
-
-	current_map_it = timespan_bounds.first;
-	timespan_thread_finished ();
+	return out;
 }
 
-void
-ExportHandler::timespan_thread_finished ()
+std::string
+ExportHandler::cue_escape_cdtext (const std::string& txt)
 {
-	channel_config_connection.disconnect();
-	export_read_finished_connection.disconnect ();
-
-	if (current_map_it != timespan_bounds.second) {
-
-		/* Get next configuration as long as no new export process is started */
-
-		ChannelConfigPtr cc = current_map_it->second.channel_config;
-		while (!cc->write_files(processor)) {
-
-			++current_map_it;
-
-			if (current_map_it == timespan_bounds.second) {
-
-				/* reached end of bounds, this call will end up in the else block below */
-
-				timespan_thread_finished ();
-				return;
-			}
-
-			cc = current_map_it->second.channel_config;
-		}
-
-		cc->FilesWritten.connect (channel_config_connection, boost::bind (&ExportHandler::timespan_thread_finished, this));
-		++current_map_it;
-
-	} else { /* All files are written from current timespan, reset timespan and start new */
-
-		/* Unregister configs and remove configs with this timespan */
-
-		for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second;) {
-			it->second.channel_config->unregister_all ();
-
-			ConfigMap::iterator to_erase = it;
-			++it;
-			config_map.erase (to_erase);
-		}
-
-		/* Start new timespan */
-
-		start_timespan ();
-
+	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