/*
- 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
#include "ardour/export_handler.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/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 "ardour/session_metadata.h"
+
+#include "i18n.h"
+using namespace std;
using namespace PBD;
-using std::ofstream;
namespace ARDOUR
{
}
-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));
-
- files_written_connection = ExportProcessor::WritingFile.connect (sigc::mem_fun (files_written, &std::list<Glib::ustring>::push_back));
}
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();
+ // 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 (sigc::mem_fun (*this, &ExportHandler::finish_timespan));
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;
- void (ExportHandler::*header_func) (CDMarkerStatus &);
- void (ExportHandler::*track_func) (CDMarkerStatus &);
- void (ExportHandler::*index_func) (CDMarkerStatus &);
+ export_status->timespan++;
- switch (format) {
- case CDMarkerTOC:
- filepath = filename + ".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 = filename + ".cue";
- header_func = &ExportHandler::write_cue_header;
- track_func = &ExportHandler::write_track_info_cue;
- index_func = &ExportHandler::write_index_info_cue;
- break;
- default:
+ if (config_map.empty()) {
+ // freewheeling has to be stopped from outside the process cycle
+ export_status->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;
- CDMarkerStatus status (filepath, timespan, file_format, filename);
+ export_status->total_frames_current_timespan = current_timespan->get_length();
+ export_status->timespan_name = current_timespan->name();
+ export_status->processed_frames_current_timespan = 0;
- if (!status.out) {
- error << string_compose(_("Editor: cannot open \"%1\" as export file for CD marker file"), filepath) << endmsg;
- 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);
+ }
+
+ /* start export */
+
+ 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);
-
- /* 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_end()) {
- temp.push_back (*i);
+ // 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) {
+ return process_normalize ();
+ } else {
+ return process_timespan (frames);
+ }
+}
+
+int
+ExportHandler::process_timespan (framecnt_t frames)
+{
+ /* update position */
+
+ 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) {
+ 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;
- /* Start actual marker stuff */
+ export_status->current_normalize_cycle++;
- nframes_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
- status.track_position = last_start_time - timespan->get_start();
+ return 0;
+}
- for (i = temp.begin(); i != temp.end(); ++i) {
+void
+ExportHandler::finish_timespan ()
+{
+ while (config_map.begin() != timespan_bounds.second) {
- status.marker = *i;
+ ExportFormatSpecPtr fmt = config_map.begin()->second.format;
+ std::string filename = config_map.begin()->second.filename->get_path(fmt);
- 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);
+ 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->tag()) {
+ AudiofileTagger::tag_file(filename, *SessionMetadata::Metadata());
+ }
+
+ 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);
+
+ /* 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;
}
- /* 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();
+ if (temp.empty()) {
+ // TODO One index marker for whole thing
+ return;
+ }
+
+ LocationSortByStart cmp;
+ temp.sort (cmp);
+ Locations::LocationList::const_iterator nexti;
+
+ /* 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();
+
+ for (i = temp.begin(); i != temp.end(); ++i) {
+
+ 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;
+ ::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());
+ }
+}
+
+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";
+ 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;
+ status.out << "REM Cue file generated by " << PROGRAM_NAME << endl;
+ status.out << "TITLE " << cue_escape_cdtext (title) << endl;
- // TODO
- if (!status.format->format_name().compare ("WAV")) {
- status.out << "FILE " << status.filename << " WAVE" << 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") || !status.format->format_name().compare ("BWF")) {
+ status.out << "WAVE";
+ } 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
+ if (status.format->endianness() == ExportFormatBase::E_Little) {
+ status.out << "BINARY";
+ } else {
+ status.out << "MOTOROLA";
+ }
} else {
- status.out << "FILE \"" << status.filename << "\" " << status.format->format_name() << endl;
+ // no special case for AIFF format it's name is already "AIFF"
+ status.out << status.format->format_name();
}
+ status.out << endl;
}
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
{
gchar buf[18];
- status.out << endl << "TRACK " << status.track_number << " AUDIO" << endl;
- status.out << "FLAGS " ;
-
+ snprintf (buf, sizeof(buf), " TRACK %02d AUDIO", status.track_number);
+ status.out << buf << endl;
+
+ status.out << " FLAGS" ;
if (status.marker->cd_info.find("scms") != status.marker->cd_info.end()) {
- status.out << "SCMS ";
+ status.out << " SCMS ";
} else {
- status.out << "DCP ";
+ status.out << " DCP ";
}
-
+
if (status.marker->cd_info.find("preemph") != status.marker->cd_info.end()) {
- status.out << "PRE";
+ status.out << " PRE";
}
status.out << endl;
-
+
if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
- status.out << "ISRC " << status.marker->cd_info["isrc"] << endl;
-
+ 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) {
+ frames_to_cd_frames_string (buf, status.track_position);
+ status.out << " INDEX 00" << buf << endl;
}
- frames_to_cd_frames_string (buf, status.track_position);
- status.out << "INDEX 00" << buf << endl;
-
frames_to_cd_frames_string (buf, status.track_start_frame);
- status.out << "INDEX 01" << buf << endl;
-
+ status.out << " INDEX 01" << buf << endl;
+
status.index_number = 2;
status.track_number++;
}
gchar buf[18];
status.out << endl << "TRACK AUDIO" << endl;
-
+
if (status.marker->cd_info.find("scms") != status.marker->cd_info.end()) {
status.out << "NO ";
}
status.out << "COPY" << endl;
-
+
if (status.marker->cd_info.find("preemph") != status.marker->cd_info.end()) {
status.out << "PRE_EMPHASIS" << endl;
} else {
status.out << "NO PRE_EMPHASIS" << endl;
}
-
+
if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
status.out << "ISRC \"" << status.marker->cd_info["isrc"] << "\"" << endl;
}
+
+ status.out << "CD_TEXT {" << endl << " LANGUAGE 0 {" << endl;
+ status.out << " TITLE " << toc_escape_cdtext (status.marker->name()) << endl;
- status.out << "CD_TEXT {" << endl << " LANGUAGE 0 {" << endl << " TITLE \"" << 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;
- }
- if (status.marker->cd_info.find("string_composer") != status.marker->cd_info.end()) {
- status.out << " COMPOSER \"" << status.marker->cd_info["string_composer"] << "\"" << endl;
+ status.out << toc_escape_cdtext (status.marker->cd_info["performer"]) << endl;
+ } else {
+ status.out << "\"\"" << endl;
}
- if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
+ 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()) {
status.out << " ISRC \"";
status.out << status.marker->cd_info["isrc"].substr(0,2) << "-";
status.out << status.marker->cd_info["isrc"].substr(2,3) << "-";
status.out << status.marker->cd_info["isrc"].substr(5,2) << "-";
status.out << status.marker->cd_info["isrc"].substr(7,5) << "\"" << endl;
}
-
+
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;
-
+
frames_to_cd_frames_string (buf, status.track_start_frame - status.track_position);
status.out << "START" << buf << endl;
}
{
gchar buf[18];
- snprintf (buf, sizeof(buf), "INDEX %02d", cue_indexnum);
+ snprintf (buf, sizeof(buf), " INDEX %02d", cue_indexnum);
status.out << buf;
frames_to_cd_frames_string (buf, status.index_position);
status.out << buf << endl;
-
+
cue_indexnum++;
}
}
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);
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 */
-
- timespan_bounds = config_map.equal_range (current_timespan);
-
- for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
- it->second.channel_config->register_with_timespan (current_timespan);
- }
+ out = '"';
- /* connect stuff and start export */
+ for (std::string::const_iterator c = latin1_txt.begin(); c != latin1_txt.end(); ++c) {
- current_timespan->process_connection = session.ProcessExport.connect (sigc::mem_fun (*current_timespan, &ExportTimespan::process));
- session.start_audio_export (current_timespan->get_start(), realtime);
-}
-
-void
-ExportHandler::finish_timespan ()
-{
- current_timespan->process_connection.disconnect ();
-
- /* Register formats and filenames to relevant channel configs */
-
- export_status->total_formats = 0;
- export_status->format = 0;
-
- 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 if (isprint (*c)) {
+ out += *c;
+ } else {
+ snprintf (buf, sizeof (buf), "\\%03o", (int) (unsigned char) *c);
+ out += buf;
+ }
}
- /* Start writing files by doing a manual call to timespan_thread_finished */
-
- current_map_it = timespan_bounds.first;
- timespan_thread_finished ();
+ out += '"';
+
+ return out;
}
-void
-ExportHandler::timespan_thread_finished ()
+std::string
+ExportHandler::toc_escape_filename (const std::string& txt)
{
- channel_config_connection.disconnect();
+ std::string out;
- 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;
- }
-
- channel_config_connection = cc->FilesWritten.connect (sigc::mem_fun (*this, &ExportHandler::timespan_thread_finished));
- ++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);
+ 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;
}
-
- /* Start new timespan */
+ }
- start_timespan ();
+ 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
projects / ardour.git / blobdiff