X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fexport_handler.cc;h=20abc80de1995866ff8befb89228d04bd1e83845;hb=658bb3ccd43658de18fbd43cd91a8e66650e27a7;hp=0e22fdad27b9418c2f6eae07518dfbacf4a690e9;hpb=eec19ca7afde0da57b2a4d9abc6ef847e6924975;p=ardour.git diff --git a/libs/ardour/export_handler.cc b/libs/ardour/export_handler.cc index 0e22fdad27..20abc80de1 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 @@ -18,23 +18,27 @@ */ -#include +#include "ardour/export_handler.h" -#include -#include +#include +#include +#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "pbd/convert.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/session_metadata.h" + +#include "i18n.h" + +using namespace std; using namespace PBD; -using std::ofstream; namespace ARDOUR { @@ -52,259 +56,443 @@ ExportElementFactory::~ExportElementFactory () } -ExportElementFactory::TimespanPtr +ExportTimespanPtr ExportElementFactory::add_timespan () { - return TimespanPtr (new ExportTimespan (session.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.export_status, 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), - 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::push_back)); } ExportHandler::~ExportHandler () { - if (session.export_status.aborted()) { - for (std::list::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 ExportFinished 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 */ - ExportStatus & status = session.export_status; - status.init(); - std::set timespan_set; + export_status->init(); + std::set 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(); + } } - status.total_timespans = timespan_set.size(); + export_status->total_timespans = timespan_set.size(); /* Start export */ - realtime = rt; - - session.ExportFinished.connect (sigc::mem_fun (*this, &ExportHandler::finish_timespan)); - session.pre_export (); 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); } - - (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); + /* 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 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) { + 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; + ::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()); + } +} + +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 @@ -312,42 +500,45 @@ ExportHandler::write_track_info_cue (CDMarkerStatus & status) { 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++; } @@ -358,46 +549,52 @@ ExportHandler::write_track_info_toc (CDMarkerStatus & status) 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; } @@ -407,11 +604,11 @@ ExportHandler::write_index_info_cue (CDMarkerStatus & status) { 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++; } @@ -425,10 +622,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); @@ -439,108 +636,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) { - session.export_status.timespan++; - - if (config_map.empty()) { - session.finalize_audio_export(); - return; - } - - 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); + 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)); } - /* connect stuff and start export */ + out = '"'; - current_timespan->process_connection = session.ProcessExport.connect (sigc::mem_fun (*current_timespan, &ExportTimespan::process)); - session.start_audio_export (current_timespan->get_start(), realtime); -} + for (std::string::const_iterator c = latin1_txt.begin(); c != latin1_txt.end(); ++c) { -void -ExportHandler::finish_timespan () -{ - current_timespan->process_connection.disconnect (); - - /* Register formats and filenames to relevant channel configs */ - - session.export_status.total_formats = 0; - session.export_status.format = 0; - - for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) { - - session.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